Upload folder using huggingface_hub (part 2)

lib/use-available-models.ts

@@ -0,0 +1,58 @@
+"use client"
+
+import { useCallback, useEffect, useState } from "react"
+import { fetchModelsFromProvider, setDeploymentModel, setDiscoveredBrowserModel, type AISettings } from "@/lib/ai-settings"
+import { sanitizeModels, type AvailableModel } from "@/lib/model-selection"
+
+/** Shared registry for settings and the main UI. Discovery never changes selection. */
+export function useAvailableModels(settings: AISettings) {
+  const [models, setModels] = useState<AvailableModel[]>([])
+  const [defaultModel, setDefaultModel] = useState("")
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [revision, setRevision] = useState(0)
+  const refresh = useCallback(() => setRevision(n => n + 1), [])
+
+  useEffect(() => {
+    setModels([])
+    setDefaultModel("")
+    setDiscoveredBrowserModel("")
+  }, [settings.apiKey, settings.provider, settings.customBaseUrl])
+
+  useEffect(() => {
+    let cancelled = false
+    setLoading(true)
+    setError(null)
+    const timer = setTimeout(async () => {
+      try {
+        if (settings.apiKey.trim()) {
+          const items = await fetchModelsFromProvider(settings.provider, settings.apiKey.trim(), settings.customBaseUrl)
+          if (!cancelled) {
+            const available = sanitizeModels(items)
+            setModels(available)
+            setDiscoveredBrowserModel(available[0]?.id || "")
+          }
+        } else {
+          const response = await fetch("/api/v1/llm/models", { cache: "no-store" })
+          if (!response.ok) throw new Error(response.status === 401 ? "Sign in to retrieve models." : "Could not retrieve the provider model list.")
+          const data = await response.json()
+          if (!cancelled) {
+            setDeploymentModel(data.defaultModel || data.models?.[0]?.id || "")
+            setDefaultModel(data.defaultModel || "")
+            setModels(sanitizeModels(data.models, data.defaultModel))
+            setError(data.discoveryStatus === "available" ? null :
+              data.discoveryStatus === "auth_error" ? "Model provider authentication failed. Check OPENAI_API in deployment secrets." :
+              !data.configured ? "No model provider configured. Set OPENAI_URL, OPENAI_MODEL and OPENAI_API in the deployment environment." :
+              `Could not retrieve the provider model list. Using configured default model: ${data.defaultModel || "none"}`)
+          }
+        }
+      } catch {
+        if (!cancelled) setError("Could not retrieve the provider model list. Your selected model is unchanged.")
+      } finally {
+        if (!cancelled) setLoading(false)
+      }
+    }, 300)
+    return () => { cancelled = true; clearTimeout(timer) }
+  }, [settings.apiKey, settings.provider, settings.customBaseUrl, revision])
+  return { models, defaultModel, loading, error, refresh }
+}

lib/utils.ts

@@ -0,0 +1,40 @@
+import { clsx, type ClassValue } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+import { useState, useEffect } from 'react'
+import type { TextBlock } from '@/components/tile-card'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+/**
+ * Returns the platform modifier key symbol: '⌘' on macOS/iOS, 'Ctrl' elsewhere.
+ * Starts as '⌘' on the server (SSR) and corrects on the client after mount.
+ */
+export function useModKey(): string {
+  const [mod, setMod] = useState('⌘')
+  useEffect(() => {
+    const isMac = /Mac|iPhone|iPad|iPod/.test(navigator.platform)
+    if (!isMac) setMod('Ctrl')
+  }, [])
+  return mod
+}
+
+/**
+ * Returns the set of block IDs that are "connected" to the hovered block,
+ * based on shared category or influencedBy relationships.
+ * Used by tiling-area and kanban-area for the connection-hover dimming effect.
+ */
+export function getRelatedIds(hoveredId: string, blocks: TextBlock[]): Set<string> {
+  const hovered = blocks.find(b => b.id === hoveredId)
+  if (!hovered) return new Set()
+
+  const related = new Set<string>([hoveredId])
+  blocks.forEach(b => {
+    if (b.id === hoveredId) return
+    const hoveredPointsToB = hovered.influencedBy?.includes(b.id) ?? false
+    const bPointsToHovered = b.influencedBy?.includes(hoveredId) ?? false
+    if (hoveredPointsToB || bPointsToHovered) related.add(b.id)
+  })
+  return related
+}

lib/validation/index.ts

@@ -0,0 +1,29 @@
+import { KNOWLEDGE_EDGE_TYPES, KNOWLEDGE_NODE_KINDS, type EvidenceRecord, type HypothesisRecord, type KnowledgeEdge, type KnowledgeNode, type SynthesisResult, type Workspace } from "../domain/types"
+import { canPromote, qualificationForScore, scoreHypothesis } from "../scoring/hypothesis"
+export interface ValidationResult { valid:boolean; errors:string[] }
+const result=(errors:string[]):ValidationResult=>({valid:errors.length===0,errors})
+export function validateNode(n:KnowledgeNode){const e:string[]=[];if(!n?.id)e.push("node id required");if(!KNOWLEDGE_NODE_KINDS.includes(n?.kind))e.push("invalid node kind");if(!n?.workspaceId)e.push("workspace required");if(!n?.title)e.push("title required");if(!n?.provenance?.origin||!n.provenance.createdAt)e.push("provenance required");if(!Number.isInteger(n?.version)||n.version<1)e.push("positive version required");return result(e)}
+export function validateEdge(e:KnowledgeEdge,nodeIds?:Set<string>){const x:string[]=[];if(!e?.id||!e.sourceId||!e.targetId)x.push("edge identity/endpoints required");if(!KNOWLEDGE_EDGE_TYPES.includes(e?.type))x.push("invalid edge type");if(e.sourceId===e.targetId)x.push("self edge prohibited");if(nodeIds&&(!nodeIds.has(e.sourceId)||!nodeIds.has(e.targetId)))x.push("unresolved endpoint");if(!e?.provenance?.origin)x.push("edge provenance required");return result(x)}
+export function validateEvidence(e:EvidenceRecord){const x:string[]=[];if(!e.id||!e.workspaceId||!e.claim.trim())x.push("evidence identity/claim required");if(!Number.isInteger(e.strength)||e.strength<1||e.strength>5)x.push("strength must be 1..5");if(!Number.isFinite(e.weight)||e.weight<0)x.push("non-negative weight required");if(!e.sourceType)x.push("source type required");if(!e.ingestedAt||!e.provenance?.origin)x.push("evidence provenance required");return result(x)}
+export function validateTheme(n:KnowledgeNode){const x=validateNode(n).errors;if(n.kind!=="theme")x.push("theme kind required");if(typeof n.metadata.clusterKey!=="string")x.push("clusterKey required");return result(x)}
+export function validateSynthesis(s:SynthesisResult){const x:string[]=[];if(!/^S\d{3}$/.test(s.synthesisType))x.push("invalid synthesis type");if(!s.inputHash||!s.runId||!s.provenance?.origin)x.push("hash/run/provenance required");if(!Array.isArray(s.derivedFrom)||!Array.isArray(s.unknowns)||!Array.isArray(s.generatedHypotheses))x.push("synthesis arrays required");if(s.generationConfidence<0||s.generationConfidence>100)x.push("generation confidence out of range");return result(x)}
+export function validateHypothesis(h:HypothesisRecord){const x:string[]=[];if(!h.id||!h.statement.trim()||!h.hypothesisType)x.push("hypothesis identity/statement/type required");if(h.evidenceScore< -100||h.evidenceScore>100)x.push("score out of range");if(h.confidence<0||h.confidence>100)x.push("confidence out of range");if(h.qualification!==qualificationForScore(h.evidenceScore))x.push("qualification mismatch");return result(x)}
+export function validateExperiment(n:KnowledgeNode){const x=validateNode(n).errors;if(n.kind!=="experiment")x.push("experiment kind required");if(!n.metadata.threshold&&!n.metadata.passThreshold)x.push("experiment threshold required");return result(x)}
+export function validateDecision(n:KnowledgeNode){const x=validateNode(n).errors;if(n.kind!=="decision")x.push("decision kind required");if(!n.metadata.rationale)x.push("decision rationale required");return result(x)}
+export function validateBrainPromotion(w:Workspace){const x:string[]=[];for(const h of w.hypotheses.filter(h=>w.brain.promotedIds.includes(h.id)))if(!canPromote(h))x.push(`${h.id}: promotion gates not met`);return result(x)}
+export function validateAdjudications(w: Workspace): ValidationResult {
+  const errors: string[] = [], ids = new Set<string>()
+  const evidenceIds = new Set(w.evidence.flatMap(e => [e.id,...(e.aliases || [])]))
+  for (const a of w.adjudications || []) {
+    if (!a || !a.id || ids.has(a.id)) { errors.push("invalid/duplicate adjudication identity"); continue }
+    ids.add(a.id)
+    if (!w.hypotheses.some(h=>h.id===a.hypothesisId) || !evidenceIds.has(a.evidenceId)) errors.push(`adjudication ${a.id}: unresolved target`)
+    if (!["supports","contradicts","neutral","uncertain"].includes(a.relation) || !["direct","indirect","contextual"].includes(a.directness)) errors.push(`adjudication ${a.id}: invalid interpretation`)
+    if (![a.relevance,a.confidence].every(n=>Number.isFinite(n)&&n>=0&&n<=100)) errors.push(`adjudication ${a.id}: invalid interpretation certainty`)
+    if (!a.inputHash || !a.runId || !a.provider || !a.promptVersion || !a.schemaVersion || !Number.isFinite(Date.parse(a.createdAt)) || !Array.isArray(a.sourceEvidenceIds) || !Array.isArray(a.semanticContextIds)) errors.push(`adjudication ${a.id}: provenance required`)
+  }
+  return result(errors)
+}
+export function validateWorkspace(w:Workspace):ValidationResult{const errors:string[]=[];if(w.schemaVersion!==1)errors.push("unsupported schema");const ids=new Set(w.nodes.map(n=>n.id));for(const n of w.nodes)errors.push(...validateNode(n).errors.map(e=>`node ${n.id}: ${e}`));for(const e of w.edges)errors.push(...validateEdge(e,ids).errors.map(x=>`edge ${e.id}: ${x}`));const evid=new Set(w.evidence.map(e=>e.id));for(const e of w.evidence)errors.push(...validateEvidence(e).errors.map(x=>`evidence ${e.id}: ${x}`));for(const h of w.hypotheses){errors.push(...validateHypothesis(h).errors.map(x=>`hypothesis ${h.id}: ${x}`));for(const id of[...h.supportingEvidence,...h.contradictingEvidence])if(!evid.has(id))errors.push(`hypothesis ${h.id}: missing evidence ${id}`);const recomputed=scoreHypothesis(h,w.evidence,Date.parse(h.lastEvaluatedAt??w.updatedAt));if(recomputed.evidenceScore!==h.evidenceScore)errors.push(`hypothesis ${h.id}: score mismatch`)}for(const s of w.syntheses)errors.push(...validateSynthesis(s).errors.map(x=>`synthesis ${s.id}: ${x}`));errors.push(...validateBrainPromotion(w).errors,...validateAdjudications(w).errors);return result(errors)}
+export const validateGitSnapshot=(w:Workspace)=>validateWorkspace(w)
+export function validateWorkflowContracts(w:Workspace){const x:string[]=[];for(const t of w.researchTasks){if(!t.question||!t.objective||!Array.isArray(t.hypothesisIds))x.push(`task ${t.id}: invalid contract`);if(t.attempts>t.maxAttempts)x.push(`task ${t.id}: attempts exceeded`)}return result(x)}

next.config.mjs

@@ -0,0 +1,68 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  output: "standalone",
+  typescript: {
+    // Build errors are intentionally ignored — see CLAUDE.md
+    ignoreBuildErrors: true,
+  },
+  images: {
+    unoptimized: true,
+  },
+  async headers() {
+    return [
+      {
+        // Apply security headers to every route
+        source: "/(.*)",
+        headers: [
+          {
+            // Prevent framing (clickjacking)
+            key: "X-Frame-Options",
+            value: "DENY",
+          },
+          {
+            // Stop MIME-type sniffing
+            key: "X-Content-Type-Options",
+            value: "nosniff",
+          },
+          {
+            // Limit referrer info sent to third-party origins
+            key: "Referrer-Policy",
+            value: "strict-origin-when-cross-origin",
+          },
+          {
+            // Permissions policy — disable features the app doesn't use
+            key: "Permissions-Policy",
+            value: "camera=(), microphone=(), geolocation=()",
+          },
+          {
+            // Content Security Policy
+            // - default-src self: everything defaults to same-origin
+            // - script-src: Next.js needs 'unsafe-inline' + 'unsafe-eval' in dev;
+            //   nonces are the proper fix but require custom server — this is the
+            //   pragmatic baseline for a static/Vercel deployment.
+            // - connect-src: https: allows any user-configured custom endpoint
+            // - img-src: data URIs for inline images, blob for canvas exports
+            // - style-src unsafe-inline: Tailwind injects inline styles at runtime
+            key: "Content-Security-Policy",
+            value: [
+              "default-src 'self'",
+              "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://cloud.umami.is",
+              "style-src 'self' 'unsafe-inline'",
+              // Allow all HTTPS so user-configured custom base URLs (arbitrary
+              // OpenAI-compatible endpoints) are not blocked by CSP. Enumerating
+              // specific provider domains is incompatible with a custom-URL feature.
+              // http://localhost:* covers local providers (Ollama, LM Studio, vLLM).
+              "connect-src 'self' https: http://localhost:*",
+              "img-src 'self' data: blob: https://i.ytimg.com",
+              "font-src 'self' data:",
+              "frame-src https://www.youtube-nocookie.com https://www.youtube.com",
+              "frame-ancestors 'none'",
+            ].join("; "),
+          },
+        ],
+      },
+    ]
+  },
+}
+
+export default nextConfig

package.json

@@ -0,0 +1,90 @@
+{
+  "name": "nodepad",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint .",
+    "test": "tsx --test tests/**/*.test.ts",
+    "test:registry": "tsx --test tests/synthesis-registry.test.ts",
+    "validate:fixture": "tsx scripts/validate-fixture.ts",
+    "heartbeat": "tsx worker/heartbeat.ts",
+    "dev:all": "sh -c 'next dev & tsx worker/heartbeat.ts; wait'",
+    "test:predeploy:unit": "tsx --import ./scripts/predeploy-env.ts --test tests/**/*.test.ts",
+    "test:predeploy:smoke": "tsx scripts/predeploy-smoke.ts",
+    "test:predeploy:docker": "tsx scripts/predeploy-docker.ts",
+    "test:predeploy": "tsx scripts/predeploy.ts"
+  },
+  "dependencies": {
+    "@hookform/resolvers": "^3.9.1",
+    "@radix-ui/react-accordion": "1.2.12",
+    "@radix-ui/react-alert-dialog": "1.1.15",
+    "@radix-ui/react-aspect-ratio": "1.1.8",
+    "@radix-ui/react-avatar": "1.1.11",
+    "@radix-ui/react-checkbox": "1.3.3",
+    "@radix-ui/react-collapsible": "1.1.12",
+    "@radix-ui/react-context-menu": "2.2.16",
+    "@radix-ui/react-dialog": "1.1.15",
+    "@radix-ui/react-dropdown-menu": "2.1.16",
+    "@radix-ui/react-hover-card": "1.1.15",
+    "@radix-ui/react-label": "2.1.8",
+    "@radix-ui/react-menubar": "1.1.16",
+    "@radix-ui/react-navigation-menu": "1.2.14",
+    "@radix-ui/react-popover": "1.1.15",
+    "@radix-ui/react-progress": "1.1.8",
+    "@radix-ui/react-radio-group": "1.3.8",
+    "@radix-ui/react-scroll-area": "1.2.10",
+    "@radix-ui/react-select": "2.2.6",
+    "@radix-ui/react-separator": "1.1.8",
+    "@radix-ui/react-slider": "1.3.6",
+    "@radix-ui/react-slot": "1.2.4",
+    "@radix-ui/react-switch": "1.2.6",
+    "@radix-ui/react-tabs": "1.1.13",
+    "@radix-ui/react-toast": "1.2.15",
+    "@radix-ui/react-toggle": "1.1.10",
+    "@radix-ui/react-toggle-group": "1.1.11",
+    "@radix-ui/react-tooltip": "1.2.8",
+    "@tailwindcss/typography": "^0.5.19",
+    "@types/d3": "^7.4.3",
+    "autoprefixer": "^10.4.20",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "1.1.1",
+    "d3": "^7.9.0",
+    "date-fns": "4.1.0",
+    "embla-carousel-react": "8.6.0",
+    "framer-motion": "^11.18.0",
+    "input-otp": "1.4.2",
+    "lucide-react": "^0.564.0",
+    "next": "^16.2.2",
+    "next-themes": "^0.4.6",
+    "react": "19.2.4",
+    "react-day-picker": "9.13.2",
+    "react-dom": "19.2.4",
+    "react-hook-form": "^7.54.1",
+    "react-markdown": "^10.1.0",
+    "react-resizable-panels": "^2.1.7",
+    "recharts": "2.15.0",
+    "remark-gfm": "^4.0.1",
+    "sonner": "^1.7.1",
+    "tailwind-merge": "^3.3.1",
+    "vaul": "^1.1.2",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.2.0",
+    "@types/node": "^22",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "eslint": "^9.39.5",
+    "eslint-config-next": "^16.3.8",
+    "postcss": "^8.5",
+    "shadcn": "^4.0.0",
+    "tailwindcss": "^4.2.0",
+    "tsx": "^4.23.15",
+    "tw-animate-css": "1.3.3",
+    "typescript": "5.7.3"
+  }
+}

postcss.config.mjs

@@ -0,0 +1,8 @@
+/** @type {import('postcss-load-config').Config} */
+const config = {
+  plugins: {
+    '@tailwindcss/postcss': {},
+  },
+}
+
+export default config

product-eval/.claude-plugin/marketplace.json

@@ -0,0 +1,16 @@
+{
+  "name": "product-eval-marketplace",
+  "owner": {
+    "name": "Narek Gevorgyan"
+  },
+  "plugins": [
+    {
+      "name": "product-eval",
+      "source": "./",
+      "version": "0.14.2",
+      "description": "Evidence-gated product decisions: scope product context and evidence, then rank opportunities, decide on one bet, pressure-test plans, and write briefs/specs/scorecards.",
+      "homepage": "https://github.com/sparkline-ventures/product-eval",
+      "repository": "https://github.com/sparkline-ventures/product-eval"
+    }
+  ]
+}

product-eval/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "product-eval",
+  "version": "0.14.2",
+  "description": "Evidence-gated product decisions that start by scoping product context, evidence sources, and the desired deliverable before ranking opportunities, deciding on bets, pressure-testing plans, or writing outputs. Keeps evidence gathering, problem framing, Value/Confidence scoring, readiness gates, and audit files behind a simpler user experience.",
+  "author": {
+    "name": "Narek Gevorgyan"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/sparkline-ventures/product-eval",
+  "repository": "https://github.com/sparkline-ventures/product-eval",
+  "keywords": [
+    "product-management",
+    "prioritization",
+    "evidence",
+    "roadmap",
+    "decision-readiness",
+    "pressure-test"
+  ]
+}

product-eval/.codex-plugin/plugin.json

@@ -0,0 +1,36 @@
+{
+  "name": "product-eval",
+  "version": "0.14.2",
+  "description": "Evidence-gated product decisions that start by scoping product context, evidence sources, and the desired deliverable before ranking opportunities, deciding on bets, pressure-testing plans, or writing outputs.",
+  "author": {
+    "name": "Narek Gevorgyan"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/sparkline-ventures/product-eval",
+  "repository": "https://github.com/sparkline-ventures/product-eval",
+  "keywords": [
+    "product-management",
+    "prioritization",
+    "evidence",
+    "roadmap",
+    "decision-readiness",
+    "pressure-test"
+  ],
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "product-eval",
+    "shortDescription": "Scoped, evidence-gated product decisions",
+    "longDescription": "Set up product context and evidence sources, then rank opportunities, decide whether one bet is ready, pressure-test plans, and write briefs, build briefs, or scorecards from scoped product evidence.",
+    "developerName": "Narek Gevorgyan",
+    "category": "Productivity",
+    "capabilities": [
+      "Interactive",
+      "Write"
+    ],
+    "defaultPrompt": [
+      "Set up product-eval for my product.",
+      "Help me decide what to build next.",
+      "Help me prepare a decision report."
+    ]
+  }
+}

product-eval/.gitignore

@@ -0,0 +1,12 @@
+# OS / editor cruft
+.DS_Store
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+
+# Note: product-eval.plugin (the built package) is intentionally committed.
+# evals/checks/validate_plugin.py verifies it byte-matches the source tree,
+# so rebuild it after any change:  rm -f product-eval.plugin && \
+#   zip -r -X -q /tmp/pe.plugin . -x '*.plugin' && mv /tmp/pe.plugin product-eval.plugin

product-eval/CONNECTORS.md

@@ -0,0 +1,21 @@
+# Connectors
+
+This plugin is tool-agnostic in spirit: it works in terms of **evidence source categories**, and uses whatever you connect in each. Nothing is required, `discover-sources` detects what's available, CSV/upload is a universal fallback, and the plugin honestly caps decision confidence by the sources you actually have.
+
+The full category → example-tool mapping lives in `skills/discover-sources/references/source-catalog.md`. Summary:
+
+| Category | Example tools | Evidence role |
+|---|---|---|
+| Product / behavioral analytics | Amplitude, PostHog, Mixpanel, GA4 | first-party quantitative (strongest) |
+| Reliability / logs / errors | Datadog, Sentry, New Relic | first-party quantitative |
+| Support / tickets | Zendesk, Intercom, Freshdesk | ticket clusters |
+| Voice of customer / calls | Fireflies, Gong, churn & NPS surveys | transcripts / surveys |
+| CRM / sales | Salesforce, HubSpot | PFRs, lost-deal reasons |
+| Feedback / idea mgmt | Productboard, Canny, Aha! | feature requests |
+| Reviews / app stores | G2, Capterra, App/Play Store | third-party qualitative |
+| Community | Reddit, Hacker News, Discord | third-party qualitative |
+| Market / SEO / demand | Semrush, Ahrefs, SimilarWeb | market signal |
+| Issue trackers / changelogs | GitHub, GitLab | bug/feature signal + freshness checks |
+| Identity (CDP) | Segment, RudderStack | resolves the same user/account across the above |
+
+Connect any subset. The more first-party quantitative sources you connect (analytics, logs) and the more source-type diversity you have, the higher the confidence ceiling the plugin can reach.

product-eval/DATA-CONTRACT.md

@@ -0,0 +1,149 @@
+# Data Contract
+
+The file shapes every skill reads and writes inside an investigation scope at `.product-eval/<scope>/`. Keeping these stable is what lets skills hand off reliably. Files are markdown with YAML front-matter (or YAML lists), human-readable and machine-parseable.
+
+All paths below are relative to `.product-eval/<scope>/`, except `.product-eval/calibration.yml`, which is workspace-level. Exact computed fields (`weight`, `confidence`, `value`) are stored for audit, calibration, and scorecards. User-facing output should lead with bands and verdicts, not bare point estimates.
+
+## context.md (front-matter)
+```yaml
+---
+scope: tula-q3-eval
+job: evaluate            # explore | evaluate | validate | pressure-test | draft
+stage: evaluate          # sets the crispness bar: explore = lenient, evaluate/validate = strict
+product: "one-line description"
+north_star: "metric"
+personas: [admin, end_user, buyer]
+updated: 2026-06-26
+---
+```
+
+## evidence/<id>.md (one file per item)
+```yaml
+---
+id: E1
+claim: "state the pain, not the solution"
+source_type: product_analytics      # taxonomy below
+source_ref: "Amplitude › Activation funnel"
+persona: [client]
+funnel_stage: activation
+impact_type: activation
+strength: 5                # 1-5 (evidence-quality rubric)
+recency_days: 20
+weight: 12                 # computed: base-by-strength × recency factor (evidence-quality rubric)
+person_id: null
+account_id: acct_acme      # if identity-resolved
+corroborated_by: [E2]
+stale: false               # true if a changelog/release supersedes it
+---
+optional quote / notes
+```
+`source_type` taxonomy: product_analytics, support_ticket, sales_call, churn_survey, customer_interview, internal_data, internal_observation, feature_request, app_review, community_post, social_media, competitor_analysis, market_research, blog_or_article.
+
+## identities.md (list)
+```yaml
+- entity: acct_acme
+  grain: account                 # person | account
+  matched_records: [intercom:org_812, hubspot:acct_55, amplitude:grp_acme]
+  method: email_domain           # email | user_id | email_domain | fuzzy
+  match_confidence: high         # high | medium | low
+```
+
+## themes.md (list)
+```yaml
+- id: T1
+  name: "problem-framed, 5-10 words"
+  members: [E1, E2]
+  personas: [client]
+  distinct_accounts: 9
+  total_weight: 19
+  source_types: [product_analytics, support_ticket]
+  trend: up                      # emerging | up | flat | down | regression
+  corroboration: cross-source
+  contradictions: []
+  confidence: 67                 # computed (scoring-framework Confidence formula)
+  confidence_band: moderate      # low | moderate | high; preferred for chat output
+  gaps: ["spam vs ignored?", "funnel confound: agency-abandoned projects"]
+```
+
+## scores.md (list)
+```yaml
+- problem: T1
+  value: 72                      # 0-100 (scoring-framework: persona + funnel + frequency + competitive)
+  value_inputs: {persona: 15, funnel: 22, frequency: 25, competitive: 10}
+  value_band: high               # low | moderate | high; preferred for chat output
+  confidence: 67                 # 0-100 (scoring-framework Confidence formula)
+  confidence_band: moderate      # low | moderate | high; preferred for chat output
+  recommendation: "Run a research sprint"   # ranking tier from the score-to-recommendation matrix
+  rationale: "short reasoning"
+  override: null                 # {field, to, reason} if a human overrides
+```
+
+## decisions-log.md (append-only entries)
+```yaml
+- date: 2026-06-26
+  item: T1
+  event: readiness               # readiness | override | critique | drift | doc
+  verdict: "Run a research sprint"
+  confidence: 67
+  confidence_band: moderate
+  evidence: [E1, E2]
+  open: ["spam vs ignored", "funnel confound"]
+  contested: []
+  note: "short note"
+  outcome:                         # optional; appended later once the bet has closed, read by calibrate
+    problem_was_real: confirmed    # confirmed | refuted | partial (the calibration target)
+    solution_outcome: succeeded    # succeeded | failed | mixed (context only, does not tune constants)
+```
+
+`outcome` is added to a `readiness` entry only when the result is known (often a quarter later). `calibrate` reads it to score the constants: it tunes against `problem_was_real`, never `solution_outcome`. See the calibrate reference.
+
+## calibration.yml (workspace-level, optional)
+
+Lives at `.product-eval/calibration.yml`, workspace/product level, **not** per-scope. Overrides the shipped scoring defaults for this team/product; written by `calibrate`, read by the scoring skills on top of the defaults (anything omitted → shipped default). Schema in the calibrate reference. Absent → the universal defaults apply.
+
+## Computed fields, single sources of truth
+- `strength` (1-5) and `weight`, `skills/decision-readiness/references/evidence-quality.md`.
+- `confidence` (0-100), `skills/prioritize-backlog/references/scoring-framework.md` (the Confidence formula); stored exactly, displayed as `confidence_band` (Low/Moderate/High) with an optional bounded ±10 logged adjustment, and overridable via `.product-eval/calibration.yml`.
+- `value` (0-100) and the recommendation matrix, same scoring-framework reference; store exact `value`, display `value_band` in chat.
+
+Keep these schemas **additive**: skills may add fields, but must not rename or remove the ones above.
+
+## Validation (preflight conformance check)
+
+Skills trust each other's files. A malformed `evidence/`, `themes.md`, or `scores.md` must fail **loudly**, not degrade a downstream skill silently. So every consuming skill runs this preflight on the files it is about to read, and if any check fails it **stops and reports the exact file, field, and violation** rather than guessing past it or proceeding on a partial read. The checks are mechanical (no judgement), so a team can also run them as a script; this section is the single source of truth for what "conformant" means.
+
+**Band rule (used everywhere):** `band(x)` = Low if `x < 40`, Moderate if `40 <= x <= 69`, High if `x >= 70`. A stored `*_band` that disagrees with its stored number is a violation.
+
+**`evidence/<id>.md`**
+- Required keys present: `id`, `claim`, `source_type`, `strength`, `weight`, `stale`.
+- `id` is unique across the folder and matches the filename (`E1` in `E1.md`).
+- `source_type` is in the taxonomy above; `strength` is an integer 1 to 5; `weight` is a number `>= 0`; `recency_days` (if present) is a non-negative integer; `stale` is a boolean.
+- Every id in `corroborated_by` / `contradicts` resolves to a real evidence file.
+- `person_id` / `account_id`, when not null, resolve to an entity in `identities.md`.
+
+**`themes.md`**
+- Each theme has a unique `id`, a `name`, and a non-empty `members` list; every member resolves to a real evidence id.
+- `total_weight` equals the sum of member weights within rounding tolerance (`+/- 1`).
+- `source_types` is a subset of the taxonomy and is consistent with the members' source types.
+- `confidence` is present (0 to 100) and `confidence_band` satisfies the band rule.
+- Every id in `contradictions` resolves to a real evidence id.
+
+**`scores.md`**
+- Each entry's `problem` resolves to a theme id in `themes.md`.
+- `value` is 0 to 100 and `value_inputs` (`persona + funnel + frequency + competitive`) sums to `value`.
+- `value_band` and `confidence_band` satisfy the band rule.
+- `confidence` equals the same item's `confidence` in `themes.md` (one source of truth; readiness reads, it does not recompute a different number).
+- `recommendation` is one of the four verdicts (Decide now / Run a research sprint / Do not commit yet / Deprioritize) and matches what the score-to-recommendation matrix produces from (`value`, `confidence`), unless `override` is set and carries a reason.
+- `override` is null or has `{field, to, reason}`.
+
+**`decisions-log.md`**
+- Append-only: existing entries are never edited or deleted, only added to.
+- Each entry has `date`, `item`, `event`, `verdict`; `verdict` is in the four-verdict vocabulary; `event` is one of readiness / override / critique / drift / doc.
+- Every id in `evidence` / `contested` resolves to a real evidence id; `confidence_band` satisfies the band rule.
+- If `outcome` is present: `problem_was_real` is one of confirmed / refuted / partial, and `solution_outcome` (if present) is one of succeeded / failed / mixed.
+
+**Cross-file**
+- Every theme referenced by `scores.md` and `decisions-log.md` exists in `themes.md`.
+- `context.md` front-matter is present and has at least `scope`, `job`, `stage`.
+
+A passing preflight means the files are structurally sound and internally consistent; it does **not** vouch for whether the evidence is true. These checks are also implemented as an optional script, `scripts/validate_scope.py` (run `python scripts/validate_scope.py .product-eval/<scope>/`; needs PyYAML, exits non-zero on any violation), for CI or a pre-commit hook. `examples/activation-q3/` is a conformant fixture to test the checks against.

product-eval/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Narek Gevorgyan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

product-eval/README.md

@@ -0,0 +1,156 @@
+# product-eval
+
+**Find what's worth building next, with the evidence to prove it.**
+
+![A product-eval decision scorecard, generated from real support tickets](docs/scorecard.png)
+
+product-eval discovers and analyzes real customer problems from the tools where they already live: support tickets (Zendesk), CRM (Salesforce, HubSpot), issue trackers (Jira), product analytics, and reviews. It weighs the evidence, ranks what matters, and builds a prioritized, evidence-backed narrative of the problem worth solving.
+
+When a bet is ready, hand it off: export a brief or decision memo, or pass a build spec straight to a wireframing tool or an AI coding agent like Codex or Claude Code to ship an MVP. It runs in both Claude Code and Codex, and keeps the rigor (evidence weighting, readiness gates, audit files) behind a simple, outcome-first chat.
+
+It helps you answer four practical questions:
+
+- **Rank opportunities:** what should we build next?
+- **Decide on one bet:** is this worth building now, or do we need more proof?
+- **Pressure-test a plan:** where is this roadmap, PRD, or strategy weak before we commit?
+- **Write the output:** turn an approved decision into a brief, decision memo, build spec, or visual scorecard.
+
+The plugin keeps the rigor behind the scenes: it can discover available sources, gather and weight evidence, synthesize themes into buildable problems, score Value and Confidence, check decision readiness, and produce decision artifacts. Users should not need to choose those internal steps directly; they can describe the outcome they want.
+
+## Install
+
+![The product-eval plugin and its 14 skills](docs/install-page.png)
+
+**Cowork:** open the `.plugin` file. It renders as an installable card; click to add it.
+
+**Claude Code:** add this directory or its hosting repo as a plugin marketplace, then install:
+
+```text
+/plugin marketplace add <path-or-repo>
+/plugin install product-eval
+```
+
+**Codex:** this source is Codex-compatible through `.codex-plugin/plugin.json`. For Codex marketplace installation, place or symlink this folder as `<marketplace-root>/plugins/product-eval`, make sure that marketplace root is registered with Codex, then install `product-eval` from that marketplace. This repo cleanup does not create or edit global Codex marketplace config such as `~/.agents/plugins/marketplace.json`.
+
+**Quick install (either tool, no marketplace):** clone this repo and run `./install.sh`. It symlinks the 14 skills into `~/.claude/skills` and `~/.agents/skills`, so a later `git pull` keeps them current. In Codex, invoke a skill explicitly with `$<skill-name>` (for example `$start`).
+
+After installing, start by setting up the product context and decision:
+
+- "Set up product-eval for my product."
+- "Help me decide what to build next."
+- "Help me prepare a decision report."
+- "Pressure-test this Q3 roadmap using the evidence in our current scope."
+
+On first run, product-eval should ask for the product, target users, decision goal, scope/time horizon, available evidence sources, and the metric or business constraint that should shape the recommendation. It should not rank a vague area like "onboarding" or judge a bet like "SSO" until the product context and evidence plan are clear, unless you explicitly ask for an outside-in first pass with a lower confidence ceiling.
+
+Each step should end with a **Next move** that points toward delivery: upload the evidence, rank the candidates, run the readiness call, pressure-test the plan, write the decision memo, render the scorecard, or hand a build brief to Codex/design.
+
+## 60-second demo
+
+Point it at your customer signal and ask for the outcome. For example, hand it a support-ticket export in Codex:
+
+> "These are our support tickets. Can you analyze them?"
+
+product-eval runs the full chain (gather and weight evidence, synthesize themes, score Value and Confidence, run the readiness gate) and returns a ranked shortlist with a verdict on each.
+
+![Ranking opportunities from a Zendesk ticket export, in Codex](docs/demo-rank.png)
+
+Ask for a scorecard and it builds a self-contained, shareable HTML dashboard:
+
+> "Can you build a scorecard?"
+
+![product-eval generating a decision scorecard from the evidence](docs/demo-scorecard-codex.png)
+
+No data of your own? It also works top-down from a domain ("research the observability tooling space and tell me what's worth building"), reasoning from public signal and stating the resulting confidence ceiling. You can also open a ready-made example with zero setup: `examples/activation-q3/scorecard.html`.
+
+## Outcome Modes
+
+### Rank Opportunities
+
+Use this when you have a product area, evidence pile, or backlog and want a ranked shortlist. The plugin gathers or reads evidence, turns themes into buildable problem statements, scores each item by Value and Confidence, and returns a ranked table with the best next move.
+
+### Decide On One Bet
+
+Use this when you have one idea or problem and need a yes/no readiness call. The output leads with one of three outcomes:
+
+- **Decide now:** enough credible, diverse evidence to commit.
+- **Run a research sprint:** promising, but one specific proof gap should be closed first.
+- **Do not commit yet:** evidence is too weak, vague, stale, or single-source.
+
+Evidence math is kept visible for audit, but the decision is presented as a banded verdict rather than false precision.
+
+### Pressure-Test A Plan
+
+Use this when a roadmap, PRD, strategy, or bet already exists and you want the weak spots surfaced before committing. The output is blocking issues, suggestions, strengths, and a ready / needs-fixes / not-ready verdict.
+
+### Write The Output
+
+Use this after a decision has enough evidence or when you need a decision artifact:
+
+- **Opportunity Brief:** persuade and align humans around the problem, why now, impact, and ask.
+- **Decision Memo:** force a specific yes/no or option choice with criteria, metrics, tradeoffs, and deadline.
+- **Build Brief:** hand an approved decision to a code or design agent with testable requirements.
+- **Scorecard:** render ranked opportunities and verdicts as a shareable HTML dashboard.
+
+Use **critique** when you want an independent adversarial read of findings, a problem statement, a brief, or an FAQ. Use **pressure-test** when you already have a roadmap, PRD, plan, or bet and want to find the weak spots before committing.
+
+## Decision Model
+
+A decision passes a two-stage gate:
+
+1. **Sufficiency gate:** blocks if evidence weight is too low, all evidence is weak, evidence comes from only one independent source type, or the problem statement is vague.
+2. **Confidence verdict:** combines evidence weight, source diversity, contradictions, and Value into a recommendation.
+
+The chat output should show **bands first**: Low / Moderate / High Confidence and the resulting verdict. Exact Value and Confidence numbers are stored in `.product-eval/<scope>/` files for audit, calibration, and scorecards.
+
+## State: `.product-eval/<scope>/`
+
+All investigation state lives inside the user's project repo so it versions with code and can be reviewed in pull requests. Each investigation gets its own scope:
+
+```text
+.product-eval/
+  <scope>/
+    context.md          business context: product, north star, personas
+    sources.md          discovered sources, coverage, confidence ceiling
+    evidence/           one file per evidence item
+    identities.md       resolved person/account map across sources
+    themes.md           problem-framed themes with gaps and confidence
+    scores.md           exact Value + Confidence numbers for audit
+    decisions-log.md    append-only verdicts, overrides, drift, docs
+    snapshots/          timestamped copies for drift checks
+    docs/               briefs and decision memos
+    build/              agent-ready build/design briefs
+  calibration.yml       optional workspace-level scoring overrides
+```
+
+If `.product-eval/<scope>/` does not exist, the first run creates or proposes a short scope name. Skills degrade gracefully when files or sources are missing and state the resulting confidence ceiling.
+
+## Validation
+
+Run the plugin/package checks:
+
+```text
+python3 evals/checks/validate_plugin.py
+```
+
+Run the scope fixture validator after installing its dependency:
+
+```text
+python3 -m pip install -r scripts/requirements.txt
+python3 scripts/validate_scope.py examples/activation-q3
+```
+
+## Design Principles
+
+- **Outcome-first UX.** Users ask for Rank, Decide, Pressure-test, or Write; internal skills do the routing.
+- **Evidence as described, not ground truth.** The plugin rates credibility, diversity, and recency. It does not prove that every cited number is objectively true.
+- **Honest ceilings.** Every verdict states the maximum confidence the connected or provided sources allow and how to raise it.
+- **Evidence is weighted, not counted.** Strong first-party findings outweigh many weak anecdotes.
+- **Plain files, no daemon.** Skills read and write markdown/YAML under `.product-eval/<scope>/`; git provides history.
+
+## Roadmap
+
+- Calibration and reality-testing against more closed decisions.
+- Trigger eval hardening for the outcome modes and scorecard.
+- Cross-scope portfolio view: a roll-up of what is decided, waiting on evidence, or drifting across investigations.
+- Scale-out clustering for large evidence corpora when map-reduce synthesis is not enough.

product-eval/evals/checks/validate_plugin.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+"""Validate product-eval plugin source, evals, and packaged artifact."""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+import zipfile
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+PACKAGE = ROOT / "product-eval.plugin"
+PARENT_PACKAGE = ROOT.parent / "product-eval.plugin"
+CLAUDE_MANIFEST = ROOT / ".claude-plugin" / "plugin.json"
+CLAUDE_MARKETPLACE = ROOT / ".claude-plugin" / "marketplace.json"
+CODEX_MANIFEST = ROOT / ".codex-plugin" / "plugin.json"
+EXCLUDED_PATH_PREFIXES = (
+    "skills/critique/",
+    "evals/trigger/critique.json",
+    "evals/checks/validate_plugin.py",
+)
+IGNORED_SOURCE_NAMES = {".DS_Store", "product-eval.plugin"}
+LEGACY_PM_PATHS = (
+    ".pm/context",
+    ".pm/sources",
+    ".pm/evidence",
+    ".pm/identities",
+    ".pm/themes",
+    ".pm/scores",
+    ".pm/decisions-log",
+    ".pm/snapshots",
+)
+ALLOWED_FRONTMATTER = {"name", "description", "license", "allowed-tools", "metadata"}
+
+
+def fail(message: str) -> None:
+    print(f"ERROR: {message}", file=sys.stderr)
+    raise SystemExit(1)
+
+
+def load_json(path: Path):
+    try:
+        with path.open("r", encoding="utf-8") as handle:
+            return json.load(handle)
+    except Exception as exc:  # noqa: BLE001 - validation script should report exact file.
+        fail(f"invalid JSON in {path.relative_to(ROOT)}: {exc}")
+
+
+def read_archive_json(archive: zipfile.ZipFile, path: str):
+    try:
+        return json.loads(archive.read(path))
+    except Exception as exc:  # noqa: BLE001 - package validator should report exact file.
+        fail(f"packaged {path} missing or invalid: {exc}")
+
+
+def manifest_identity(payload: dict, label: str) -> tuple[str, str]:
+    name = payload.get("name")
+    version = payload.get("version")
+    if not isinstance(name, str) or not name.strip():
+        fail(f"{label} missing name")
+    if not isinstance(version, str) or not version.strip():
+        fail(f"{label} missing version")
+    return name, version
+
+
+def marketplace_entry(payload: dict, label: str, expected_name: str) -> dict:
+    plugins = payload.get("plugins")
+    if not isinstance(plugins, list) or not plugins:
+        fail(f"{label} missing plugins array")
+    for entry in plugins:
+        if isinstance(entry, dict) and entry.get("name") == expected_name:
+            return entry
+    if len(plugins) == 1 and isinstance(plugins[0], dict):
+        return plugins[0]
+    fail(f"{label} missing plugin entry for {expected_name!r}")
+
+
+def validate_identity(label: str, name: str, version: str, expected_name: str, expected_version: str) -> None:
+    if name != expected_name:
+        fail(f"{label} name mismatch: {name!r} != {expected_name!r}")
+    if version != expected_version:
+        fail(f"{label} version mismatch: {version!r} != {expected_version!r}")
+
+
+def validate_json() -> None:
+    for path in sorted((ROOT / "evals").rglob("*.json")):
+        load_json(path)
+
+
+def validate_manifest_identity() -> None:
+    if not CODEX_MANIFEST.exists():
+        fail("missing .codex-plugin/plugin.json")
+
+    claude_manifest = load_json(CLAUDE_MANIFEST)
+    codex_manifest = load_json(CODEX_MANIFEST)
+    marketplace = load_json(CLAUDE_MARKETPLACE)
+
+    expected_name, expected_version = manifest_identity(
+        claude_manifest, ".claude-plugin/plugin.json"
+    )
+    if ROOT.name != expected_name:
+        fail(f"plugin folder name {ROOT.name!r} does not match manifest name {expected_name!r}")
+
+    codex_name, codex_version = manifest_identity(codex_manifest, ".codex-plugin/plugin.json")
+    validate_identity(
+        ".codex-plugin/plugin.json",
+        codex_name,
+        codex_version,
+        expected_name,
+        expected_version,
+    )
+
+    entry = marketplace_entry(
+        marketplace, ".claude-plugin/marketplace.json", expected_name
+    )
+    entry_name = entry.get("name")
+    entry_version = entry.get("version")
+    validate_identity(
+        ".claude-plugin/marketplace.json plugin entry",
+        entry_name,
+        entry_version,
+        expected_name,
+        expected_version,
+    )
+
+
+def validate_route_coverage() -> None:
+    skills = sorted(path.parent.name for path in (ROOT / "skills").glob("*/SKILL.md"))
+    triggering = load_json(ROOT / "evals" / "triggering.json")
+    listed = sorted(triggering.get("skills", []))
+    if listed != skills:
+        fail(f"triggering.json skills do not match source skills: listed={listed}, source={skills}")
+
+    trigger_files = sorted(path.stem for path in (ROOT / "evals" / "trigger").glob("*.json"))
+    if trigger_files != skills:
+        fail(f"per-skill trigger evals do not match source skills: evals={trigger_files}, source={skills}")
+
+    for skill in skills:
+        cases = load_json(ROOT / "evals" / "trigger" / f"{skill}.json")
+        if not isinstance(cases, list) or not cases:
+            fail(f"missing trigger cases for {skill}")
+        positives = [case for case in cases if case.get("should_trigger") is True]
+        negatives = [case for case in cases if case.get("should_trigger") is False]
+        if not positives or not negatives:
+            fail(f"{skill} trigger eval must include positive and negative cases")
+
+
+def parse_simple_frontmatter(path: Path) -> dict[str, str]:
+    text = path.read_text(encoding="utf-8")
+    if not text.startswith("---\n"):
+        fail(f"{path.relative_to(ROOT)} missing YAML frontmatter")
+    end = text.find("\n---", 4)
+    if end == -1:
+        fail(f"{path.relative_to(ROOT)} has unterminated YAML frontmatter")
+
+    data: dict[str, str] = {}
+    for raw_line in text[4:end].splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if ":" not in line:
+            fail(f"{path.relative_to(ROOT)} has unsupported frontmatter line: {raw_line!r}")
+        key, value = line.split(":", 1)
+        key = key.strip()
+        if key not in ALLOWED_FRONTMATTER:
+            fail(f"{path.relative_to(ROOT)} has unexpected frontmatter key {key!r}")
+        data[key] = value.strip().strip('"').strip("'")
+    return data
+
+
+def validate_skill_frontmatter() -> None:
+    for skill_md in sorted((ROOT / "skills").glob("*/SKILL.md")):
+        rel = skill_md.relative_to(ROOT)
+        frontmatter = parse_simple_frontmatter(skill_md)
+        name = frontmatter.get("name")
+        description = frontmatter.get("description")
+        if not name:
+            fail(f"{rel} missing name")
+        if not re.fullmatch(r"[a-z0-9-]{1,64}", name):
+            fail(f"{rel} has invalid skill name {name!r}")
+        if name != skill_md.parent.name:
+            fail(f"{rel} name {name!r} does not match folder {skill_md.parent.name!r}")
+        if not description:
+            fail(f"{rel} missing description")
+        if "<" in description or ">" in description:
+            fail(f"{rel} description contains angle brackets")
+        if len(description) > 1024:
+            fail(f"{rel} description is too long ({len(description)} chars)")
+        lower_description = description.lower()
+        if "do not trigger" in lower_description or "deprecated" in lower_description:
+            fail(f"{rel} is still packaged as a routable skill but its description says not to trigger it")
+
+
+def validate_pm_paths() -> None:
+    for path in sorted(ROOT.rglob("*")):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(ROOT).as_posix()
+        if rel.startswith(EXCLUDED_PATH_PREFIXES):
+            continue
+        if path.name in IGNORED_SOURCE_NAMES:
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        for legacy in LEGACY_PM_PATHS:
+            if legacy in text:
+                fail(f"legacy unscoped path {legacy!r} found in {rel}")
+
+
+def source_files() -> set[str]:
+    files: set[str] = set()
+    for path in ROOT.rglob("*"):
+        if not path.is_file():
+            continue
+        if path.name in IGNORED_SOURCE_NAMES:
+            continue
+        files.add(path.relative_to(ROOT).as_posix())
+    return files
+
+
+def validate_package() -> None:
+    if PARENT_PACKAGE.exists():
+        fail(f"stale parent-level product-eval.plugin exists at {PARENT_PACKAGE}")
+    if not PACKAGE.exists():
+        fail("product-eval.plugin is missing")
+
+    source = source_files()
+    with zipfile.ZipFile(PACKAGE) as archive:
+        packaged_files = {
+            name
+            for name in archive.namelist()
+            if not name.endswith("/")
+            and Path(name).name not in IGNORED_SOURCE_NAMES
+        }
+        missing = sorted(source - packaged_files)
+        extra = sorted(packaged_files - source)
+        if missing or extra:
+            fail(f"package/source file mismatch: missing={missing}, extra={extra}")
+
+        for rel in sorted(source):
+            if archive.read(rel) != (ROOT / rel).read_bytes():
+                fail(f"package/source content mismatch: {rel}")
+
+        packaged_claude_manifest = read_archive_json(archive, ".claude-plugin/plugin.json")
+        packaged_codex_manifest = read_archive_json(archive, ".codex-plugin/plugin.json")
+        packaged_marketplace = read_archive_json(archive, ".claude-plugin/marketplace.json")
+
+    source_manifest = load_json(CLAUDE_MANIFEST)
+    expected_name, expected_version = manifest_identity(
+        source_manifest, ".claude-plugin/plugin.json"
+    )
+    for label, payload in (
+        ("packaged .claude-plugin/plugin.json", packaged_claude_manifest),
+        ("packaged .codex-plugin/plugin.json", packaged_codex_manifest),
+    ):
+        name, version = manifest_identity(payload, label)
+        validate_identity(label, name, version, expected_name, expected_version)
+
+    packaged_entry = marketplace_entry(
+        packaged_marketplace, "packaged .claude-plugin/marketplace.json", expected_name
+    )
+    validate_identity(
+        "packaged .claude-plugin/marketplace.json plugin entry",
+        packaged_entry.get("name"),
+        packaged_entry.get("version"),
+        expected_name,
+        expected_version,
+    )
+
+
+def main() -> None:
+    validate_json()
+    validate_manifest_identity()
+    validate_route_coverage()
+    validate_skill_frontmatter()
+    validate_pm_paths()
+    validate_package()
+    print("product-eval validation passed")
+
+
+if __name__ == "__main__":
+    main()

product-eval/evals/trigger/calibrate.json

@@ -0,0 +1,90 @@
+[
+  {
+    "query": "the confidence numbers feel too generous lately, can we tune the thresholds against these 8 past launches where we already know how they turned out",
+    "should_trigger": true
+  },
+  {
+    "query": "our model keeps flashing Go on stuff that later flopped. here are 12 shipped bets with what actually happened, fix the weights so it stops doing that",
+    "should_trigger": true
+  },
+  {
+    "query": "i think the gate cutoff is too loose. check it against past calls and tell me what number to move it to",
+    "should_trigger": true
+  },
+  {
+    "query": "validate the scoring against calibration/cases.md and flag where the verdict didn't match the real outcome",
+    "should_trigger": true
+  },
+  {
+    "query": "we've got a sheet of 15 old feature decisions with their actual results. use them to see if our evidence weights are even right",
+    "should_trigger": true
+  },
+  {
+    "query": "the crispness bar feels off, sanity-check it against the problems we actually shipped vs the ones we killed",
+    "should_trigger": true
+  },
+  {
+    "query": "three things it scored Research turned out great. that's a false-negative pattern, right? adjust the constants",
+    "should_trigger": true
+  },
+  {
+    "query": "backtest the scoring formula on our 2025 launches and recommend new threshold values",
+    "should_trigger": true
+  },
+  {
+    "query": "are the diversity factors and the gate threshold actually calibrated? here are 10 past decisions with known outcomes to test against",
+    "should_trigger": true
+  },
+  {
+    "query": "i don't trust the confidence math anymore. we have a stack of past bets and their outcomes, figure out where the scoring is systematically wrong",
+    "should_trigger": true
+  },
+  {
+    "query": "is it worth building SSO before our enterprise push, and do we even have enough data to make that call yet?",
+    "should_trigger": false
+  },
+  {
+    "query": "does the SSO bet have enough evidence behind it to greenlight, and what's still missing?",
+    "should_trigger": false
+  },
+  {
+    "query": "the confidence score on this one opportunity looks way too high. is it actually ready to decide or not?",
+    "should_trigger": false
+  },
+  {
+    "query": "rank these 8 feature ideas by what's most worth doing, we've got analytics plus support data",
+    "should_trigger": false
+  },
+  {
+    "query": "review our north-star and activation metrics for the month and flag what moved",
+    "should_trigger": false
+  },
+  {
+    "query": "our activation rate dropped 4 points last week, dig into the numbers and tell me why",
+    "should_trigger": false
+  },
+  {
+    "query": "poke holes in our Q3 roadmap before the leadership review on friday",
+    "should_trigger": false
+  },
+  {
+    "query": "grade how crisp this problem statement is: 'onboarding is bad'",
+    "should_trigger": false
+  },
+  {
+    "query": "has our top opportunity drifted since last month, did confidence actually improve or are we just spinning?",
+    "should_trigger": false
+  },
+  {
+    "query": "pull the recurring complaints from zendesk, our g2 reviews, and the churn survey and grade how solid each signal is",
+    "should_trigger": false
+  },
+  {
+    "query": "turn this pile of 30 user interview transcripts into the top themes ranked by how often they came up",
+    "should_trigger": false
+  },
+  {
+    "query": "build me a scorecard of this quarter's product metrics with the trends called out for the exec review",
+    "should_trigger": false
+  }
+]

product-eval/evals/trigger/critique.json

@@ -0,0 +1,90 @@
+[
+  {
+    "query": "grade how crisp this problem statement is: 'onboarding is bad'",
+    "should_trigger": true
+  },
+  {
+    "query": "is this one-liner actually sharp enough to take into a brief? 'we need better reporting'",
+    "should_trigger": true
+  },
+  {
+    "query": "poke holes in the findings from our churn investigation before I write them up",
+    "should_trigger": true
+  },
+  {
+    "query": "red-team this FAQ we drafted for the SSO opportunity brief, attack the weak answers",
+    "should_trigger": true
+  },
+  {
+    "query": "is this crisp enough? 'users want a faster dashboard' - score it and tell me what's missing",
+    "should_trigger": true
+  },
+  {
+    "query": "before we move from evidence to scoring, can someone fresh tear into our themes handoff and flag what's not ready",
+    "should_trigger": true
+  },
+  {
+    "query": "put these findings in front of a skeptical customer, a CFO, and an engineer and see where they fall apart",
+    "should_trigger": true
+  },
+  {
+    "query": "gate this opportunity brief before it advances to the decision stage, don't rubber-stamp it",
+    "should_trigger": true
+  },
+  {
+    "query": "my one-liner is 'reduce friction in checkout' - how tight is it and can you rewrite it sharper",
+    "should_trigger": true
+  },
+  {
+    "query": "give the conclusions in this synthesis doc a fresh adversarial read from someone who wasn't in the room",
+    "should_trigger": true
+  },
+  {
+    "query": "does this problem statement sit at the right altitude and actually name a persona, or is it mush?",
+    "should_trigger": true
+  },
+  {
+    "query": "poke holes in our Q3 roadmap before the leadership review on friday",
+    "should_trigger": false
+  },
+  {
+    "query": "stress-test our whole go-to-market plan for the enterprise tier before we commit to it",
+    "should_trigger": false
+  },
+  {
+    "query": "adversarially pressure-test this PRD and the bet behind it before we green-light the sprint",
+    "should_trigger": false
+  },
+  {
+    "query": "let's brainstorm some new directions for our analytics product, i want a sharp thinking partner",
+    "should_trigger": false
+  },
+  {
+    "query": "be my sparring partner and help me explore the problem space around activation, throw ideas at me",
+    "should_trigger": false
+  },
+  {
+    "query": "is it worth building SSO before our enterprise push? do we even have the data to call it?",
+    "should_trigger": false
+  },
+  {
+    "query": "synthesize the evidence we just pulled into the main problem-themes",
+    "should_trigger": false
+  },
+  {
+    "query": "i have a pile of 30 user-interview transcripts in a folder, pull out the main themes and insights for me",
+    "should_trigger": false
+  },
+  {
+    "query": "here are our raw survey responses and a stack of support tickets, make sense of them into findings",
+    "should_trigger": false
+  },
+  {
+    "query": "pull the recurring complaints from zendesk, our g2 reviews, and the churn survey and grade how solid each signal is",
+    "should_trigger": false
+  },
+  {
+    "query": "reprioritize the roadmap into now/next/later now that the SSO bet jumped the queue",
+    "should_trigger": false
+  }
+]

product-eval/evals/trigger/decision-readiness.json

@@ -0,0 +1,82 @@
+[
+  {
+    "query": "is it worth building SSO before our enterprise push? do we even have the data to call it?",
+    "should_trigger": true
+  },
+  {
+    "query": "do we have enough evidence to greenlight the in-app notifications rebuild, or are we just guessing?",
+    "should_trigger": true
+  },
+  {
+    "query": "are we ready to commit to the billing rework? tell me what's still missing before i say yes",
+    "should_trigger": true
+  },
+  {
+    "query": "we've got ~40 intercom tickets and an amplitude drop-off chart pointing at onboarding step 3. is that actually enough to decide to fix it?",
+    "should_trigger": true
+  },
+  {
+    "query": "honestly, what's the evidence behind shipping a mobile app this half? strong enough to pull the trigger or not?",
+    "should_trigger": true
+  },
+  {
+    "query": "before i tell eng to start, can you judge whether the dark-mode request has enough signal to justify it",
+    "should_trigger": true
+  },
+  {
+    "query": "i keep going back and forth on the API rate-limit feature. do we have the right to make this call yet, and what gaps should i close first?",
+    "should_trigger": true
+  },
+  {
+    "query": "gut check: is team-permissions a defensible build given what we actually know, or do we need more data before committing?",
+    "should_trigger": true
+  },
+  {
+    "query": "we think churned accounts wanted Slack alerts. is that conviction earned by the evidence, or wishful thinking? want a yes/no and the holes",
+    "should_trigger": true
+  },
+  {
+    "query": "my PM swears the saved-views feature is a slam dunk. can you sanity-check whether the evidence actually backs committing to it?",
+    "should_trigger": true
+  },
+  {
+    "query": "rank these 8 feature ideas by what's most worth doing, we have analytics + support data",
+    "should_trigger": false
+  },
+  {
+    "query": "which of our three enterprise bets has the strongest case? line them up and score them so we know where to spend",
+    "should_trigger": false
+  },
+  {
+    "query": "poke holes in our Q3 roadmap before the leadership review on friday",
+    "should_trigger": false
+  },
+  {
+    "query": "stress-test this PRD for the new onboarding flow before we commit to it next sprint",
+    "should_trigger": false
+  },
+  {
+    "query": "review our north-star and activation metrics for the month and flag what moved",
+    "should_trigger": false
+  },
+  {
+    "query": "how did retention and DAU trend last quarter vs target? give me the scorecard",
+    "should_trigger": false
+  },
+  {
+    "query": "i have a pile of 30 user-interview transcripts in a folder, pull out the main themes and insights for me",
+    "should_trigger": false
+  },
+  {
+    "query": "here are 200 raw survey responses, make sense of them and rank the findings by frequency",
+    "should_trigger": false
+  },
+  {
+    "query": "pull the recurring complaints from zendesk, our g2 reviews, and the churn survey and grade how solid each signal is",
+    "should_trigger": false
+  },
+  {
+    "query": "grade how crisp this problem statement is: 'onboarding is bad'",
+    "should_trigger": false
+  }
+]

product-eval/evals/trigger/design-test.json

@@ -0,0 +1,82 @@
+[
+  {
+    "query": "decision-readiness says run a research sprint for SSO — design the cheapest test to close the gap",
+    "should_trigger": true
+  },
+  {
+    "query": "how do we validate this billing bet before engineering starts building?",
+    "should_trigger": true
+  },
+  {
+    "query": "what's the cheapest experiment that would de-risk the notifications idea?",
+    "should_trigger": true
+  },
+  {
+    "query": "turn these readiness gaps into a concrete validation test with a pass fail threshold",
+    "should_trigger": true
+  },
+  {
+    "query": "we need a smoke test for the enterprise audit logs bet before committing the quarter",
+    "should_trigger": true
+  },
+  {
+    "query": "design a quick fake-door test to see if customers actually want scheduled csv exports",
+    "should_trigger": true
+  },
+  {
+    "query": "the idea is promising but evidence is thin; tell me the fastest research sprint to run",
+    "should_trigger": true
+  },
+  {
+    "query": "what would prove or disprove this onboarding hypothesis in two weeks?",
+    "should_trigger": true
+  },
+  {
+    "query": "give me the riskiest assumption, method, sample, instrumentation, duration and pass fail bar",
+    "should_trigger": true
+  },
+  {
+    "query": "de-risk this feature idea with a small experiment before we write a spec",
+    "should_trigger": true
+  },
+  {
+    "query": "pull the recurring complaints from zendesk and g2 and grade how solid each signal is",
+    "should_trigger": false
+  },
+  {
+    "query": "is SSO worth building before the enterprise push, do we have enough evidence?",
+    "should_trigger": false
+  },
+  {
+    "query": "rank these 8 feature ideas by what's most worth doing",
+    "should_trigger": false
+  },
+  {
+    "query": "write the opportunity brief for the approved billing decision",
+    "should_trigger": false
+  },
+  {
+    "query": "turn the approved decision into a build spec for claude code",
+    "should_trigger": false
+  },
+  {
+    "query": "pressure-test our Q3 roadmap before leadership review",
+    "should_trigger": false
+  },
+  {
+    "query": "what product-data sources do I have connected?",
+    "should_trigger": false
+  },
+  {
+    "query": "synthesize the evidence we pulled into problem themes",
+    "should_trigger": false
+  },
+  {
+    "query": "make a scorecard from the ranked opportunities",
+    "should_trigger": false
+  },
+  {
+    "query": "update our Now Next Later roadmap with the new SSO epic",
+    "should_trigger": false
+  }
+]

product-eval/evals/trigger/discover-sources.json

@@ -0,0 +1,86 @@
+[
+  {
+    "query": "what data do I even have to make product decisions? scan my connectors and tell me the confidence ceiling",
+    "should_trigger": true
+  },
+  {
+    "query": "scan my sources and tell me where product insights could realistically come from",
+    "should_trigger": true
+  },
+  {
+    "query": "what can I connect for product decisions right now? show me whats callable and whats missing",
+    "should_trigger": true
+  },
+  {
+    "query": "im starting fresh in this repo, before we frame anything map out where my product data actually lives",
+    "should_trigger": true
+  },
+  {
+    "query": "do i have intercom, amplitude, and zendesk hooked up? give me an inventory of my product-data sources and how strong each can get",
+    "should_trigger": true
+  },
+  {
+    "query": "whats the best decision confidence i can realistically hit given only the sources i have access to today?",
+    "should_trigger": true
+  },
+  {
+    "query": "build me a source map of my product evidence and flag what i'd have to upload as a CSV since it cant be connected",
+    "should_trigger": true
+  },
+  {
+    "query": "i just want the landscape of where signal could come from, not the actual data pulled yet",
+    "should_trigger": true
+  },
+  {
+    "query": "refresh the source inventory in .product-eval/onboarding/sources.md, i think i wired up linear and pendo since we last looked",
+    "should_trigger": true
+  },
+  {
+    "query": "new project, what's the ceiling on how confident any call could be with what i've got connected?",
+    "should_trigger": true
+  },
+  {
+    "query": "pull the recurring complaints from zendesk, our g2 reviews, and the churn survey and grade how solid each signal is",
+    "should_trigger": false
+  },
+  {
+    "query": "now that you know where my data lives, go ahead and pull everything from intercom and amplitude into the scope",
+    "should_trigger": false
+  },
+  {
+    "query": "collect the last 90 days of support tickets and reviews and normalize them so we can analyze",
+    "should_trigger": false
+  },
+  {
+    "query": "synthesize the evidence we just gathered into the main problem themes",
+    "should_trigger": false
+  },
+  {
+    "query": "i have a folder of 30 user-interview transcripts, pull out the main themes and insights for me",
+    "should_trigger": false
+  },
+  {
+    "query": "here are 200 raw survey responses we just got back, make sense of them and rank the findings",
+    "should_trigger": false
+  },
+  {
+    "query": "review our north-star and activation metrics for the month and flag what moved",
+    "should_trigger": false
+  },
+  {
+    "query": "put together our monthly product scorecard and call out the biggest trend changes",
+    "should_trigger": false
+  },
+  {
+    "query": "give me a competitive brief on Linear vs Jira for our sales battlecard",
+    "should_trigger": false
+  },
+  {
+    "query": "update our Now/Next/Later roadmap, move the billing rework to Next and add the SSO epic to Now",
+    "should_trigger": false
+  },
+  {
+    "query": "is it worth building SSO before our enterprise push? do we even have enough evidence to call it?",
+    "should_trigger": false
+  }
+]

product-eval/evals/trigger/drift-check.json

@@ -0,0 +1,26 @@
+[
+  {"query": "what changed since last month", "should_trigger": true},
+  {"query": "has this investigation drifted since we last looked at it", "should_trigger": true},
+  {"query": "compare the current state of the onboarding scope to the snapshot from last quarter and tell me what moved", "should_trigger": true},
+  {"query": "is the confidence trajectory on this bet actually improving, or are we just churning without new evidence coming in", "should_trigger": true},
+  {"query": "audit this scope before we re-decide — what's changed since the last decision was logged", "should_trigger": true},
+  {"query": "did our problem statement drift away from the evidence since the first version of the brief", "should_trigger": true},
+  {"query": "diff the billing investigation now versus the prior version — scores, evidence, and framing", "should_trigger": true},
+  {"query": "we snapshotted this scope a month ago — what evidence got added or retired, and how did Value and Confidence move", "should_trigger": true},
+  {"query": "are we accumulating real confidence on the activation problem over time, or has it just been flat churn", "should_trigger": true},
+  {"query": "show me what moved in this investigation since the last git ref", "should_trigger": true},
+  {"query": "has the narrative on the enterprise-churn bet been quietly reframed compared to the earlier brief", "should_trigger": true},
+  {"query": "set up a weekly digest of what moved across my investigations", "should_trigger": true},
+  {"query": "between the snapshot and now, which themes are new, which faded, and which got merged for this scope", "should_trigger": true},
+  {"query": "some of our evidence may have gone stale after the last release — compare against the prior snapshot and flag what got retired", "should_trigger": true},
+
+  {"query": "what's trending across the evidence we just gathered — which themes are getting worse month over month", "should_trigger": false},
+  {"query": "cluster the evidence in this scope into problem themes with confidence reasoning", "should_trigger": false},
+  {"query": "review our product metrics dashboard for the month and flag what moved on activation and retention", "should_trigger": false},
+  {"query": "our north-star metric dropped 8% this week, dig into what changed in the funnel", "should_trigger": false},
+  {"query": "rank these opportunities by value and confidence and tell me what to build next", "should_trigger": false},
+  {"query": "pull the latest zendesk tickets and g2 reviews into the scope", "should_trigger": false},
+  {"query": "do we have enough evidence to decide on the SSO bet yet", "should_trigger": false},
+  {"query": "let's brainstorm some new directions for our analytics product", "should_trigger": false},
+  {"query": "compare how our competitors solved onboarding versus how we did", "should_trigger": false}
+]

product-eval/evals/trigger/gather-evidence.json

@@ -0,0 +1,82 @@
+[
+  {
+    "query": "pull the recurring complaints from zendesk, our g2 reviews, and the churn survey and grade how solid each signal is",
+    "should_trigger": true
+  },
+  {
+    "query": "dig into the onboarding drop-off for me - go through intercom, amplitude, and our linear issues and tell me which findings actually hold up",
+    "should_trigger": true
+  },
+  {
+    "query": "collect data on the billing complaints across our support tickets and app store reviews, last 90 days",
+    "should_trigger": true
+  },
+  {
+    "query": "find signal for the slow-export problem - pull from wherever we have data and rate how strong each piece is",
+    "should_trigger": true
+  },
+  {
+    "query": "i exported ~150 intercom convos to a csv plus a g2 dump, parse them and turn them into evidence items with strengths",
+    "should_trigger": true
+  },
+  {
+    "query": "ok discover-sources is done, now actually go pull the tickets and analytics for the checkout friction area",
+    "should_trigger": true
+  },
+  {
+    "query": "scrape the recent reddit + community threads about our competitor and our own churn survey, normalize it and dedupe the same users across sources",
+    "should_trigger": true
+  },
+  {
+    "query": "we keep hearing notifications are noisy - go get me the actual receipts from pendo, the nps verbatims, and support, and tell me how much to trust each",
+    "should_trigger": true
+  },
+  {
+    "query": "pull every lost-deal reason from the crm and the support tickets tagged 'sso' and weight them into evidence cards",
+    "should_trigger": true
+  },
+  {
+    "query": "harvest signal on mobile crashes: error groups from datadog, app reviews, and the 40 support tickets, then strength-rate and resolve duplicate reporters",
+    "should_trigger": true
+  },
+  {
+    "query": "synthesize the evidence we just pulled into themes",
+    "should_trigger": false
+  },
+  {
+    "query": "what data do I even have to make product decisions? scan my connectors and tell me the confidence ceiling",
+    "should_trigger": false
+  },
+  {
+    "query": "i have a pile of 30 user-interview transcripts in a folder, pull out the main themes and insights for me",
+    "should_trigger": false
+  },
+  {
+    "query": "cluster this into the main problems - what patterns pop out of the signal we already collected?",
+    "should_trigger": false
+  },
+  {
+    "query": "give me a competitive brief on Linear vs Jira for our sales battlecard",
+    "should_trigger": false
+  },
+  {
+    "query": "do a teardown of Notion vs us - where are we losing on features and what do I put on the sales one-pager?",
+    "should_trigger": false
+  },
+  {
+    "query": "review our north-star and activation metrics for the month and flag what moved",
+    "should_trigger": false
+  },
+  {
+    "query": "which of our connected sources actually have usable product data, and how high can confidence get given what's available?",
+    "should_trigger": false
+  },
+  {
+    "query": "is it worth building SSO before our enterprise push? do we even have the data to call it?",
+    "should_trigger": false
+  },
+  {
+    "query": "new churn data came in - reshuffle our Now/Next/Later and tell me what slips to make room for the retention work",
+    "should_trigger": false
+  }
+]

product-eval/evals/trigger/pressure-test.json

@@ -0,0 +1,23 @@
+[
+  {"query": "poke holes in our Q3 roadmap before the leadership review on friday", "should_trigger": true},
+  {"query": "stress-test this bet before we commit the whole quarter to it", "should_trigger": true},
+  {"query": "pressure-test the PRD for the new billing system, where's it weak", "should_trigger": true},
+  {"query": "red-team our go-to-market plan for the enterprise launch", "should_trigger": true},
+  {"query": "challenge the assumptions baked into this roadmap, i think we're kidding ourselves", "should_trigger": true},
+  {"query": "before we greenlight building SSO, tear the plan apart and find the holes", "should_trigger": true},
+  {"query": "we're about to commit to the mobile rewrite, what are the hidden assumptions and scope risks", "should_trigger": true},
+  {"query": "give this plan a hard critic review, find the weak grounding before we ship it", "should_trigger": true},
+  {"query": "what could go wrong with this roadmap? surface the soft spots before we present it", "should_trigger": true},
+  {"query": "play devil's advocate on our Q4 plan, what are we not seeing", "should_trigger": true},
+
+  {"query": "let's brainstorm some new directions for our analytics product, i want a sharp thinking partner", "should_trigger": false},
+  {"query": "help me come up with fresh feature ideas for our onboarding flow, just spitball with me", "should_trigger": false},
+  {"query": "i want to explore the problem space around developer retention and generate some options", "should_trigger": false},
+  {"query": "be my thinking partner, let's ideate on what we could build next in the observability space", "should_trigger": false},
+  {"query": "grade how crisp this problem statement is: 'onboarding is bad'", "should_trigger": false},
+  {"query": "is it worth building SSO before our enterprise push? do we even have the data to call it?", "should_trigger": false},
+  {"query": "update our Now/Next/Later roadmap, move the billing rework to Next and add the SSO epic to Now", "should_trigger": false},
+  {"query": "write a PRD for the new CSV export feature so engineering can pick it up", "should_trigger": false},
+  {"query": "review our north-star and activation metrics for the month and flag what moved", "should_trigger": false},
+  {"query": "write the weekly stakeholder update for leadership about the platform migration", "should_trigger": false}
+]

product-eval/evals/trigger/prioritize-backlog.json

@@ -0,0 +1,23 @@
+[
+  {"query": "rank these 8 feature ideas by what's most worth doing, we have analytics and support data", "should_trigger": true},
+  {"query": "here's a list of 12 opportunities from our backlog, score them by value and confidence and tell me what to build", "should_trigger": true},
+  {"query": "prioritize my backlog for next quarter based on the evidence we've gathered", "should_trigger": true},
+  {"query": "i've got 15 problems competing for the same eng team, which ones are actually worth doing first", "should_trigger": true},
+  {"query": "score these opportunities and map each to a recommendation: build now, gather more, or drop", "should_trigger": true},
+  {"query": "we have evidence for some of these and basically nothing for others, rank them anyway and flag the low-confidence ones", "should_trigger": true},
+  {"query": "sequence these feature ideas by what's most worth doing given the data we have", "should_trigger": true},
+  {"query": "out of these 9 candidate bets, which should we tackle first, use value and confidence", "should_trigger": true},
+  {"query": "prioritize these: SSO, audit logs, SAML, bulk export, SCIM, rank by evidence-backed value", "should_trigger": true},
+  {"query": "what's the highest-leverage thing to build from this list of opportunities", "should_trigger": true},
+
+  {"query": "update our Now/Next/Later roadmap, move the billing rework to Next and add the SSO epic to Now", "should_trigger": false},
+  {"query": "reprioritize our roadmap, bump the mobile redesign up and push the API v2 work to later", "should_trigger": false},
+  {"query": "build me a Now / Next / Later roadmap view from scratch for the platform team", "should_trigger": false},
+  {"query": "the analytics dependency slipped two weeks, shift the roadmap timelines accordingly", "should_trigger": false},
+  {"query": "plan our next sprint, size the backlog against the team's capacity, we've got two people on PTO", "should_trigger": false},
+  {"query": "is it worth building SSO before our enterprise push? do we even have the data to call it?", "should_trigger": false},
+  {"query": "ok i've got ~200 intercom tickets exported and our amplitude funnel open, what should we actually build next quarter for onboarding", "should_trigger": false},
+  {"query": "review our north-star and activation metrics for the month and flag what moved", "should_trigger": false},
+  {"query": "write a PRD for the new CSV export feature so engineering can pick it up", "should_trigger": false},
+  {"query": "give me a competitive brief on Linear vs Jira for our sales battlecard", "should_trigger": false}
+]

product-eval/evals/trigger/scorecard.json

@@ -0,0 +1,82 @@
+[
+  {
+    "query": "make a scorecard from the ranked opportunities in this product-eval scope",
+    "should_trigger": true
+  },
+  {
+    "query": "turn the prioritization results into a visual dashboard i can share with leadership",
+    "should_trigger": true
+  },
+  {
+    "query": "show me the ranked opportunities as an interactive html scorecard with value, confidence, verdicts and gaps",
+    "should_trigger": true
+  },
+  {
+    "query": "after that backlog ranking, create the scorecard view with the value-confidence quadrant",
+    "should_trigger": true
+  },
+  {
+    "query": "render a product decision dashboard from .product-eval/onboarding/scores.md and decisions-log.md",
+    "should_trigger": true
+  },
+  {
+    "query": "give me a rich visual output for the readiness verdicts and opportunity ranking",
+    "should_trigger": true
+  },
+  {
+    "query": "build a shareable html page of the opportunities, confidence bands, evidence weight, and open gaps",
+    "should_trigger": true
+  },
+  {
+    "query": "make this prioritization easier to scan with cards, bands, and the top customer quotes",
+    "should_trigger": true
+  },
+  {
+    "query": "open a scorecard for the current investigation so PMs can sort and act on the top bets",
+    "should_trigger": true
+  },
+  {
+    "query": "can you generate the decision dashboard after running prioritize-backlog",
+    "should_trigger": true
+  },
+  {
+    "query": "review our north-star and activation metrics for the month and flag what moved",
+    "should_trigger": false
+  },
+  {
+    "query": "build me a scorecard of this quarter's product metrics with trends called out for the exec review",
+    "should_trigger": false
+  },
+  {
+    "query": "rank these 8 feature ideas by what's most worth doing, we have analytics and support data",
+    "should_trigger": false
+  },
+  {
+    "query": "is it worth building SSO before our enterprise push? do we have enough evidence to call it?",
+    "should_trigger": false
+  },
+  {
+    "query": "write the decision memo for the billing rework with options and success criteria",
+    "should_trigger": false
+  },
+  {
+    "query": "turn the approved decision into a spec i can hand straight to claude code",
+    "should_trigger": false
+  },
+  {
+    "query": "poke holes in our Q3 roadmap before the leadership review on friday",
+    "should_trigger": false
+  },
+  {
+    "query": "what data do I have connected for product decisions?",
+    "should_trigger": false
+  },
+  {
+    "query": "pull the recurring complaints from zendesk and g2 and grade how solid each signal is",
+    "should_trigger": false
+  },
+  {
+    "query": "draft the opportunity brief for the notifications problem",
+    "should_trigger": false
+  }
+]

product-eval/evals/trigger/start.json

@@ -0,0 +1,102 @@
+[
+  {
+    "query": "start",
+    "should_trigger": true
+  },
+  {
+    "query": "set up product-eval for my product",
+    "should_trigger": true
+  },
+  {
+    "query": "help me decide what to build next, but first ask me what context and data you need",
+    "should_trigger": true
+  },
+  {
+    "query": "help me prepare a decision report and set up the product context first",
+    "should_trigger": true
+  },
+  {
+    "query": "hey just installed this, help me get going — where do i even start?",
+    "should_trigger": true
+  },
+  {
+    "query": "what can this plugin actually do for me?",
+    "should_trigger": true
+  },
+  {
+    "query": "i want to build something in the observability tooling space but don't know what — help me find the real problems worth solving",
+    "should_trigger": true
+  },
+  {
+    "query": "should we build an AI changelog generator? honestly not sure, just point me in the right direction",
+    "should_trigger": true
+  },
+  {
+    "query": "i'm a PM at a fintech trying to find our next big bet — how does this thing even work?",
+    "should_trigger": true
+  },
+  {
+    "query": "help me figure out what to work on next, i don't even know which step to begin with",
+    "should_trigger": true
+  },
+  {
+    "query": "explore the API-monitoring market for me and show me where the gaps are",
+    "should_trigger": true
+  },
+  {
+    "query": "we want to figure out what to build next for our payments product — take it from the top",
+    "should_trigger": true
+  },
+  {
+    "query": "give me the lay of the land here and kick off an investigation into the CI/CD space",
+    "should_trigger": true
+  },
+  {
+    "query": "synthesize the evidence we just pulled into the main problem themes",
+    "should_trigger": false
+  },
+  {
+    "query": "cluster the signal we already gathered into a handful of themes",
+    "should_trigger": false
+  },
+  {
+    "query": "rank these 8 feature ideas by what's most worth building — we already have the analytics and support data",
+    "should_trigger": false
+  },
+  {
+    "query": "poke holes in our Q3 roadmap before the leadership review on friday",
+    "should_trigger": false
+  },
+  {
+    "query": "red-team this PRD and tell me where it falls apart before we commit",
+    "should_trigger": false
+  },
+  {
+    "query": "what product data do i even have to work with? scan my connectors and tell me the confidence ceiling",
+    "should_trigger": false
+  },
+  {
+    "query": "draft the opportunity brief for the notifications problem — both the narrative and the FAQ version",
+    "should_trigger": false
+  },
+  {
+    "query": "let's brainstorm some fresh directions for our analytics product, i want a sharp thinking partner",
+    "should_trigger": false
+  },
+  {
+    "query": "be my sounding board for a bit — i want to riff on new ideas for our developer tools",
+    "should_trigger": false
+  },
+  {
+    "query": "i've got 30 user-interview transcripts in a folder, pull out the main themes and insights for me",
+    "should_trigger": false
+  },
+  {
+    "query": "update our Now/Next/Later roadmap — move the billing rework to Next and add the SSO epic to Now",
+    "should_trigger": false
+  },
+  {
+    "query": "reprioritize the roadmap, that dependency slipped so push the search revamp to Later",
+    "should_trigger": false
+  }
+]

product-eval/evals/trigger/synthesize.json

@@ -0,0 +1,28 @@
+[
+  {"query": "synthesize the evidence we just pulled into themes", "should_trigger": true},
+  {"query": "ok we ran gather-evidence yesterday and pulled a bunch of tickets, reviews and analytics into the scope, now cluster all that into the main problem themes", "should_trigger": true},
+  {"query": "what are the recurring patterns across the evidence we collected for the onboarding scope, and how confident should we be in each theme", "should_trigger": true},
+  {"query": "group the weighted evidence items in .product-eval/onboarding/evidence into problem clusters for me", "should_trigger": true},
+  {"query": "we've got the signal gathered for this investigation, what's trending over time and what themes pop out", "should_trigger": true},
+  {"query": "turn the evidence we gathered into themes i can feed into prioritization", "should_trigger": true},
+  {"query": "now that the data's in for this scope, find the clusters and tell me where the gaps are", "should_trigger": true},
+  {"query": "what problem-themes emerge from all the evidence in this investigation, and which ones are getting worse month over month", "should_trigger": true},
+  {"query": "consolidate everything we collected on the billing pain into a few clear themes with confidence reasoning", "should_trigger": true},
+  {"query": "we pulled g2 reviews, intercom and amplitude into the scope last week, summarize the patterns into themes", "should_trigger": true},
+  {"query": "can you frame this up properly? right now all we've got is 'onboarding feels clunky' and i need it sharp enough that someone could actually build against it", "should_trigger": true},
+  {"query": "users keep dropping off somewhere in the signup flow. help me turn that into a real problem statement", "should_trigger": true},
+  {"query": "the eng lead handed me 'add SSO' as the ask, but that feels like a solution dressed up as a requirement. what's the real underlying problem here?", "should_trigger": true},
+  {"query": "everyone keeps saying 'make the dashboard better' and it's going nowhere because it's so broad. reshape it into an actual problem we could solve", "should_trigger": true},
+  {"query": "'enterprise customers churn' is one giant blob. split it into a few separate problems that are each small enough to build for", "should_trigger": true},
+
+  {"query": "i have a pile of 30 user-interview transcripts in a folder, pull out the main themes and insights for me", "should_trigger": false},
+  {"query": "just got back from 12 customer interviews, here are my raw notes, help me make sense of them and pull out themes", "should_trigger": false},
+  {"query": "we ran a survey and got 400 open-text responses in a csv, synthesize them into key insights ranked by frequency", "should_trigger": false},
+  {"query": "here's a dump of 200 support tickets exported from zendesk, what are the common themes and what should we prioritize", "should_trigger": false},
+  {"query": "pull the recurring complaints from zendesk, our g2 reviews, and the churn survey and grade how solid each signal is", "should_trigger": false},
+  {"query": "rank these 8 feature ideas by what's most worth doing, we have analytics and support data", "should_trigger": false},
+  {"query": "update our Now/Next/Later roadmap, move the billing rework to Next and add the SSO epic to Now", "should_trigger": false},
+  {"query": "review our north-star and activation metrics for the month and flag what moved", "should_trigger": false},
+  {"query": "let's brainstorm some new directions for our analytics product, i want a sharp thinking partner", "should_trigger": false},
+  {"query": "draft the opportunity brief for the notifications problem, both the narrative and the FAQ version", "should_trigger": false}
+]

product-eval/evals/trigger/to-build-brief.json

@@ -0,0 +1,90 @@
+[
+  {
+    "query": "the SSO bet got approved, can you turn it into a spec i can hand straight to claude code?",
+    "should_trigger": true
+  },
+  {
+    "query": "the notifications brief got approved yesterday — make it buildable, give me an agent-ready build spec",
+    "should_trigger": true
+  },
+  {
+    "query": "convert our approved opportunity brief into a build spec with given/when/then acceptance criteria",
+    "should_trigger": true
+  },
+  {
+    "query": "we signed off on the csv export bet — strip the prose and emit a structured spec claude code can just execute",
+    "should_trigger": true
+  },
+  {
+    "query": "run the design mode on the approved onboarding decision so i can hand the screen-by-screen breakdown to figma",
+    "should_trigger": true
+  },
+  {
+    "query": "we greenlit the billing rework, now produce the implementation spec for an AI builder with scope in/out and an MVP slice first",
+    "should_trigger": true
+  },
+  {
+    "query": "take this approved brief and make a figma-ready spec: every screen, its empty/loading/error states, and the primary CTA per view",
+    "should_trigger": true
+  },
+  {
+    "query": "decision's been signed off, just give me a literal testable build doc to drop into codex, no narrative",
+    "should_trigger": true
+  },
+  {
+    "query": "hand this approved billing brief to claude code with the data model, edge cases, success metrics and instrumentation",
+    "should_trigger": true
+  },
+  {
+    "query": "it passed readiness last week, can you turn it into something an agent can actually build from?",
+    "should_trigger": true
+  },
+  {
+    "query": "the export feature got the go-ahead — break it into screens and states for our designer to mock in figma",
+    "should_trigger": true
+  },
+  {
+    "query": "write a PRD for the new CSV export feature so engineering can pick it up",
+    "should_trigger": false
+  },
+  {
+    "query": "draft a feature spec with goals, non-goals and acceptance criteria so the devs can start the export work",
+    "should_trigger": false
+  },
+  {
+    "query": "draft the opportunity brief for the notifications problem, both the narrative and the FAQ version",
+    "should_trigger": false
+  },
+  {
+    "query": "write up the human-readable brief for the SSO opportunity — problem, why now, impact, the ask",
+    "should_trigger": false
+  },
+  {
+    "query": "write a decision memo for the SSO bet — options, falsifiable criteria, metrics, the ask and a deadline",
+    "should_trigger": false
+  },
+  {
+    "query": "put together the memo so leadership can decide on billing rework: the options, what would prove us wrong, and the deadline",
+    "should_trigger": false
+  },
+  {
+    "query": "is it worth building SSO before our enterprise push? do we even have the evidence to call it yet?",
+    "should_trigger": false
+  },
+  {
+    "query": "poke holes in our Q3 roadmap and the export PRD before the leadership review on friday",
+    "should_trigger": false
+  },
+  {
+    "query": "update our Now/Next/Later roadmap, move the billing rework to Next and add the SSO epic to Now",
+    "should_trigger": false
+  },
+  {
+    "query": "implement this approved figma design as react code for the onboarding flow",
+    "should_trigger": false
+  },
+  {
+    "query": "i have a pile of 30 user-interview transcripts in a folder, pull out the main themes and insights for me",
+    "should_trigger": false
+  }
+]

product-eval/evals/trigger/write-brief.json

@@ -0,0 +1,26 @@
+[
+  {"query": "draft the opportunity brief for the notifications problem, both the narrative and the FAQ version", "should_trigger": true},
+  {"query": "write the opportunity brief for the onboarding pain now that it passed the readiness gate", "should_trigger": true},
+  {"query": "draft the narrative version of the brief: problem, why now, impact, the ask", "should_trigger": true},
+  {"query": "write the FAQ version of the brief for the billing opportunity", "should_trigger": true},
+  {"query": "put together the human decision doc for leadership on the SSO opportunity", "should_trigger": true},
+  {"query": "we decided to move forward, write up the brief that explains the problem and what we're asking for", "should_trigger": true},
+  {"query": "turn this investigation into an opportunity brief i can circulate to the exec team", "should_trigger": true},
+  {"query": "write the brief: problem statement, why-now, expected impact, and the ask", "should_trigger": true},
+  {"query": "draft both versions of the opportunity brief for the churn problem, report and FAQ", "should_trigger": true},
+  {"query": "i need the opportunity brief for the analytics problem written up as a narrative for the team", "should_trigger": true},
+  {"query": "write the decision memo for the SSO bet, options, success/failure criteria, metrics scorecard, and an explicit ask for friday", "should_trigger": true},
+  {"query": "draft a recommendation memo on whether to build the in-app notifications center, weigh at least 3 options including do-nothing and recommend one", "should_trigger": true},
+  {"query": "i need an options memo for the onboarding rework: choices, tradeoffs, and what i'm asking the exec team to decide by july 15", "should_trigger": true},
+  {"query": "write the doc that forces a build-vs-buy call on the analytics pipeline, with options, what we'd measure, and a recommendation", "should_trigger": true},
+
+  {"query": "write a PRD for the new CSV export feature so engineering can pick it up", "should_trigger": false},
+  {"query": "turn this feature idea into a spec with goals, non-goals, and acceptance criteria for the eng team", "should_trigger": false},
+  {"query": "scope the bulk-export feature into a PRD with success metrics and phased milestones", "should_trigger": false},
+  {"query": "write the engineering spec for the new webhooks system so the devs can start", "should_trigger": false},
+  {"query": "turn the approved decision into a spec i can hand straight to claude code", "should_trigger": false},
+  {"query": "write the weekly stakeholder update for leadership about the platform migration", "should_trigger": false},
+  {"query": "give me a competitive brief on Linear vs Jira for our sales battlecard", "should_trigger": false},
+  {"query": "ok i've got ~200 intercom tickets exported and our amplitude funnel open, what should we actually build next quarter for onboarding", "should_trigger": false},
+  {"query": "review our north-star and activation metrics for the month and flag what moved", "should_trigger": false}
+]

product-eval/evals/triggering.json

@@ -0,0 +1,33 @@
+{
+  "purpose": "Routing / collision evals. Each query maps to the skill that SHOULD win. 'anthropic-pm:*' and 'none' mark cases that must NOT trigger one of our skills (near-misses against Anthropic's product-management plugin). To run the per-skill description optimizer (skill-creator run_loop.py), transform per skill: queries whose expected == <skill> are should_trigger:true, all others false.",
+  "skills": ["start","discover-sources","gather-evidence","synthesize","prioritize-backlog","decision-readiness","design-test","pressure-test","critique","write-brief","to-build-brief","scorecard","drift-check","calibrate"],
+  "cases": [
+    {"id": 1, "query": "ok i've got ~200 intercom tickets exported and our amplitude funnel open — what should we actually build next quarter for onboarding?", "expected": "start", "note": "setup, then evaluate job and chains"},
+    {"id": 2, "query": "is it worth building SSO before our enterprise push? do we even have the data to call it?", "expected": "decision-readiness"},
+    {"id": 3, "query": "rank these 8 feature ideas by what's most worth doing — we have analytics + support data", "expected": "prioritize-backlog"},
+    {"id": 4, "query": "synthesize the evidence we just pulled into themes", "expected": "synthesize"},
+    {"id": 5, "query": "i have a pile of 30 user-interview transcripts in a folder, pull out the main themes and insights for me", "expected": "anthropic-pm:synthesize-research", "note": "raw research outside our pipeline — must NOT trigger synthesize"},
+    {"id": 6, "query": "poke holes in our Q3 roadmap before the leadership review on friday", "expected": "pressure-test"},
+    {"id": 7, "query": "let's brainstorm some new directions for our analytics product, i want a sharp thinking partner", "expected": "anthropic-pm:product-brainstorming", "note": "generative — must NOT trigger pressure-test/critique"},
+    {"id": 8, "query": "update our Now/Next/Later roadmap — move the billing rework to Next and add the SSO epic to Now", "expected": "anthropic-pm:roadmap-update", "note": "roadmap edit — must NOT trigger prioritize-backlog"},
+    {"id": 9, "query": "write a PRD for the new CSV export feature so engineering can pick it up", "expected": "anthropic-pm:write-spec", "note": "engineering spec — must NOT trigger write-brief"},
+    {"id": 10, "query": "draft the opportunity brief for the notifications problem — both the narrative and the FAQ version", "expected": "write-brief"},
+    {"id": 11, "query": "grade how crisp this problem statement is: 'onboarding is bad'", "expected": "critique", "note": "crispness grader"},
+    {"id": 12, "query": "what data do I even have to make product decisions? scan my connectors and tell me the confidence ceiling", "expected": "discover-sources"},
+    {"id": 13, "query": "i want to build something in the observability tooling space but not sure what — find the real problems worth solving", "expected": "start", "note": "explore job"},
+    {"id": 14, "query": "turn the approved decision into a spec i can hand straight to claude code", "expected": "to-build-brief"},
+    {"id": 15, "query": "has our top opportunity drifted since last month? did confidence actually improve or are we spinning?", "expected": "drift-check"},
+    {"id": 16, "query": "the confidence numbers feel too generous — tune the thresholds against these 8 past launches we know the outcomes of", "expected": "calibrate"},
+    {"id": 17, "query": "give me a competitive brief on Linear vs Jira for our sales battlecard", "expected": "anthropic-pm:competitive-brief", "note": "must NOT trigger gather-evidence/pressure-test"},
+    {"id": 18, "query": "review our north-star and activation metrics for the month and flag what moved", "expected": "anthropic-pm:metrics-review", "note": "must NOT trigger drift-check"},
+    {"id": 19, "query": "write the weekly stakeholder update for leadership about the platform migration", "expected": "anthropic-pm:stakeholder-update", "note": "none of ours"},
+    {"id": 20, "query": "pull the recurring complaints from zendesk, our g2 reviews, and the churn survey and grade how solid each signal is", "expected": "gather-evidence"},
+    {"id": 21, "query": "decision-readiness says run a research sprint for SSO — design the cheapest test to close the gap", "expected": "design-test"},
+    {"id": 22, "query": "make a scorecard from the ranked opportunities in this product-eval scope", "expected": "scorecard"},
+    {"id": 23, "query": "write the decision memo for the SSO bet — options, metrics, falsifiable criteria, and the explicit ask", "expected": "write-brief"},
+    {"id": 24, "query": "what should we build next for activation if we have a csv of support tickets and some funnel data?", "expected": "start", "note": "Rank opportunities outcome with setup"},
+    {"id": 25, "query": "users keep dropping off somewhere in signup; turn that into a real problem statement", "expected": "synthesize", "note": "problem framing is now inside synthesize"},
+    {"id": 26, "query": "set up product-eval for my product", "expected": "start", "note": "first-run onboarding"},
+    {"id": 27, "query": "help me prepare a decision report and ask me what context you need first", "expected": "start", "note": "write outcome but missing source/audience setup"}
+  ]
+}

product-eval/examples/README.md

@@ -0,0 +1,39 @@
+# Examples
+
+## `activation-q3/`: a complete sample investigation
+
+A synthetic, self-contained investigation scope for the fictional product "Pulse" (a B2B product-analytics workspace). It mirrors exactly what the plugin writes to `.product-eval/<scope>/` in a real project, and it serves two purposes:
+
+1. **A `scorecard` reference output.** `activation-q3/scorecard.html` is the rendered decision scorecard for this scope: open it in a browser to see the KPI cards, the Value by Confidence quadrant, the four color-coded verdict cards (with verbatim quotes, top complaint, the ask, and "why it ranks here"), the glossary, and the honest footer.
+2. **A conformance fixture.** Every file conforms to `DATA-CONTRACT.md`, and every number was computed from the shipped scoring defaults, so it is the fixture the validation preflight (and `scripts/validate_scope.py`) is tested against.
+
+### What's inside
+
+| File | Role |
+|---|---|
+| `context.md` | scope front-matter (product, north star, personas) |
+| `evidence/E1.md` ... `E12.md` | 12 normalized, weighted evidence items (E12 is a flagged contradiction) |
+| `identities.md` | resolved cross-system identities (same account across Zendesk + CRM + analytics; same email across Zendesk + CRM) |
+| `themes.md` | 4 problem-framed themes with computed confidence |
+| `scores.md` | Value/Confidence and a recommendation per theme |
+| `decisions-log.md` | readiness verdicts (append-only) |
+| `scorecard.html` | the rendered scorecard |
+
+### The four opportunities (one of each verdict)
+
+| Theme | Value | Confidence | Verdict |
+|---|---|---|---|
+| T1 New admins can't finish setup without CS help | 72 (High) | 89 (High) | **Decide now** |
+| T2 Teams can't share saved views across the org | 70 (High) | 63 (Moderate) | **Run a research sprint** |
+| T3 Alert noise pushes users to mute critical alerts | 60 (Moderate) | 24 (Low) | **Do not commit yet** |
+| T4 Users want a dark-mode dashboard | 35 (Low) | 12 (Low) | **Deprioritize** |
+
+T3 shows how a directly contradicting first-party signal (E12) drives confidence below the gate even when value is real.
+
+### Verify it
+
+```
+python ../scripts/validate_scope.py activation-q3/      # -> OK (needs PyYAML)
+```
+
+All numbers are illustrative. No real customer data.

product-eval/examples/activation-q3/context.md

@@ -0,0 +1,13 @@
+---
+scope: activation-q3
+job: evaluate
+stage: evaluate
+product: "Pulse, a B2B product-analytics workspace for SaaS teams"
+north_star: "weekly activated workspaces"
+personas: [admin, end_user, buyer]
+updated: 2026-06-29
+---
+
+Synthetic example investigation shipped with the product-eval plugin. All numbers
+are illustrative and were computed from the shipped scoring defaults so the files
+can double as a validation fixture. No real customer data.

product-eval/examples/activation-q3/decisions-log.md

@@ -0,0 +1,34 @@
+# Decisions log for activation-q3 (append-only)
+
+- date: 2026-06-29
+  item: T1
+  event: readiness
+  verdict: "Decide now"
+  confidence: 89
+  confidence_band: high
+  evidence: [E1, E2, E3, E4]
+  open: ["which connector is worst", "trial-spam check on the 38%"]
+  contested: []
+  note: "Passed the sufficiency gate; first-party analytics + tickets + interviews + churn agree."
+
+- date: 2026-06-29
+  item: T2
+  event: readiness
+  verdict: "Run a research sprint"
+  confidence: 63
+  confidence_band: moderate
+  evidence: [E5, E6, E7]
+  open: ["how many seats would share", "no first-party re-creation data"]
+  contested: []
+  note: "High value, but the cheapest validating test should run before committing (see design-test)."
+
+- date: 2026-06-29
+  item: T3
+  event: readiness
+  verdict: "Do not commit yet"
+  confidence: 24
+  confidence_band: low
+  evidence: [E8, E9]
+  open: ["measure actual mute-rate"]
+  contested: [E12]
+  note: "Hypothesis contradicted by first-party analytics; do not act until measured."

product-eval/examples/activation-q3/evidence/E1.md

@@ -0,0 +1,17 @@
+---
+id: E1
+claim: "38% of new workspaces never finish setup, dropping at the data-source connection step (up from 24% last quarter)"
+source_type: product_analytics
+source_ref: "Amplitude > Activation funnel"
+persona: [admin]
+funnel_stage: activation
+impact_type: activation
+strength: 5
+recency_days: 20
+weight: 12
+person_id: null
+account_id: acct_acme
+corroborated_by: [E2, E3]
+stale: false
+---
+Funnel: signup to first-connected-source. The cliff is the integrations step, not signup.

product-eval/examples/activation-q3/evidence/E10.md

@@ -0,0 +1,17 @@
+---
+id: E10
+claim: "6 scattered requests for a dark-mode dashboard over the past year"
+source_type: feature_request
+source_ref: "Productboard > misc (6 requests)"
+persona: [end_user]
+funnel_stage: engagement
+impact_type: engagement
+strength: 2
+recency_days: 300
+weight: 1
+person_id: null
+account_id: null
+corroborated_by: []
+stale: false
+---
+Low frequency, spread thin over 12 months.

product-eval/examples/activation-q3/evidence/E11.md

@@ -0,0 +1,17 @@
+---
+id: E11
+claim: "Occasional app-store style reviews ask for dark mode"
+source_type: app_review
+source_ref: "Capterra (sparse)"
+persona: [end_user]
+funnel_stage: engagement
+impact_type: engagement
+strength: 2
+recency_days: 200
+weight: 1
+person_id: null
+account_id: null
+corroborated_by: []
+stale: false
+---
+Aesthetic preference, no business-pain signal.

product-eval/examples/activation-q3/evidence/E12.md

@@ -0,0 +1,19 @@
+---
+id: E12
+claim: "Alert-channel engagement is flat quarter over quarter, not declining"
+source_type: product_analytics
+source_ref: "Amplitude > Alerts engagement"
+persona: [end_user]
+funnel_stage: engagement
+impact_type: engagement
+strength: 4
+recency_days: 25
+weight: 7
+person_id: null
+account_id: null
+corroborated_by: []
+stale: false
+contradicts: [E8]
+---
+Direct first-party data that contradicts the "users are muting alerts" hypothesis (E8).
+Kept and flagged: this is the unresolved material contradiction that drives T3's confidence penalty.

product-eval/examples/activation-q3/evidence/E2.md

@@ -0,0 +1,17 @@
+---
+id: E2
+claim: "Admins get stuck at the data-source connection step and open tickets to finish setup"
+source_type: support_ticket
+source_ref: "Zendesk > tag:onboarding (27 tickets / 6 weeks)"
+persona: [admin]
+funnel_stage: activation
+impact_type: activation
+strength: 4
+recency_days: 30
+weight: 7
+person_id: null
+account_id: acct_acme
+corroborated_by: [E1, E3]
+stale: false
+---
+"I connected Postgres but nothing shows up, what am I missing?" Recurring across 27 tickets.

product-eval/examples/activation-q3/evidence/E3.md

@@ -0,0 +1,17 @@
+---
+id: E3
+claim: "In 4 onboarding calls, admins needed CS hand-holding to complete setup"
+source_type: customer_interview
+source_ref: "Onboarding calls (4 accounts)"
+persona: [admin]
+funnel_stage: activation
+impact_type: activation
+strength: 4
+recency_days: 15
+weight: 7
+person_id: person_jordan
+account_id: acct_acme
+corroborated_by: [E1, E2]
+stale: false
+---
+"We almost gave up before your CS person walked us through the connectors."

product-eval/examples/activation-q3/evidence/E4.md

@@ -0,0 +1,17 @@
+---
+id: E4
+claim: "3 churned accounts named 'never got it set up' as the reason for leaving"
+source_type: churn_survey
+source_ref: "Churn survey Q2 (3 of 11 responses)"
+persona: [admin, buyer]
+funnel_stage: retention
+impact_type: retention
+strength: 4
+recency_days: 120
+weight: 5
+person_id: null
+account_id: null
+corroborated_by: []
+stale: false
+---
+Setup friction reads through to retention, not just activation.

product-eval/examples/activation-q3/evidence/E5.md

@@ -0,0 +1,17 @@
+---
+id: E5
+claim: "19 feature requests asking for views/dashboards shared across the whole org"
+source_type: feature_request
+source_ref: "Productboard > top requests"
+persona: [admin, end_user]
+funnel_stage: expansion
+impact_type: expansion
+strength: 3
+recency_days: 25
+weight: 4
+person_id: null
+account_id: null
+corroborated_by: [E6, E7]
+stale: false
+---
+Today views are per-user; teams rebuild the same view repeatedly.

product-eval/examples/activation-q3/evidence/E6.md

@@ -0,0 +1,17 @@
+---
+id: E6
+claim: "Two mid-market prospects asked about org-shared views during deals"
+source_type: sales_call
+source_ref: "Gong > deal notes (2 deals)"
+persona: [buyer]
+funnel_stage: expansion
+impact_type: competitive
+strength: 4
+recency_days: 18
+weight: 7
+person_id: null
+account_id: acct_northwind
+corroborated_by: [E5]
+stale: false
+---
+Raised as a 'will our team adopt this' question, an expansion signal.

product-eval/examples/activation-q3/evidence/E7.md

@@ -0,0 +1,17 @@
+---
+id: E7
+claim: "A G2 review wants team-shared saved views"
+source_type: app_review
+source_ref: "G2 review (4-star)"
+persona: [end_user]
+funnel_stage: expansion
+impact_type: competitive
+strength: 3
+recency_days: 140
+weight: 3
+person_id: null
+account_id: null
+corroborated_by: [E5]
+stale: false
+---
+"Love it solo, but my team can't see my views."

product-eval/examples/activation-q3/evidence/E8.md

@@ -0,0 +1,17 @@
+---
+id: E8
+claim: "CS suspects users mute alert channels because of noise; one large account muted everything"
+source_type: internal_observation
+source_ref: "CS Slack thread + 1 account"
+persona: [end_user]
+funnel_stage: retention
+impact_type: retention
+strength: 3
+recency_days: 22
+weight: 4
+person_id: null
+account_id: acct_acme
+corroborated_by: []
+stale: false
+---
+Hypothesis, not measured. Flagged as contradicted by E-contra below.

product-eval/examples/activation-q3/evidence/E9.md

@@ -0,0 +1,17 @@
+---
+id: E9
+claim: "A low-engagement community thread complains about alert spam"
+source_type: community_post
+source_ref: "Reddit r/devops (low engagement)"
+persona: [end_user]
+funnel_stage: engagement
+impact_type: cost
+strength: 2
+recency_days: 150
+weight: 1
+person_id: null
+account_id: null
+corroborated_by: []
+stale: false
+---
+Thin signal; included for completeness.

product-eval/examples/activation-q3/identities.md

@@ -0,0 +1,25 @@
+# Resolved identities for activation-q3
+# Shows the cross-system mapping: the same account/person stitched across
+# Zendesk + CRM + analytics so multi-touchpoint signal collapses to one entity.
+
+- entity: acct_acme
+  grain: account
+  matched_records: [zendesk:org_1183, hubspot:acct_55, amplitude:grp_acme]
+  method: email_domain        # acme.io
+  match_confidence: high
+  # Appears in E1 (analytics), E2 (ticket), E3 (interview), E8 (observation):
+  # one account, four touchpoints, escalating -> a severity signal, not four voices.
+
+- entity: person_jordan
+  grain: person
+  matched_records: [zendesk:user_991, hubspot:contact_77]
+  method: email               # jordan@acme.io present verbatim in both systems
+  match_confidence: high
+  # The canonical case: same email in a Zendesk ticket AND the CRM -> one person,
+  # enriched with CRM context (admin at Acme, mid-market, renewal in 90 days).
+
+- entity: acct_northwind
+  grain: account
+  matched_records: [gong:acct_nw, hubspot:acct_204]
+  method: email_domain        # northwind.com
+  match_confidence: high

product-eval/examples/activation-q3/scorecard.html

@@ -0,0 +1,305 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Decision Scorecard, activation-q3 (Pulse)</title>
+<style>
+  :root{
+    --bg:#f7f8fa; --card:#ffffff; --ink:#15181d; --muted:#5b6471; --line:#e5e8ee;
+    --green:#16a34a; --green-bg:#e7f6ec; --amber:#c2780b; --amber-bg:#fdf3df;
+    --grey:#5b6471; --grey-bg:#eef0f4; --red:#dc2626; --red-bg:#fbe9e9;
+    --bar:#dfe3ea; --accent:#3b5bdb;
+  }
+  *{box-sizing:border-box}
+  body{margin:0;background:var(--bg);color:var(--ink);
+    font:15px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;}
+  .wrap{max-width:1040px;margin:0 auto;padding:28px 22px 60px}
+  header.top{display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:12px;margin-bottom:6px}
+  .brand{font-size:12px;letter-spacing:.14em;text-transform:uppercase;color:var(--accent);font-weight:700}
+  h1{font-size:24px;margin:4px 0 2px}
+  .sub{color:var(--muted);font-size:14px}
+  .summary{margin:14px 0 22px;padding:12px 16px;background:var(--card);border:1px solid var(--line);
+    border-radius:10px;font-size:14.5px}
+  .summary b{font-weight:650}
+  .kpis{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:12px;margin-bottom:22px}
+  .kpi{background:var(--card);border:1px solid var(--line);border-radius:10px;padding:14px 16px}
+  .kpi .n{font-size:26px;font-weight:700;line-height:1.1}
+  .kpi .l{font-size:12.5px;color:var(--muted);margin-top:3px}
+  .kpi .dot{display:inline-block;width:9px;height:9px;border-radius:50%;margin-right:6px;vertical-align:middle}
+  .panel{background:var(--card);border:1px solid var(--line);border-radius:12px;padding:18px 20px;margin-bottom:22px}
+  .panel h2{font-size:16px;margin:0 0 4px}
+  .panel .hint{color:var(--muted);font-size:13px;margin:0 0 12px}
+  .quad-flex{display:flex;flex-wrap:wrap;gap:18px;align-items:center}
+  .legend{font-size:13px;min-width:190px}
+  .legend div{margin:6px 0;display:flex;align-items:center;gap:8px}
+  .sw{width:12px;height:12px;border-radius:3px;display:inline-block}
+  .toolbar{display:flex;flex-wrap:wrap;gap:8px;align-items:center;margin-bottom:14px}
+  .toolbar span{font-size:13px;color:var(--muted);margin-right:2px}
+  .toolbar button{font:inherit;font-size:13px;border:1px solid var(--line);background:var(--card);
+    color:var(--ink);border-radius:999px;padding:5px 12px;cursor:pointer}
+  .toolbar button.active{background:var(--ink);color:#fff;border-color:var(--ink)}
+  .card{background:var(--card);border:1px solid var(--line);border-left-width:5px;border-radius:10px;
+    padding:16px 18px;margin-bottom:14px}
+  .card .row1{display:flex;flex-wrap:wrap;justify-content:space-between;gap:8px;align-items:baseline}
+  .card h3{font-size:17px;margin:0}
+  .verdict{font-size:12.5px;font-weight:700;padding:3px 10px;border-radius:999px;white-space:nowrap}
+  .bands{display:flex;flex-wrap:wrap;gap:18px;margin:12px 0 6px}
+  .band{min-width:150px;flex:1}
+  .band .lab{font-size:12px;color:var(--muted);display:flex;justify-content:space-between}
+  .band .barwrap{height:8px;background:var(--bar);border-radius:6px;margin-top:4px;overflow:hidden}
+  .band .fill{height:100%;border-radius:6px}
+  .band .bandname{font-weight:650;font-size:13.5px}
+  .meta{display:flex;flex-wrap:wrap;gap:16px;font-size:13px;color:var(--muted);margin:8px 0 10px}
+  .meta b{color:var(--ink);font-weight:650}
+  blockquote{margin:10px 0;padding:8px 14px;border-left:3px solid var(--line);
+    background:#fafbfc;color:#2c313a;font-style:italic;border-radius:0 6px 6px 0;font-size:13.5px}
+  .pa{font-size:13.5px;margin:6px 0}
+  .pa .k{font-weight:650}
+  .why{font-size:13.5px;margin:10px 0 4px;padding:8px 12px;background:#f3f6ff;border-radius:7px}
+  .gaps{font-size:13px;color:var(--muted);margin-top:8px}
+  .gaps .k{font-weight:650;color:var(--ink)}
+  details.glossary{background:var(--card);border:1px solid var(--line);border-radius:12px;padding:6px 20px;margin-bottom:22px}
+  details.glossary summary{cursor:pointer;font-weight:650;padding:12px 0;font-size:15px}
+  details.glossary dl{margin:0 0 12px}
+  details.glossary dt{font-weight:650;margin-top:10px;font-size:13.5px}
+  details.glossary dd{margin:2px 0 0;color:var(--muted);font-size:13.5px}
+  footer.honest{background:#10141b;color:#e7eaf0;border-radius:12px;padding:18px 20px;font-size:14px}
+  footer.honest b{color:#fff}
+  footer.honest .move{margin-top:8px;color:#aeb7c6}
+  .tag{font-size:11.5px;color:var(--muted)}
+  @media(max-width:560px){.bands{gap:10px}}
+</style>
+</head>
+<body>
+<div class="wrap">
+  <header class="top">
+    <div>
+      <div class="brand">product-eval &nbsp;/&nbsp; decision scorecard</div>
+      <h1>activation-q3</h1>
+      <div class="sub">Pulse, a B2B product-analytics workspace. North star: weekly activated workspaces. Generated 2026-06-29.</div>
+    </div>
+  </header>
+
+  <div class="summary" id="summary"></div>
+
+  <div class="kpis" id="kpis"></div>
+
+  <div class="panel">
+    <h2>Value &times; Confidence</h2>
+    <p class="hint">Each opportunity is plotted by how big it could be (Value, vertical) against how sure we are it is real (Confidence, horizontal). The gate lines sit at 70. The top-right box is where a bet is both worth it and proven enough to commit.</p>
+    <div class="quad-flex">
+      <svg viewBox="0 0 480 380" width="480" height="380" role="img" aria-label="Value by Confidence quadrant">
+        <!-- quadrant tints -->
+        <rect x="337" y="16" width="79" height="97" fill="var(--green-bg)"></rect>
+        <rect x="46" y="16" width="291" height="97" fill="#fcfcfd"></rect>
+        <!-- axes -->
+        <line x1="46" y1="16" x2="46" y2="340" stroke="var(--line)"></line>
+        <line x1="46" y1="340" x2="464" y2="340" stroke="var(--line)"></line>
+        <!-- gate lines at 70 -->
+        <line x1="337" y1="16" x2="337" y2="340" stroke="#c8ccd6" stroke-dasharray="4 4"></line>
+        <line x1="46" y1="113" x2="464" y2="113" stroke="#c8ccd6" stroke-dasharray="4 4"></line>
+        <text x="341" y="30" font-size="10" fill="#9aa1ad">conf gate 70</text>
+        <text x="50" y="110" font-size="10" fill="#9aa1ad">value 70</text>
+        <!-- axis labels -->
+        <text x="255" y="366" font-size="12" fill="#5b6471" text-anchor="middle">Confidence &rarr;</text>
+        <text x="14" y="180" font-size="12" fill="#5b6471" text-anchor="middle" transform="rotate(-90 14 180)">Value &rarr;</text>
+        <text x="46" y="356" font-size="10" fill="#9aa1ad" text-anchor="middle">0</text>
+        <text x="464" y="356" font-size="10" fill="#9aa1ad" text-anchor="middle">100</text>
+        <!-- points -->
+        <g>
+          <circle cx="416" cy="107" r="8" fill="var(--green)"></circle>
+          <text x="416" y="96" font-size="11" fill="#15181d" text-anchor="middle" font-weight="700">T1</text>
+          <circle cx="308" cy="113" r="8" fill="var(--amber)"></circle>
+          <text x="304" y="102" font-size="11" fill="#15181d" text-anchor="end" font-weight="700">T2</text>
+          <circle cx="146" cy="146" r="8" fill="var(--grey)"></circle>
+          <text x="146" y="135" font-size="11" fill="#15181d" text-anchor="middle" font-weight="700">T3</text>
+          <circle cx="96" cy="227" r="8" fill="var(--red)"></circle>
+          <text x="96" y="216" font-size="11" fill="#15181d" text-anchor="middle" font-weight="700">T4</text>
+        </g>
+      </svg>
+      <div class="legend">
+        <div><span class="sw" style="background:var(--green)"></span> Decide now</div>
+        <div><span class="sw" style="background:var(--amber)"></span> Run a research sprint</div>
+        <div><span class="sw" style="background:var(--grey)"></span> Do not commit yet</div>
+        <div><span class="sw" style="background:var(--red)"></span> Deprioritize</div>
+      </div>
+    </div>
+  </div>
+
+  <div class="toolbar">
+    <span>Sort by</span>
+    <button data-sort="tier" class="active">Recommendation</button>
+    <button data-sort="value">Value</button>
+    <button data-sort="confidence">Confidence</button>
+    <button data-sort="weight">Evidence weight</button>
+  </div>
+
+  <div id="cards"></div>
+
+  <details class="glossary">
+    <summary>How to read this</summary>
+    <dl>
+      <dt>Value (0 to 100)</dt>
+      <dd>If this problem is real, how big is it? Built from persona weight, funnel location, frequency, and competitive pressure (each 0 to 25). It is about potential impact, not certainty.</dd>
+      <dt>Confidence (0 to 100)</dt>
+      <dd>How sure are we the problem is real and worth acting on? Computed from total evidence weight, source-type diversity, and unresolved contradictions. Reported as a band (Low / Moderate / High); the number is for audit.</dd>
+      <dt>Evidence weight</dt>
+      <dd>Quality-weighted volume of evidence, deduplicated by account. Three strong first-party findings outweigh fifty vague mentions, so weight, not raw count, drives Confidence.</dd>
+      <dt>Accounts affected</dt>
+      <dd>Distinct accounts after identity resolution (one customer across Zendesk, CRM, and analytics counts once), so a single loud account is not mistaken for a widespread problem.</dd>
+      <dt>The recommendation tiers</dt>
+      <dd><b>Decide now</b>: worth building and well supported. <b>Run a research sprint</b>: high value but needs more proof, design the cheapest validating test. <b>Do not commit yet</b>: too unproven to act on. <b>Deprioritize</b>: prize too small to pursue.</dd>
+    </dl>
+  </details>
+
+  <footer class="honest" id="footer"></footer>
+</div>
+
+<script>
+const CEILING = "Decide-now reachable: first-party analytics, support tickets, and CRM are connected.";
+const DATA = [
+  {
+    id:"T1", tier:1, verdict:"Decide now", color:"green",
+    name:"New admins can't finish workspace setup without CS help",
+    value:72, valueBand:"High", confidence:89, confBand:"High",
+    weight:31, accounts:9, sources:4,
+    quote:"We almost gave up before your CS person walked us through the connectors.",
+    quoteSrc:"onboarding call, admin at Acme",
+    complaint:"38% of new workspaces never finish setup, dropping at the data-source connection step (up from 24% last quarter).",
+    ask:"Guided or auto-detected connector setup so an admin can finish without opening a ticket.",
+    why:"Ranks top-right: an activation cliff on the north-star path, corroborated across analytics, tickets, interviews, and churn. The score earns a commit.",
+    gaps:["Which connector is worst (Postgres vs Snowflake)?","Is the 38% inflated by trial spam?"]
+  },
+  {
+    id:"T2", tier:2, verdict:"Run a research sprint", color:"amber",
+    name:"Teams can't share saved views across the org",
+    value:70, valueBand:"High", confidence:63, confBand:"Moderate",
+    weight:14, accounts:6, sources:3,
+    quote:"Love it solo, but my team can't see my views.",
+    quoteSrc:"G2 review, end user",
+    complaint:"Views are per-user today, so teams rebuild the same view over and over; raised in two live deals.",
+    ask:"Org-shared saved views and dashboards a team can all see.",
+    why:"High value and competitors already solved it, but there is no first-party usage data on how often views get re-created. Validate before committing.",
+    gaps:["How many seats would actually share a view?","No first-party data on view re-creation."]
+  },
+  {
+    id:"T3", tier:3, verdict:"Do not commit yet", color:"grey",
+    name:"Alert noise pushes users to mute critical alerts",
+    value:60, valueBand:"Moderate", confidence:24, confBand:"Low",
+    weight:5, accounts:2, sources:2,
+    quote:"People just mute the whole channel, then miss the one that mattered.",
+    quoteSrc:"CS internal observation",
+    complaint:"Suspected that alert noise leads users to mute channels and miss critical alerts.",
+    ask:"Smarter alert grouping or quieter defaults so the signal survives.",
+    why:"Retention-relevant if true, but the core hypothesis is directly contradicted by first-party analytics (alert engagement is flat, not falling). Measure before acting.",
+    gaps:["No measured mute-rate.","Hypothesis (E8) directly contradicted by analytics (E12)."]
+  },
+  {
+    id:"T4", tier:4, verdict:"Deprioritize", color:"red",
+    name:"Users want a dark-mode dashboard",
+    value:35, valueBand:"Low", confidence:12, confBand:"Low",
+    weight:2, accounts:4, sources:2,
+    quote:"Would love a dark mode for late-night dashboards.",
+    quoteSrc:"Capterra review, end user",
+    complaint:"Scattered requests for a dark-mode theme, six over the past year.",
+    ask:"A dark-mode theme for the dashboard.",
+    why:"A secondary-persona, engagement-only preference with no competitive pressure. The prize is too small to pursue now, regardless of confidence.",
+    gaps:["No business-impact signal.","Low frequency, spread over 12 months."]
+  }
+];
+
+const C = {
+  green:{ink:"var(--green)",bg:"var(--green-bg)"},
+  amber:{ink:"var(--amber)",bg:"var(--amber-bg)"},
+  grey:{ink:"var(--grey)",bg:"var(--grey-bg)"},
+  red:{ink:"var(--red)",bg:"var(--red-bg)"}
+};
+
+function bandColor(band){return band==="High"?"var(--green)":band==="Moderate"?"var(--amber)":"var(--grey)";}
+
+function renderSummary(){
+  const n=DATA.length;
+  const by=t=>DATA.filter(d=>d.verdict===t).length;
+  document.getElementById("summary").innerHTML =
+    `<b>${n} opportunities</b>: ${by("Decide now")} Decide now, `+
+    `${by("Run a research sprint")} Run a research sprint, `+
+    `${by("Do not commit yet")} Do not commit yet, ${by("Deprioritize")} Deprioritize. `+
+    `Confidence ceiling: ${CEILING}`;
+}
+
+function renderKpis(){
+  const by=t=>DATA.filter(d=>d.verdict===t).length;
+  const cards=[
+    {n:DATA.length,l:"Opportunities",dot:null},
+    {n:by("Decide now"),l:"Decide now",dot:"var(--green)"},
+    {n:by("Run a research sprint"),l:"Research sprint",dot:"var(--amber)"},
+    {n:by("Do not commit yet"),l:"Do not commit yet",dot:"var(--grey)"},
+    {n:by("Deprioritize"),l:"Deprioritize",dot:"var(--red)"}
+  ];
+  document.getElementById("kpis").innerHTML = cards.map(c=>
+    `<div class="kpi"><div class="n">${c.n}</div><div class="l">${c.dot?`<span class="dot" style="background:${c.dot}"></span>`:""}${c.l}</div></div>`
+  ).join("");
+}
+
+function card(d){
+  const c=C[d.color];
+  return `<div class="card" style="border-left-color:${c.ink}">
+    <div class="row1">
+      <h3>${d.id}. ${d.name}</h3>
+      <span class="verdict" style="color:${c.ink};background:${c.bg}">${d.verdict}</span>
+    </div>
+    <div class="bands">
+      <div class="band">
+        <div class="lab"><span>Value</span><span class="bandname" style="color:${bandColor(d.valueBand)}">${d.valueBand}</span></div>
+        <div class="barwrap"><div class="fill" style="width:${d.value}%;background:${bandColor(d.valueBand)}"></div></div>
+        <div class="tag">audit: ${d.value}/100</div>
+      </div>
+      <div class="band">
+        <div class="lab"><span>Confidence</span><span class="bandname" style="color:${bandColor(d.confBand)}">${d.confBand}</span></div>
+        <div class="barwrap"><div class="fill" style="width:${d.confidence}%;background:${bandColor(d.confBand)}"></div></div>
+        <div class="tag">audit: ${d.confidence}/100</div>
+      </div>
+    </div>
+    <div class="meta">
+      <span><b>${d.weight}</b> evidence weight</span>
+      <span><b>${d.accounts}</b> accounts affected</span>
+      <span><b>${d.sources}</b> source types</span>
+    </div>
+    <blockquote>&ldquo;${d.quote}&rdquo; <span class="tag">(${d.quoteSrc})</span></blockquote>
+    <div class="pa"><span class="k">Top complaint:</span> ${d.complaint}</div>
+    <div class="pa"><span class="k">The ask:</span> ${d.ask}</div>
+    <div class="why"><b>Why it ranks here:</b> ${d.why}</div>
+    <div class="gaps"><span class="k">Open gaps:</span> ${d.gaps.join(" &middot; ")}</div>
+  </div>`;
+}
+
+let sortKey="tier";
+function renderCards(){
+  const arr=[...DATA].sort((a,b)=>{
+    if(sortKey==="tier") return a.tier-b.tier;
+    return b[sortKey]-a[sortKey];
+  });
+  document.getElementById("cards").innerHTML = arr.map(card).join("");
+}
+
+function renderFooter(){
+  const top=DATA.find(d=>d.tier===1)||DATA[0];
+  document.getElementById("footer").innerHTML =
+    `<b>Honest read.</b> Confidence ceiling: ${CEILING}<div class="move">`+
+    `Cheapest move to raise the top open item: instrument the connection step to break the 38% drop down by connector, which would convert T1's remaining gap into a measured fact and de-risk the build scope.</div>`;
+}
+
+document.querySelectorAll(".toolbar button").forEach(b=>{
+  b.addEventListener("click",()=>{
+    document.querySelectorAll(".toolbar button").forEach(x=>x.classList.remove("active"));
+    b.classList.add("active");
+    sortKey=b.dataset.sort;
+    renderCards();
+  });
+});
+
+renderSummary(); renderKpis(); renderCards(); renderFooter();
+</script>
+</body>
+</html>

product-eval/examples/activation-q3/scores.md

@@ -0,0 +1,41 @@
+# Scores for activation-q3 (exact 0-100 stored for audit; chat leads with bands)
+
+- problem: T1
+  value: 72
+  value_inputs: {persona: 20, funnel: 22, frequency: 20, competitive: 10}
+  value_band: high
+  confidence: 89
+  confidence_band: high
+  recommendation: "Decide now"
+  rationale: "High-value activation cliff, corroborated across 4 first-party source types; the math supports committing."
+  override: null
+
+- problem: T2
+  value: 70
+  value_inputs: {persona: 20, funnel: 15, frequency: 15, competitive: 20}
+  value_band: high
+  confidence: 63
+  confidence_band: moderate
+  recommendation: "Run a research sprint"
+  rationale: "High value and competitors solved it, but no first-party usage data; firm up proof before committing."
+  override: null
+
+- problem: T3
+  value: 60
+  value_inputs: {persona: 15, funnel: 25, frequency: 10, competitive: 10}
+  value_band: moderate
+  confidence: 24
+  confidence_band: low
+  recommendation: "Do not commit yet"
+  rationale: "Retention-relevant if true, but the core hypothesis is directly contradicted by first-party analytics (E12)."
+  override: null
+
+- problem: T4
+  value: 35
+  value_inputs: {persona: 10, funnel: 10, frequency: 10, competitive: 5}
+  value_band: low
+  confidence: 12
+  confidence_band: low
+  recommendation: "Deprioritize"
+  rationale: "Prize too small: secondary persona, engagement-only, no competitive pressure."
+  override: null

product-eval/examples/activation-q3/themes.md

@@ -0,0 +1,57 @@
+# Problem-framed themes for activation-q3
+
+- id: T1
+  name: "New admins can't finish workspace setup without CS help"
+  members: [E1, E2, E3, E4]
+  personas: [admin, buyer]
+  distinct_accounts: 9
+  total_weight: 31
+  source_types: [product_analytics, support_ticket, customer_interview, churn_survey]
+  trend: up
+  corroboration: cross-source
+  contradictions: []
+  confidence: 89          # base 89 (W=31) x 1.0 (4 source types) x 1.0 (no contradictions)
+  confidence_band: high
+  gaps: ["which connector is worst (Postgres vs Snowflake)?", "is the 38% inflated by trial spam?"]
+
+- id: T2
+  name: "Teams can't share saved views across the org"
+  members: [E5, E6, E7]
+  personas: [admin, end_user, buyer]
+  distinct_accounts: 6
+  total_weight: 14
+  source_types: [feature_request, sales_call, app_review]
+  trend: emerging
+  corroboration: cross-source
+  contradictions: []
+  confidence: 63          # base 63 (W=14) x 1.0 (3 source types) x 1.0
+  confidence_band: moderate
+  gaps: ["how many seats would actually share?", "no first-party usage data on view re-creation"]
+
+- id: T3
+  name: "Alert noise pushes users to mute critical alerts"
+  members: [E8, E9]
+  personas: [end_user]
+  distinct_accounts: 2
+  total_weight: 5
+  source_types: [internal_observation, community_post]
+  trend: flat
+  corroboration: single-source-ish
+  contradictions: [E12]   # analytics show alert engagement flat -> 1 unresolved material contradiction
+  confidence: 24          # base 30 (W=5) x 0.9 (2 source types) x 0.9 (1 contradiction)
+  confidence_band: low
+  gaps: ["no measured mute-rate", "E8 hypothesis directly contradicted by E12"]
+
+- id: T4
+  name: "Users want a dark-mode dashboard"
+  members: [E10, E11]
+  personas: [end_user]
+  distinct_accounts: 4
+  total_weight: 2
+  source_types: [feature_request, app_review]
+  trend: flat
+  corroboration: weak
+  contradictions: []
+  confidence: 12          # base 13 (W=2) x 0.9 (2 source types) x 1.0
+  confidence_band: low
+  gaps: ["no business-impact signal", "aesthetic preference, low frequency"]