@productbrain/mcp 0.0.1-beta.80 → 0.0.1-beta.82

package/dist/{chunk-MDGV4MHW.js → chunk-WXT35272.js}

@@ -3653,9 +3653,6 @@ function getWorkflowTemplateMetadata(descriptor) {
     name: descriptor.template.name
   };
 }
-function getWorkflowContextCollection(descriptor) {
-  return getWorkflowPrimaryRecordCollection(descriptor);
-}
 function describeWorkflowPrimaryOutput(descriptor) {
   const { routing } = descriptor.output.primaryRecord;
   if (routing.mode === "fixed") {
@@ -3869,7 +3866,7 @@ The retro must never fail silently. Always communicate state.`
 var SHAPE_WORKFLOW_DESCRIPTOR = {
   id: "shape",
   name: "Shape a Bet",
-  shortDescription: "Integration-aware shaping: maps the system before designing, traces five paths per element, surfaces governance conflicts at design time. Uses `facilitate` for scoring and Chain capture.",
+  shortDescription: "Integration-aware shaping: maps the system before designing, traces five paths per element, surfaces governance conflicts at design time. Scoring is in the shaping skill; uses capture and facilitate action=commit-constellation for Chain capture.",
   template: {
     slug: "shape-a-bet",
     name: "Shape a Bet"
@@ -4446,7 +4443,7 @@ ${wf.shortDescription}
 ${roundList}
 
 **Output**: ${outputDescription}
-_Use the \`run-workflow\` prompt with workflow="${wf.id}" to start._`;
+_Trigger via Facilitator Mode: say "run retro", "shape this", "review implementation", or "process change" in Cursor._`;
 }
 function validateFinalWorkflowCheckpoint(workflow, roundId) {
   const finalRound = workflow.rounds.at(-1);
@@ -4495,7 +4492,7 @@ function registerWorkflowTools(server) {
     "workflows",
     {
       title: "Workflows",
-      description: "Chainwork workflow discovery, checkpointing, and run inspection. Three actions:\n\n- **list**: Browse available workflows \u2014 retro, shape-a-bet, IDM, etc. Use the `run-workflow` prompt to launch one.\n- **checkpoint**: Record round output during Facilitator Mode. Persists progress. At completion, some workflows support isFinal=true to create the summary chain entry.\n- **get-run**: Inspect a persisted workflow run by run ID or by workflow ID in the current session.",
+      description: "Chainwork workflow discovery, checkpointing, and run inspection. Three actions:\n\n- **list**: Browse available workflows \u2014 retro, shape-a-bet, implementation-review, process-change. Triggered by Facilitator Mode in Cursor (e.g. 'run retro', 'shape this', 'review implementation').\n- **checkpoint**: Record round output during Facilitator Mode. Persists progress. At completion, some workflows support isFinal=true to create the summary chain entry.\n- **get-run**: Inspect a persisted workflow run by run ID or by workflow ID in the current session.",
       inputSchema: workflowsSchema,
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
     },
@@ -4565,7 +4562,7 @@ async function handleList3() {
       type: "text",
       text: `# Available Chainwork Workflows
 
-${workflows.length} workflow(s) available. Use the \`run-workflow\` prompt to launch one.
+${workflows.length} workflow(s) available. Trigger via Facilitator Mode in Cursor (say "run retro", "shape this", "review implementation", or "process change").
 
 ---
 
@@ -9860,197 +9857,12 @@ ${entry.labels.map((l) => `- ${l.name ?? l.slug}`).join("\n")}`);
 }
 
 // src/prompts/index.ts
-import { z as z23 } from "zod";
-
-// src/tools/project-scan.ts
 import { z as z22 } from "zod";
-var scanExtractionSchema = z22.object({
-  vision: z22.string().min(10).optional().describe("Product purpose from README"),
-  audience: z22.string().optional().describe("Primary user or customer segment"),
-  techStack: z22.array(z22.string()).optional().describe("Key technologies from package.json"),
-  modules: z22.array(z22.object({ name: z22.string(), purpose: z22.string() })).max(8).optional().describe("Top-level modules from folder structure"),
-  businessRules: z22.array(z22.string()).max(10).optional().describe("System constraints from .cursorrules/AGENTS.md/CLAUDE.md"),
-  conventions: z22.array(z22.string()).max(8).optional().describe("Coding or process standards from .cursorrules"),
-  keyDecisions: z22.array(z22.string()).optional().describe("Significant architectural decisions from git log or README"),
-  tensions: z22.array(z22.string()).optional().describe("Friction points or known trade-offs"),
-  keyTerms: z22.array(z22.string()).optional().describe("Domain-specific vocabulary found in files")
-});
-var COLLECTION_PRIORITY = {
-  strategy: 0,
-  audiences: 1,
-  architecture: 2,
-  decisions: 3,
-  "business-rules": 4,
-  standards: 5,
-  glossary: 6,
-  tensions: 7
-};
-var GENERIC_MODULE_NAMES = /* @__PURE__ */ new Set(["src", "lib", "utils"]);
-function truncate(str, maxLen) {
-  return str.length <= maxLen ? str : str.slice(0, maxLen);
-}
-function firstNWords(str, n) {
-  return str.split(/\s+/).slice(0, n).join(" ");
-}
-function scanToBatchEntries(extracted) {
-  const entries = [];
-  const techStackGlossaryNames = /* @__PURE__ */ new Set();
-  if (extracted.vision) {
-    entries.push({
-      collection: "strategy",
-      name: "Product Vision",
-      description: extracted.vision
-    });
-  }
-  if (extracted.audience) {
-    entries.push({
-      collection: "audiences",
-      name: firstNWords(extracted.audience, 6),
-      description: extracted.audience
-    });
-  }
-  if (extracted.techStack && extracted.techStack.length > 0) {
-    entries.push({
-      collection: "architecture",
-      name: "Tech Stack",
-      description: `Technology choices: ${extracted.techStack.join(", ")}`
-    });
-    for (const tech of extracted.techStack.slice(0, 3)) {
-      const name = tech;
-      techStackGlossaryNames.add(name.toLowerCase());
-      entries.push({
-        collection: "glossary",
-        name,
-        description: `${tech} \u2014 part of the tech stack`
-      });
-    }
-  }
-  if (extracted.modules) {
-    let count = 0;
-    for (const mod of extracted.modules) {
-      if (count >= 5) break;
-      if (GENERIC_MODULE_NAMES.has(mod.name.toLowerCase())) continue;
-      entries.push({
-        collection: "architecture",
-        name: mod.name,
-        description: mod.purpose
-      });
-      count++;
-    }
-  }
-  for (const rule of extracted.businessRules ?? []) {
-    entries.push({
-      collection: "business-rules",
-      name: truncate(rule, 70),
-      description: rule
-    });
-  }
-  for (const convention of extracted.conventions ?? []) {
-    entries.push({
-      collection: "standards",
-      name: truncate(convention, 70),
-      description: convention
-    });
-  }
-  for (const decision of extracted.keyDecisions ?? []) {
-    entries.push({
-      collection: "decisions",
-      name: truncate(decision, 80),
-      description: decision
-    });
-  }
-  for (const tension of extracted.tensions ?? []) {
-    entries.push({
-      collection: "tensions",
-      name: truncate(tension, 80),
-      description: tension
-    });
-  }
-  for (const term of extracted.keyTerms ?? []) {
-    if (techStackGlossaryNames.has(term.toLowerCase())) continue;
-    entries.push({
-      collection: "glossary",
-      name: term,
-      description: `Core domain term: ${term}`
-    });
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = entries.filter((e) => {
-    const key = `${e.collection}:${e.name.toLowerCase()}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-  if (deduped.length <= 30) return deduped;
-  return deduped.sort((a, b) => {
-    const pa = COLLECTION_PRIORITY[a.collection] ?? 99;
-    const pb = COLLECTION_PRIORITY[b.collection] ?? 99;
-    return pa - pb;
-  }).slice(0, 30);
-}
-
-// src/tools/draft-review.ts
-var REVIEW_COLLECTION_ORDER = [
-  "strategy",
-  "chains",
-  "audiences",
-  "architecture",
-  "decisions",
-  "business-rules",
-  "standards",
-  "glossary",
-  "tensions"
-];
-function groupDraftsByCollection(drafts) {
-  const buckets = /* @__PURE__ */ new Map();
-  for (const draft of drafts) {
-    const existing = buckets.get(draft.collection);
-    if (existing) {
-      existing.push(draft);
-    } else {
-      buckets.set(draft.collection, [draft]);
-    }
-  }
-  const knownKeys = REVIEW_COLLECTION_ORDER.filter((k) => buckets.has(k));
-  const unknownKeys = [...buckets.keys()].filter((k) => !REVIEW_COLLECTION_ORDER.includes(k)).sort();
-  const ordered = /* @__PURE__ */ new Map();
-  for (const key of [...knownKeys, ...unknownKeys]) {
-    ordered.set(key, buckets.get(key));
-  }
-  return ordered;
-}
-var COLLECTION_DISPLAY_NAMES = {
-  "business-rules": "Business Rules",
-  "tracking-events": "Tracking Events"
-};
-function collectionLabel(slug) {
-  return COLLECTION_DISPLAY_NAMES[slug] ?? slug.charAt(0).toUpperCase() + slug.slice(1);
-}
-function formatDraftGroups(grouped, total) {
-  if (total === 0) {
-    return "No drafts to review \u2014 your workspace is fully committed.";
-  }
-  const lines = [`## Drafts Ready for Review (${total} total)`];
-  let counter = 1;
-  for (const [collection, entries] of grouped) {
-    const label = collectionLabel(collection);
-    const count = entries.length;
-    lines.push(`
-### ${label} (${count} ${count === 1 ? "entry" : "entries"})`);
-    for (const entry of entries) {
-      lines.push(`${counter}. ${entry.name} [${entry.entryId}]`);
-      counter++;
-    }
-  }
-  return lines.join("\n");
-}
-
-// src/prompts/index.ts
 function registerPrompts(server) {
   server.prompt(
     "review-against-rules",
     "Review code or a design decision against all business rules for a given domain. Fetches the rules and asks you to do a structured compliance review.",
-    { domain: z23.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
+    { domain: z22.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
     async ({ domain }) => {
       const entries = await mcpQuery("chain.listEntries", { collectionSlug: "business-rules" });
       const rules = entries.filter((e) => e.data?.domain === domain);
@@ -10103,7 +9915,7 @@ Provide a structured review with a compliance status for each rule (COMPLIANT /
   server.prompt(
     "name-check",
     "Check variable names, field names, or API names against the glossary for terminology alignment. Flags drift from canonical terms.",
-    { names: z23.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
+    { names: z22.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
     async ({ names }) => {
       const terms = await mcpQuery("chain.listEntries", { collectionSlug: "glossary" });
       const glossaryContext = terms.map(
@@ -10139,7 +9951,7 @@ Format as a table: Name | Status | Canonical Form | Action Needed`
   server.prompt(
     "draft-decision-record",
     "Draft a structured decision record from a description of what was decided. Includes context from recent decisions and relevant rules.",
-    { context: z23.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
+    { context: z22.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
     async ({ context }) => {
       const recentDecisions = await mcpQuery("chain.listEntries", { collectionSlug: "decisions" });
       const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
@@ -10177,8 +9989,8 @@ After drafting, I can log it using the capture tool with collection "decisions".
     "draft-rule-from-context",
     "Draft a new business rule from an observation or discovery made while coding. Fetches existing rules for the domain to ensure consistency.",
     {
-      observation: z23.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
-      domain: z23.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
+      observation: z22.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
+      domain: z22.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
     },
     async ({ observation, domain }) => {
       const allRules = await mcpQuery("chain.listEntries", { collectionSlug: "business-rules" });
@@ -10215,575 +10027,6 @@ Make sure the rule is consistent with existing rules and doesn't contradict them
       };
     }
   );
-  server.prompt(
-    "run-workflow",
-    "Launch any registered Chainwork workflow in Facilitator Mode. Returns the full workflow definition, facilitation instructions, and round structure. The agent enters Facilitator Mode and guides the participant through each round.",
-    {
-      workflow: z23.string().describe(
-        "Workflow ID to run. Available: " + listWorkflows().map((w) => `'${w.id}' (${w.name})`).join(", ")
-      ),
-      context: z23.string().optional().describe(
-        "Optional context from the participant (e.g., 'retro on last sprint', 'shape the Chainwork API bet')"
-      )
-    },
-    async ({ workflow: workflowId, context }) => {
-      const wf = getWorkflow(workflowId);
-      const descriptor = getWorkflowDescriptor(workflowId);
-      if (!wf) {
-        const available = listWorkflows().map((w) => `- **${w.id}**: ${w.name} \u2014 ${w.shortDescription}`).join("\n");
-        return {
-          messages: [
-            {
-              role: "user",
-              content: {
-                type: "text",
-                text: `Workflow "${workflowId}" not found.
-
-Available workflows:
-${available}
-
-Use one of these IDs to run a workflow.`
-              }
-            }
-          ]
-        };
-      }
-      let kbContext = "";
-      const contextCollection = descriptor ? getWorkflowContextCollection(descriptor) : wf.kbOutputCollection ?? null;
-      try {
-        if (contextCollection) {
-          const recentDecisions = await mcpQuery("chain.listEntries", {
-            collectionSlug: contextCollection
-          });
-          const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
-          if (sorted.length > 0) {
-            kbContext = `
-## Recent ${contextCollection} entries (for context)
-` + sorted.map((d) => `- ${d.entryId ?? ""}: ${d.name} [${d.status}]`).join("\n");
-          }
-        }
-      } catch {
-        kbContext = "\n_Could not load chain context \u2014 proceed without it._";
-      }
-      const roundsPlan = wf.rounds.map(
-        (r) => `### Round ${r.num}: ${r.label}
-**Type**: ${r.type} | **Duration**: ~${r.maxDurationHint ?? "5 min"}
-**Instruction**: ${r.instruction}
-**Facilitator guidance**: ${r.facilitatorGuidance}
-` + (r.questions ? r.questions.map(
-          (q) => `**Question**: ${q.prompt}
-` + (q.options ? q.options.map((o) => `  - ${o.id}: ${o.label}`).join("\n") : "  _(open response)_")
-        ).join("\n") : "") + `
-**Output**: Capture to \`${r.outputSchema.field}\` (${r.outputSchema.format})
-**Checkpoint**: \`workflows action="checkpoint" workflowId="${wf.id}" roundId="${r.id}"\``
-      ).join("\n\n---\n\n");
-      const contextLine = context ? `
-The participant provided this context: "${context}"
-Use it \u2014 don't make them repeat themselves.
-` : "";
-      const outputDescription = descriptor ? describeWorkflowPrimaryOutput(descriptor) : wf.kbOutputCollection ? `Primary record routes to \`${wf.kbOutputCollection}\`.` : "Primary output routing resolved at runtime.";
-      const summaryCapture = descriptor ? getWorkflowSummaryCaptureDefinition(descriptor) : wf.kbOutputCollection && wf.kbOutputTemplate ? {
-        routing: {
-          mode: "fixed",
-          collection: wf.kbOutputCollection
-        },
-        nameTemplate: wf.kbOutputTemplate.nameTemplate,
-        descriptionField: wf.kbOutputTemplate.descriptionField,
-        descriptionSource: "final-output-text"
-      } : null;
-      const chainOutputBlock = summaryCapture ? `Primary record routes to \`${summaryCapture.routing.mode === "fixed" ? summaryCapture.routing.collection : "classifier"}\`.
-Summary capture template: ${summaryCapture.nameTemplate}
-Description field: ${summaryCapture.descriptionField ?? "collection default"}
-` : `${outputDescription}
-`;
-      return {
-        messages: [
-          {
-            role: "user",
-            content: {
-              type: "text",
-              text: `# ${wf.icon} ${wf.name} Workflow \u2014 Facilitator Mode
-
-${wf.shortDescription}
-` + contextLine + `
----
-
-## Facilitator Instructions
-
-${wf.facilitatorPreamble}
-
----
-
-## Checkpointing & Resume
-
-1. Before starting, check for an existing run: \`workflows action="get-run" workflowId="${wf.id}"\`.
-2. If an active run exists, resume from its \`currentRoundId\`.
-3. After EACH round: \`workflows action="checkpoint" workflowId="${wf.id}" roundId="<round-id>" output=<round-output>\`.
-` + (wf.facilitatorPreamble.includes("commit-constellation") ? `4. Finalize via \`facilitate action=commit-constellation\` \u2014 do NOT use \`isFinal: true\`.
-` : `4. Only call \`isFinal: true\` from the terminal round (or pass \`summaryEntryId=<primary-entry-id>\` to finalize with a linked entry).
-`) + `5. If a checkpoint fails, continue \u2014 the conversation is the backup.
-
----
-
-## Rounds
-
-${roundsPlan}
-
----
-
-## Error Recovery
-
-${wf.errorRecovery}
-
----
-
-## Chain Output
-
-${chainOutputBlock}` + kbContext + `
-
----
-
-**BEGIN THE WORKFLOW NOW.** Start with Round 01. Create a Plan first.`
-            }
-          }
-        ]
-      };
-    }
-  );
-  server.prompt(
-    "capture-and-connect",
-    "Guided workflow: capture a knowledge entry, discover graph connections, create relations, and prepare for commit. Encodes the capture \u2192 suggest \u2192 batch-create \u2192 commit choreography as a step-by-step guide.",
-    {
-      collection: z23.string().describe("Collection slug (e.g. 'glossary', 'business-rules', 'decisions', 'tensions')"),
-      name: z23.string().describe("Entry name"),
-      description: z23.string().describe("Entry description")
-    },
-    async ({ collection, name, description }) => {
-      const collections = await mcpQuery("chain.listCollections");
-      const col = collections.find((c) => c.slug === collection);
-      const colName = col ? col.name : collection;
-      return {
-        messages: [{
-          role: "user",
-          content: {
-            type: "text",
-            text: `# Capture & Connect Workflow
-
-You are capturing a new **${colName}** entry and connecting it to the knowledge graph.
-
-## Entry Details
-- **Collection:** ${collection}
-- **Name:** ${name}
-- **Description:** ${description}
-
-## Steps (execute in order)
-
-### Step 1: Capture
-\`\`\`
-capture collection="${collection}" name="${name}" description="${description}"
-\`\`\`
-Review the quality scorecard. Note the returned \`entryId\`.
-
-### Step 2: Discover Connections
-\`\`\`
-graph action=suggest entryId="<ID from step 1>"
-\`\`\`
-Review the top 3 quick wins. Accept the ones that make sense.
-
-### Step 3: Create Relations
-\`\`\`
-relations action=batch-create relations=[...]
-\`\`\`
-Use the suggested relations from step 2.
-
-### Step 4: Present for Commit
-Show the user what was captured and connected. Ask for confirmation.
-Only call \`commit-entry\` when the user explicitly confirms.
-
-**Begin with Step 1 now.**`
-          }
-        }]
-      };
-    }
-  );
-  server.prompt(
-    "deep-dive",
-    "Explore everything the Chain knows about a topic or entry. Assembles entry details, graph context, related business rules, and glossary terms into a comprehensive briefing.",
-    {
-      topic: z23.string().describe("Entry ID (e.g. 'BR-001') or topic to explore (e.g. 'authentication')")
-    },
-    async ({ topic }) => {
-      const isEntryId = /^[A-Z]+-\d+$/i.test(topic) || /^[A-Z]+-[a-z0-9]+$/i.test(topic);
-      let contextInstructions;
-      if (isEntryId) {
-        contextInstructions = `The topic is an entry ID: \`${topic}\`
-
-## Steps
-
-### 1. Get the entry
-\`\`\`
-entries action=get entryId="${topic}"
-\`\`\`
-
-### 2. Gather full context
-\`\`\`
-context action=gather entryId="${topic}" mode="graph"
-\`\`\`
-
-### 3. Check direct relations
-\`\`\`
-graph action=find entryId="${topic}"
-\`\`\`
-
-### 4. Synthesize
-Combine everything into a comprehensive briefing:
-- What this entry IS (data, status, collection)
-- How it connects to the rest of the Chain (relations, context)
-- What business rules govern it
-- What glossary terms it uses
-- What gaps or opportunities exist (missing relations, low quality score)
-
-Present the briefing, then ask if the user wants to explore any connection deeper.`;
-      } else {
-        contextInstructions = `The topic is a natural-language query: "${topic}"
-
-## Steps
-
-### 1. Search the Chain
-\`\`\`
-entries action=search query="${topic}"
-\`\`\`
-
-### 2. Load task context
-\`\`\`
-context action=gather task="${topic}"
-\`\`\`
-
-### 3. Explore top results
-For the top 3 most relevant entries from search, get their full details:
-\`\`\`
-entries action=get entryId="<ID>"
-\`\`\`
-
-### 4. Synthesize
-Combine everything into a comprehensive briefing about "${topic}":
-- What the Chain knows about this topic
-- Key entries, business rules, and glossary terms
-- How different entries relate to each other
-- What gaps exist in the Chain's knowledge
-
-Present the briefing, then ask if the user wants to capture new knowledge or explore deeper.`;
-      }
-      return {
-        messages: [{
-          role: "user",
-          content: {
-            type: "text",
-            text: `# Deep Dive: ${topic}
-
-Explore everything the Chain knows about this topic.
-
-${contextInstructions}`
-          }
-        }]
-      };
-    }
-  );
-  server.prompt(
-    "pre-commit-check",
-    "Run a readiness check before committing an entry to the Chain. Validates quality score, required relations, and business rule compliance.",
-    {
-      entryId: z23.string().describe("Entry ID to check (e.g. 'GT-019', 'DEC-005')")
-    },
-    async ({ entryId }) => {
-      return {
-        messages: [{
-          role: "user",
-          content: {
-            type: "text",
-            text: `# Pre-Commit Check: ${entryId}
-
-Run a full readiness check before committing this entry to the Chain.
-
-## Steps (execute all, report results)
-
-### 1. Quality Check
-\`\`\`
-quality action=check entryId="${entryId}"
-\`\`\`
-Target: 8/10 or higher. If below, identify what to improve.
-
-### 2. Re-evaluate in Commit Context
-\`\`\`
-quality action=re-evaluate entryId="${entryId}" context="commit"
-\`\`\`
-Check semantic quality criteria (specificity, actionability, testability).
-
-### 3. Check Relations
-\`\`\`
-graph action=find entryId="${entryId}"
-\`\`\`
-Verify the entry has at least one relation. Strategy entries MUST have a strategy link.
-
-### 4. Discover Missing Connections
-\`\`\`
-graph action=suggest entryId="${entryId}"
-\`\`\`
-Review suggestions. Create high-confidence relations before committing.
-
-### 5. Readiness Verdict
-Present a summary:
-- **Quality:** X/10 (pass if >= 8)
-- **Relations:** X connections (pass if >= 1)
-- **Strategy link:** present/missing (required for governed collections)
-- **Semantic quality:** X/3 criteria pass
-- **Verdict:** READY TO COMMIT / NEEDS IMPROVEMENT
-
-If ready, ask the user to confirm. If not, suggest specific improvements.
-
-**Begin with Step 1 now.**`
-          }
-        }]
-      };
-    }
-  );
-  server.prompt(
-    "project-scan",
-    "Scan local project files to extract structured knowledge for Product Brain. The IDE agent reads README.md, package.json, .cursorrules, folder structure, and recent git history, then extracts vision, tech stack, modules, business rules, conventions, decisions, and domain terms into batch-capture entries. The trust boundary is confirmation before capture: only capture entries the user explicitly keeps, then let normal workspace governance apply.",
-    {
-      workspaceContext: z23.string().optional().describe("Optional context about the workspace preset and existing collections (paste from start/orient output)")
-    },
-    async ({ workspaceContext }) => {
-      let collectionsContext = "";
-      try {
-        const cols = await mcpQuery("chain.listCollections");
-        if (cols?.length) {
-          const colList = cols.map((c) => `- \`${c.slug}\`: ${c.name}`).join("\n");
-          collectionsContext = `
-## Available Collections
-${colList}
-`;
-        }
-      } catch {
-      }
-      const schemaFields = Object.entries(scanExtractionSchema.shape).map(([key, field]) => `- \`${key}\`: ${field.description ?? ""}`).join("\n");
-      const exampleEntries = scanToBatchEntries({
-        vision: "A knowledge management tool for solo developers working with AI coding assistants",
-        audience: "Solo developers using Cursor, Claude Code, or similar AI IDEs",
-        techStack: ["SvelteKit", "Convex", "TypeScript"],
-        modules: [{ name: "Product Brain MCP", purpose: "MCP server that exposes knowledge capture tools to the IDE agent" }],
-        businessRules: ["All public functions must validate arguments with Zod before processing"],
-        conventions: ["Use batch-capture for multi-entry writes; never call capture in a loop"],
-        keyDecisions: ["Use Convex for real-time backend \u2014 avoids managing infrastructure"],
-        keyTerms: ["Chain", "Capture", "Orientation"],
-        tensions: ["Activation requires skill \u2014 users need to know what to capture before value compounds"]
-      });
-      const exampleOutput = JSON.stringify({ entries: exampleEntries.slice(0, 5) }, null, 2);
-      return {
-        messages: [{
-          role: "user",
-          content: {
-            type: "text",
-            text: `# Project Scan \u2014 Agent-Side Knowledge Extraction
-
-You are scanning the user's local project to extract structured knowledge for Product Brain.
-PB runs remotely \u2014 you read the files and extract, then call \`batch-capture\` after confirmation.
-
-` + (workspaceContext ? `## Workspace Context
-${workspaceContext}
-
-` : "") + collectionsContext + `## Step 1: Read Project Files
-
-Read these files in order. Skip gracefully if not present.
-
-1. **\`README.md\`** \u2014 Look for: product purpose (vision), who it's for (audience), key concepts, architecture notes, known issues
-2. **\`package.json\`** \u2014 Look for: \`name\`, \`description\`, and **dependencies** \u2014 identify the framework, database, auth library, UI library (these become tech stack + glossary). Ignore dev tools and test libraries.
-3. **\`tsconfig.json\` / \`tsconfig.app.json\`** \u2014 Look for: path aliases (e.g. \`@/\`) that hint at module structure
-4. **Top-level folder structure** (list directories only, max 2 levels) \u2014 Look for: named modules, feature folders, service boundaries. Note names that are specific enough to be meaningful.
-5. **\`.cursorrules\` / \`CLAUDE.md\` / \`AGENTS.md\`** \u2014 Look for: **business rules** (constraints the system enforces), **conventions** (how work is done here), no-gos, domain vocabulary
-6. **\`git log --oneline -20\`** \u2014 Look for: commits that imply decisions ("migrate from X to Y", "switch to Z for reason"), repeated friction ("fix broken", "revert", "hotfix same area twice")
-
-**ICP stack only (V1):** README, package.json, tsconfig, folder structure, .cursorrules/CLAUDE.md/AGENTS.md, git log.
-Do not attempt Python, Rust, Go, or mobile-specific files in this pass.
-
-## Step 2: Extract Structured Data
-
-After reading all files, extract into this schema:
-
-\`\`\`
-${schemaFields}
-\`\`\`
-
-**Field-by-field guidance:**
-- \`vision\`: one sentence product purpose. Source: README intro or package.json description. Required if README exists.
-- \`audience\`: who it's for. Source: README target-user section or "built for" language.
-- \`techStack\`: main runtime dependencies only \u2014 framework, database, auth, UI. Max 8. Not dev tools, test libs, or linters.
-- \`modules\`: named subsystems with clear purposes. Source: folder structure + tsconfig path aliases. Skip generic names (src, lib, utils alone). Max 5.
-- \`businessRules\`: constraints the system enforces. Source: .cursorrules/AGENTS.md. Write as: "All X must Y" or "The system must Z". Keep as written.
-- \`conventions\`: how work is done here. Source: .cursorrules standards sections. Write as: "Use X not Y" or "Always do Z".
-- \`keyDecisions\`: architectural choices made, preferably with rationale. Source: git log patterns, README architecture notes. Each as a declarative statement ("Use Convex for real-time backend").
-- \`tensions\`: known friction or trade-offs. Source: git log hotfixes/reverts, README "known issues".
-- \`keyTerms\`: domain vocabulary specific to this project \u2014 not tech names, but product/business terms. Source: README, .cursorrules.
-
-**Quality rules (RH2 mitigation):**
-- Only include items with direct evidence from the files \u2014 no inference, no hallucination
-- Prefer 8 precise entries over 20 vague ones
-- Business rules and conventions must be actual constraints, not generic advice
-- Empty arrays beat fabricated data
-
-## Step 3: Validate Before Presenting
-
-Before presenting, check each entry:
-- vision is at least 10 characters if present
-- no duplicate names within the same collection
-- each entry has a non-empty name and description
-- techStack items are actual technologies, not version strings or config flags
-- module names are specific (not just "src", "lib", "utils")
-
-Drop any entry that fails. If no vision AND no techStack exist, the scan is too sparse \u2014 tell the user which files were missing and stop.
-
-## Step 4: Present for Confirmation
-
-Present inferred entries as a numbered list grouped by collection. Ask which to keep.
-**Do NOT call batch-capture yet.** Only after the user confirms.
-
-## Step 5: Map to batch-capture
-
-After confirmation, map entries using these rules:
-- \`vision\` \u2192 strategy, name: "Product Vision"
-- \`audience\` \u2192 audiences
-- \`techStack\` \u2192 architecture ("Tech Stack") + top 3 items individually \u2192 glossary
-- \`modules\` \u2192 architecture (1 per module, max 5)
-- \`businessRules\` \u2192 business-rules (1 per rule)
-- \`conventions\` \u2192 standards (1 per convention)
-- \`keyDecisions\` \u2192 decisions (1 per decision)
-- \`tensions\` \u2192 tensions (1 per tension)
-- \`keyTerms\` \u2192 glossary (skip names already added from techStack)
-
-**Example output:**
-\`\`\`json
-${exampleOutput}
-\`\`\`
-
-Call batch-capture with confirmed entries only. Omit \`autoCommit\` to follow workspace governance.
-If \`failed > 0\`, inspect \`failedEntries\` and retry those individually.
-
-## Step 6: Connect + Prove Value
-
-After capture:
-1. Call \`graph action=suggest\` on 2\u20133 key entries (vision, architecture, a decision)
-2. Invent a plausible next task the user might actually do and call \`context action=gather task="<that task>"\`
-3. Present what Product Brain now knows in that task context \u2014 this is the proof moment
-4. Show one clear result summary so the user sees exactly what was added
-
-**Begin with Step 1 now.** Read the files, then report what you found before extracting.`
-          }
-        }]
-      };
-    }
-  );
-  server.prompt(
-    "review-drafts",
-    "Review all uncommitted workspace drafts grouped by collection and commit them in batches. After each committed batch, surfaces the most non-obvious graph connection found as the WOW moment \u2014 the signal that Product Brain has started compounding.",
-    {
-      focus: z23.string().optional().describe("Optional: a specific collection to review first (e.g. 'glossary', 'decisions')")
-    },
-    async ({ focus }) => {
-      let allDrafts = [];
-      try {
-        const raw = await mcpQuery("chain.listEntries", { status: "draft" });
-        if (Array.isArray(raw)) {
-          allDrafts = raw.filter(
-            (e) => typeof e === "object" && e !== null && typeof e.entryId === "string" && typeof e.name === "string" && typeof e.collection === "string"
-          );
-        }
-      } catch {
-      }
-      if (focus) {
-        allDrafts.sort((a, b) => {
-          const aMatch = a.collection === focus ? -1 : 0;
-          const bMatch = b.collection === focus ? -1 : 0;
-          return aMatch - bMatch;
-        });
-      }
-      const grouped = groupDraftsByCollection(allDrafts);
-      const draftList = formatDraftGroups(grouped, allDrafts.length);
-      const hasDrafts = allDrafts.length > 0;
-      return {
-        messages: [{
-          role: "user",
-          content: {
-            type: "text",
-            text: `# Review Drafts \u2014 Batch Commit Queue
-
-` + (hasDrafts ? draftList + "\n\n" : "No drafts found in this workspace. Everything is already committed.\n\n") + (hasDrafts ? `---
-
-## How to proceed
-
-Work through each collection group with the user. The goal is: every entry the user wants to keep gets committed.
-
-**Step 1 \u2014 Offer a starting point**
-
-Ask the user which group to tackle first, or suggest the most important one. A good default: start with Strategy and Decisions \u2014 these are high-signal and there are usually few of them. Glossary and Architecture entries can be batched quickly afterward.
-
-**Step 2 \u2014 Confirm, then commit**
-
-For each group the user confirms, call \`commit-entry\` once per entry. These must be sequential \u2014 commit each before moving to the next.
-
-\`\`\`
-commit-entry entryId="[ID]"
-\`\`\`
-
-Report any failures and skip rather than block. If commit returns \`proposal_created\`, tell the user \u2014 this workspace uses governed commits and proposals need approval.
-
-**Step 3 \u2014 Surface the WOW connection (once per committed batch)**
-
-After finishing a collection group, call \`graph action=suggest\` on up to 2 of the most important entries you just committed:
-- First choice: any strategy entry
-- Second choice: architecture or decisions entries
-- Maximum: 2 \`graph action=suggest\` calls per batch \u2014 not one per entry
-
-From the suggestions returned, pick the **most non-obvious connection** \u2014 the one that crosses collection boundaries (e.g. a vision entry connecting to a decision, not just two glossary terms). Prefer suggestions with specific reasoning over generic ones. Ignore suggestions with no reasoning.
-
-If a strong connection exists, present it exactly like this:
-
----
-**The graph noticed something.**
-
-Your **[Entry A]** connects to **[Entry B]** \u2014 [reasoning from the graph, in one sentence].
-
-You didn't explain this relationship. Product Brain inferred it from what you've built so far. This is the compounding starting.
-
-Want to add this link?
-\`\`\`
-relations action=create from=[A] to=[B] type=[relationType]
-\`\`\`
----
-
-If there are no specific suggestions (or all reasoning is generic), skip this step silently. Do not fabricate a connection.
-
-**Step 4 \u2014 The offer**
-
-After the first batch is committed (especially if it includes a strategy or decisions entry), offer:
-
-> "Ask me anything about your product \u2014 I'll answer using everything you just committed."
-
-This is not a formality. If the user asks a question, actually answer it using \`context action=gather task="<their question>"\`. Show them what the Brain now knows, not just that it captured the data.
-
-**Step 5 \u2014 Continue or wrap**
-
-After each batch, ask if the user wants to continue with the next group. Once all groups are done, close with a summary:
-
-- How many entries were committed this session
-- Which collections are now populated
-- One sentence: what Product Brain now knows about their product
-
-End with: **"Your Brain is ready."**` : `Your workspace has no uncommitted entries. If you recently captured new knowledge, check that \`batch-capture\` completed successfully and try \`entries action=list status=draft\`.`)
-          }
-        }]
-      };
-    }
-  );
 }
 
 // src/server.ts
@@ -10898,4 +10141,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-MDGV4MHW.js.map
+//# sourceMappingURL=chunk-WXT35272.js.map