@productbrain/mcp 0.0.1-beta.76 → 0.0.1-beta.78

package/dist/{chunk-BWK4N5YU.js → chunk-2TAMQOP7.js}

@@ -43,7 +43,7 @@ import {
   unknownAction,
   validationResult,
   withEnvelope
-} from "./chunk-KWQSXRIH.js";
+} from "./chunk-ZY3ORYC3.js";
 import {
   trackKnowledgeGap,
   trackQualityCheck,
@@ -238,7 +238,7 @@ ${formatted}` }],
     },
     withEnvelope(async ({ entryId }) => {
       requireWriteAccess();
-      const { runContradictionCheck } = await import("./smart-capture-HSQTA5JW.js");
+      const { runContradictionCheck } = await import("./smart-capture-VFCEUDDW.js");
       const entry = await mcpQuery("chain.getEntry", { entryId });
       if (!entry) {
         return notFoundResult(entryId, `Entry '${entryId}' not found. Try search to find the right ID.`);
@@ -1155,7 +1155,26 @@ async function handleBatchCreate(relations) {
   requireWriteAccess();
   const agentSessionId = getAgentSessionId();
   const results = [];
-  for (const rel of relations) {
+  const governsRels = relations.filter((r) => r.type === "governs");
+  const batchRels = relations.filter((r) => r.type !== "governs");
+  if (batchRels.length > 0) {
+    try {
+      const batchResult = await mcpMutation("chain.createEntryRelations", {
+        relations: batchRels.map((r) => ({ fromEntryId: r.from, toEntryId: r.to, type: r.type })),
+        sessionId: agentSessionId ?? void 0
+      });
+      for (let i = 0; i < batchRels.length; i++) {
+        const rel = batchRels[i];
+        const res = batchResult.results[i];
+        results.push({ ...rel, ok: res?.ok ?? false, error: res?.error });
+      }
+    } catch (e) {
+      for (const rel of batchRels) {
+        results.push({ ...rel, ok: false, error: e instanceof Error ? e.message : "Batch failed" });
+      }
+    }
+  }
+  for (const rel of governsRels) {
     try {
       const result = await mcpMutation("chain.createEntryRelation", {
         fromEntryId: rel.from,
@@ -3850,64 +3869,17 @@ The retro must never fail silently. Always communicate state.`
 var SHAPE_WORKFLOW_DESCRIPTOR = {
   id: "shape",
   name: "Shape a Bet",
-  shortDescription: "Coached shaping session \u2014 problem \u2192 appetite \u2192 elements \u2192 architecture \u2192 de-risk \u2192 pitch. Uses the `facilitate` tool 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. Uses `facilitate` for scoring and Chain capture.",
   template: {
     slug: "shape-a-bet",
     name: "Shape a Bet"
   },
   icon: "\u25C6",
-  facilitatorPreamble: `You are now in **Shaping Mode**. You are an **investigating** shaping facilitator powered by the \`facilitate\` tool and Cursor sub-agents.
-
-## Your Behavior
-
-1. **Start with \`facilitate action=start\`.** This creates a draft bet on the Chain and returns the Studio URL, initial coaching, and an investigationBrief.
-2. **Investigate before asking.** At each phase transition, read the \`investigationBrief\` in the structured response. Spawn sub-agents to search the codebase and Chain. Synthesize findings into proposals. Present proposals for user reaction.
-3. **Use \`facilitate action=respond\` for every input.** Pass the user's text, betEntryId, dimension, and the \`source\` field:
-   - \`source="user"\` \u2014 user typed this directly (default, full score weight)
-   - \`source="agent_proposal"\` \u2014 you generated this proposal text (discounted score)
-   - \`source="user_reaction"\` \u2014 user reacting to your proposal (full score weight)
-4. **Read the structured response carefully.** The coaching object tells you what to say next. The scorecard tells you what's missing. The investigationBrief tells you what to investigate for the next phase.
-5. **One dimension at a time.** Follow the round progression below. Don't dump all dimensions at once.
-6. **Push back with evidence.** Don't just ask "Who's affected?" \u2014 search the codebase for evidence and say "I found 3 workarounds in the codebase related to this. Here's what they suggest about the problem."
-7. **Capture elements and risks inline** using the \`capture\` parameter on respond calls. Each becomes a Chain entry with a relation to the bet.
-8. **CRITICAL: Elements, rabbit holes, and no-gos MUST use the \`capture\` parameter.** Never pass them as plain \`userInput\` without \`capture\`. Without \`capture\`, nothing is saved to the bet \u2014 the data is silently lost. Always include \`capture={type:"element"|"risk"|"noGo", name:"...", description:"..."}\` for every structured item. Each element, risk, and no-go needs its own \`respond\` call with \`capture\`.
-9. **When captureReady is true, offer to finalize** \u2014 but don't force it. The user decides when the shape is complete.
-
-## Investigation Pattern (ENT-59)
-
-At phase transitions, follow this pattern:
-1. Read the \`investigationBrief\` from the structured response
-2. Spawn sub-agents in parallel (max 2, 30s budget each):
-   - \`explore\` sub-agent: codebase searches (files, patterns, architecture)
-   - \`generalPurpose\` sub-agent: Chain searches (entries, governance, context)
-3. Synthesize findings into a concrete proposal (cite files and entry IDs)
-4. Present the proposal for user reaction \u2014 "Based on the codebase, I'd suggest..."
-5. Score the user's reaction with \`source="user_reaction"\` (full weight)
-
-If investigation fails or times out, continue with the conversation \u2014 the user's knowledge is always the primary input.
-
-## DEC-56 Boundary
-
-The **server judges** \u2014 it scores input against 6 rubric dimensions, detects overlap, checks governance alignment. Agent-generated text is scored at ${0.6}x weight to prevent keyword inflation (RH1).
-**You coach** \u2014 you interpret the structured response, synthesize naturally, investigate proactively, propose grounded solutions, and push back when shaping isn't sharp.
-The \`coaching.suggestedQuestion\` is a suggestion, not a script \u2014 rephrase or skip based on conversation flow.
-
-## Error Recovery
-
-If any facilitate call fails:
-1. Tell the user what you were trying to do
-2. Explain what went wrong (one sentence)
-3. Continue shaping \u2014 the conversation IS the backup
-4. Suggest retrying or capturing manually later
-
-## Communication Style
+  facilitatorPreamble: `You are now in **Shaping Mode**. The shaping skill owns the facilitation loop end-to-end \u2014 read it for scoring rubrics, investigation patterns, and the capture flow.
 
-- Start each round with its phase header
-- Keep chat messages to 5 lines or fewer \u2014 heavy context degrades performance
-- Use AskQuestion for structured choices (appetite, gates)
-- Synthesize between phases \u2014 reflect what was decided before moving on
-- When proposing, cite evidence: "I found X in the codebase" or "The Chain has DEC-Y about this"
-- If the user seems stuck, investigate and propose rather than just asking`,
+Use \`capture\` to create constellation entries (elements, risks, decisions, glossary terms) linked to the bet.
+Use \`facilitate action=commit-constellation\` to atomically commit the bet and all linked entries when the shape is complete.
+Use \`workflows action=checkpoint\` after each round to persist progress to the durable run.`,
   rounds: [
     {
       id: "context",
@@ -3915,13 +3887,13 @@ If any facilitate call fails:
       label: "Gather Context",
       type: "open",
       instruction: "Before shaping, let's see what the Chain already knows. Search for related entries, business rules, and existing decisions.",
-      facilitatorGuidance: "**Investigate proactively.** Spawn sub-agents in parallel: (1) `explore` agent to search the codebase for code related to the bet topic \u2014 find modules, patterns, and pain points. (2) `generalPurpose` agent to search the Chain: call `orient`, use `entries action=search` with keywords, surface related tensions, active bets, and applicable business rules. Synthesize both into a 3-5 line context brief: what the codebase reveals, what the Chain knows, what governance applies. Present with IDs and file paths. Then transition: 'Here's what I found. Does this match the problem you're seeing?'",
+      facilitatorGuidance: "**Investigate proactively.** Spawn sub-agents in parallel: (1) `explore` agent to search the codebase for code related to the bet topic \u2014 find modules, patterns, and pain points. (2) `generalPurpose` agent to search the Chain: call `orient`, use `entries action=search` with keywords, surface related tensions, active bets, and applicable business rules. Synthesize both into a 3-5 line context brief: what the codebase reveals, what the Chain knows, what governance applies. Present with IDs and file paths. Build a system map: what modules, data flows, and contracts exist in this area today? Check governance: do any principles, standards, or business rules constrain this design space? Then transition: 'Here's what I found. Does this match the problem you're seeing?'",
       outputSchema: {
         field: "context",
-        description: "Chain context: related entries, governance, existing decisions",
+        description: "System map, Chain context, governance constraints, related entries",
         format: "structured"
       },
-      maxDurationHint: "2 min"
+      maxDurationHint: "5 min"
     },
     {
       id: "framing",
@@ -3929,7 +3901,7 @@ If any facilitate call fails:
       label: "Frame the Problem",
       type: "open",
       instruction: "What's the problem? Who's affected? What's the workaround today? How much time is this worth?",
-      facilitatorGuidance: "This round covers problem_clarity AND appetite. If the investigationBrief has framing tasks, search the codebase for workarounds, TODOs, and hacks related to the problem \u2014 cite what you find as evidence. Call `facilitate action=respond` with dimension='problem_clarity' for the problem input, then dimension='appetite' for the time budget. Push with evidence: 'I found 3 workaround patterns in the codebase \u2014 this suggests the problem is bigger than it looks.' Use AskQuestion for appetite: Small Batch (1-2 weeks) or Big Batch (6 weeks). When both dimensions score 6+, present the frame and ask for Frame Go confirmation. If new terms surfaced, capture them to the glossary via `capture`. If tensions surfaced, capture them too.",
+      facilitatorGuidance: "This round covers problem clarity AND appetite. Search the codebase for workarounds, TODOs, and hacks related to the problem \u2014 cite what you find as evidence. Push with evidence: 'I found 3 workaround patterns in the codebase \u2014 this suggests the problem is bigger than it looks.' Use AskQuestion for appetite: Small Batch (1-2 weeks) or Big Batch (6 weeks). When both dimensions are well-covered, present the frame and ask for Frame Go confirmation. If new terms surfaced, capture them to the glossary via `capture`. If tensions surfaced, capture them too.",
       questions: [
         {
           id: "appetite",
@@ -3962,7 +3934,7 @@ If any facilitate call fails:
       label: "Find the Elements",
       type: "open",
       instruction: "What are the solution elements? Think breadboard level \u2014 places, affordances, connections. What's the architecture?",
-      facilitatorGuidance: "**Investigate first.** Read the investigationBrief. Spawn sub-agents to search the codebase for affected modules, existing architecture patterns, and API boundaries. Synthesize findings into 3-5 proposed solution elements at breadboard level, citing specific files and modules. Present proposals for user reaction: 'Based on the codebase, here are the elements I'd suggest.' For each confirmed element, capture with its own respond call: `facilitate action=respond betEntryId='...' dimension='elements' source='user_reaction' userInput='...' capture={type:'element', name:'Element Name', description:'What it does'}`. Without the `capture` parameter, the element is NOT saved to the bet \u2014 you will get a WARNING if you forget. Each captured element becomes a features entry linked to the bet via part_of. For Big Batch: also investigate architecture \u2014 search for layer boundaries and dependency directions, then propose architecture. Call respond with dimension='architecture' for architecture input (no capture needed \u2014 free-form text). Check business rules: do any elements conflict with governance surfaced in Round 1? Capture new glossary terms and decisions as they surface. Aim for 3-5 elements. When elements score 6+ (and architecture for Big Batch), present for confirmation.",
+      facilitatorGuidance: "**Investigate first.** Spawn sub-agents to search the codebase for affected modules, existing architecture patterns, and API boundaries. Synthesize findings into 3-5 proposed solution elements at breadboard level, citing specific files and modules. **Five-path trace per element:** For each element, trace: (1) what data flows through it, (2) what contracts it relies on, (3) what contracts it alters, (4) what second-order effects downstream, (5) what happens at boundaries (batch, error, empty, scale). Present proposals for user reaction: 'Based on the codebase, here are the elements I'd suggest.' For each confirmed element, use `capture` with collection='features' to create a features entry linked to the bet via part_of. For Big Batch: also investigate architecture \u2014 search for layer boundaries and dependency directions, then propose architecture. Check business rules: do any elements conflict with governance surfaced in Round 1? Capture new glossary terms and decisions as they surface. Aim for 3-5 elements. When elements and architecture are well-covered, present for confirmation.",
       outputSchema: {
         field: "elements",
         description: "Core solution elements and architecture",
@@ -3977,7 +3949,7 @@ If any facilitate call fails:
       label: "De-risk \u2014 Rabbit Holes & No-Gos",
       type: "open",
       instruction: "What could go wrong? What are we NOT building? Walk through the solution slowly and find the risks.",
-      facilitatorGuidance: "**Investigate first.** Read the investigationBrief. Spawn sub-agents to search the codebase for fragile code, tight coupling, missing tests, performance-sensitive paths, and external dependencies near the affected modules. Propose risks with evidence: 'I found that X module has no tests and is tightly coupled to Y \u2014 this is a rabbit hole.' Every confirmed risk MUST be captured with its own respond call: `facilitate action=respond betEntryId='...' dimension='risks' source='user_reaction' userInput='...' capture={type:'risk', name:'Risk Name', description:'What could go wrong', theme:'implementation'}`. Each becomes a tensions entry linked to the bet via constrains. Push for mitigations \u2014 every risk needs a patch or explicit acceptance. Then declare no-gos: 'Based on what I've seen, I'd suggest these no-gos.' Every no-go MUST use capture: `facilitate action=respond betEntryId='...' dimension='boundaries' source='user_reaction' userInput='...' capture={type:'noGo', name:'No-Go Title', description:'Why we are not doing this'}`. Without the `capture` parameter on each call, the item is NOT saved \u2014 you will get a WARNING. **Counter-Metric Mandate (STD-19):** If the derisking references any quantitative gates or metrics (accuracy targets, performance budgets, adoption thresholds), stress-test them: 'What's the denominator? What gets excluded? What counter-metric would expose a false positive?' A metric gate that can be gamed by abstaining or cherry-picking the population is not a gate \u2014 name the compound metric that can't be gamed. When risks score 6+ and boundaries score 4+, present Shape Go gate: 'Is this buildable within the appetite?'",
+      facilitatorGuidance: "**Investigate first.** Spawn sub-agents to search the codebase for fragile code, tight coupling, missing tests, performance-sensitive paths, and external dependencies near the affected modules. Propose risks with evidence: 'I found that X module has no tests and is tightly coupled to Y \u2014 this is a rabbit hole.' Every confirmed risk MUST be captured using `capture` with collection='tensions' \u2014 each becomes a tensions entry linked to the bet via constrains. Push for mitigations \u2014 every risk needs a patch or explicit acceptance. Then declare no-gos: 'Based on what I've seen, I'd suggest these no-gos.' Every no-go MUST also be captured. **Counter-Metric Mandate (STD-19):** If the derisking references any quantitative gates or metrics (accuracy targets, performance budgets, adoption thresholds), stress-test them: 'What's the denominator? What gets excluded? What counter-metric would expose a false positive?' A metric gate that can be gamed by abstaining or cherry-picking the population is not a gate \u2014 name the compound metric that can't be gamed. When risks and boundaries are well-covered, present Shape Go gate: 'Is this buildable within the appetite?'",
       questions: [
         {
           id: "shape-go",
@@ -4003,7 +3975,7 @@ If any facilitate call fails:
       label: "Validate & Build Contract",
       type: "synthesis",
       instruction: "Check completeness. Generate the build contract. Review the full scorecard.",
-      facilitatorGuidance: "Call `facilitate action=score` to get the full scorecard. Present it as a table. Check: does the response include a buildContract? If captureReady is true, it should. Verify the 5 core ingredients: Problem, Appetite, Solution elements, Rabbit Holes, No-Gos. For Big Batch: also verify Architecture, narrative hook, and value-flow annotations. **Counter-Metric Mandate (STD-19):** If the scorecard or build contract contains metrics or gates, verify each has a denominator, a coverage rate, and a counter-metric. Flag any gate that can be satisfied by abstaining or excluding the hard cases. Present the build contract. Ask: 'Anything to adjust before we capture to the Chain?'",
+      facilitatorGuidance: "Review the scorecard from the shaping skill's scoring rubric. Present it as a table. Verify the 5 core ingredients: Problem, Appetite, Solution elements, Rabbit Holes, No-Gos. For Big Batch: also verify Architecture, narrative hook, and value-flow annotations. **System coherence confirmation:** Were all five paths traced for each element? State which interaction risks remain unverified \u2014 these become explicit risks in the bet, not surprises during implementation. **Vision narrative (TEN-281):** Write one paragraph \u2014 how does this bet serve the product vision? **Test plan (TEN-281):** How will we know this is done? Concrete scenarios, not 'when tests pass.' **Counter-Metric Mandate (STD-19):** If the scorecard or build contract contains metrics or gates, verify each has a denominator, a coverage rate, and a counter-metric. Flag any gate that can be satisfied by abstaining or excluding the hard cases. Present the build contract. Ask: 'Anything to adjust before we capture to the Chain?'",
       outputSchema: {
         field: "validation",
         description: "Completeness check result and build contract",
@@ -4017,7 +3989,7 @@ If any facilitate call fails:
       label: "Capture & Commit",
       type: "close",
       instruction: "Capture the pitch to the Chain. Commit draft entries. Connect the constellation.",
-      facilitatorGuidance: "List all draft entries created during shaping (elements, risks, decisions, glossary terms). Ask the user to confirm: 'Ready to commit these to the Chain?' For each confirmed entry: `commit-entry entryId='...'`. Then `graph action=suggest entryId='<betId>'` to discover connections. Create the top 3 suggested relations. Update the bet status from 'shaping' to 'shaped'. Thank the user and summarize: how many entries captured, relations created, Chain enrichment.",
+      facilitatorGuidance: "List all draft entries created during shaping (elements, risks, decisions, glossary terms). Ask the user to confirm: 'Ready to commit these to the Chain?' Call `facilitate action=commit-constellation` to atomically commit the bet and all linked entries. Then `graph action=suggest entryId='<betId>'` to discover connections. Create the top 3 suggested relations via `relations action=batch-create`. Thank the user. State: what was shaped, how many constellation entries captured, what the implementer inherits.",
       outputSchema: {
         field: "capture",
         description: "Final capture summary \u2014 entries committed, relations created",
@@ -4063,14 +4035,13 @@ If any facilitate call fails:
     ]
   },
   runtime: {
-    kind: "facilitated",
-    primaryTool: "facilitate"
+    kind: "guided"
   },
   errorRecovery: `If anything goes wrong during shaping:
 
 1. **facilitate tool failure**: Continue the conversation. The shaping knowledge is in the chat. Suggest retrying the tool call or capturing manually later.
 2. **Chain capture failure (duplicate)**: The tool handles duplicates by linking existing entries. If it still fails, note the entry name and move on \u2014 capture manually after the session.
-3. **Score seems wrong**: Call \`facilitate action=score\` to get a clean read. Scores are heuristic \u2014 the agent's judgment matters more than the number.
+3. **Score seems wrong**: Scoring is local to the shaping skill \u2014 re-apply the scoring rubric from the shaping SKILL.md against the conversation context. Scores are heuristic; the agent's judgment matters more than the number.
 4. **User wants to stop mid-session**: Respect it. Everything captured so far is on the Chain as drafts. Use \`facilitate action=resume\` to pick up later.
 5. **MCP server unreachable**: Run the shaping from conversation knowledge. Skip chain capture. Say: "Product Brain is temporarily unavailable \u2014 I'll shape from our conversation and we can commit afterward."
 
@@ -4079,7 +4050,7 @@ The shaping must never fail silently. Always communicate state.`
 var IMPLEMENTATION_REVIEW_WORKFLOW_DESCRIPTOR = {
   id: "implementation-review",
   name: "Implementation Review",
-  shortDescription: "Review completed implementation against standards, Chain coherence, and test honesty. Spawns sub-agents, uses Context7 for library docs, validates chain is up to date. Ends with BET/chain IDs. Commits an insight to the Chain.",
+  shortDescription: "Fix-as-you-go implementation review: finds issues, fixes them immediately, verifies, then proceeds. Three expert lenses (Staff+ Engineer, CTO, Chain Coherence). Spawns sub-agents for code and test review. Extracts learnings into standards/rules. Ends with BET/chain IDs. Commits an insight to the Chain.",
   template: {
     slug: "implementation-review",
     name: "Implementation Review"
@@ -4099,11 +4070,13 @@ var IMPLEMENTATION_REVIEW_WORKFLOW_DESCRIPTOR = {
 ## Your Behavior
 
 1. **Tool-heavy, not chat-heavy.** Each round calls specific tools: orient, quality, verify, chain-review, context action=gather, review-against-rules. Use Context7 (query-docs) for relevant testing and framework docs \u2014 not for Chain truth.
-2. **Spawn sub-agents** for parallel review: (a) code/architecture review, (b) test honesty (did we edit tests to pass or do they validate real behavior?), (c) Chain/standards coherence. Max 2 agents in parallel, 30s budget each. **Constrain each sub-agent to the stated review scope only.**
-3. **Chain is SSOT.** Call orient or start first. Use entries action=search and context action=gather to load relevant BETs, DECs, BRs. If findings conflict with Chain entries, report the conflict and cite the entry ID.
-4. **One round at a time.** Complete each round before moving to the next. Checkpoint progress.
-5. **CRITICAL: End with BET/chain IDs.** The final output MUST include a single sentence: "BET/feature IDs reviewed: [IDs]. [One-line summary of findings]."
-6. **Never go silent.** If a tool fails, explain and continue. The conversation IS the backup.
+2. **Spawn sub-agents** for parallel review: (a) code/architecture review, (b) test honesty (did we edit tests to pass or do they validate real behavior?). Max 2 agents in parallel, 30s budget each. **Constrain each sub-agent to the stated review scope only.**
+3. **Fix-as-you-go (FEAT-172).** When you find a HIGH or MEDIUM issue: fix it immediately, verify (lints, types), then proceed. The user sees clean work, not a list of issues. Only defer if estimated >5 min \u2014 capture deferred items as tensions. If user says "skip", capture as tension and continue.
+4. **Chain is SSOT.** Call orient or start first. Use entries action=search and context action=gather to load relevant BETs, DECs, BRs. If findings conflict with Chain entries, report the conflict and cite the entry ID.
+5. **One round at a time.** Complete each round before moving to the next. Checkpoint progress.
+6. **Extract learnings (FEAT-174).** After fixing issues, ask: is this a recurring pattern? Offer to capture structural patterns as standards or business rules so future reviews check automatically.
+7. **CRITICAL: End with BET/chain IDs.** The final output MUST include a single sentence: "BET/feature IDs reviewed: [IDs]. [One-line summary of findings]."
+8. **Never go silent.** If a tool fails, explain and continue. The conversation IS the backup.
 
 ## Tool Usage
 
@@ -4137,13 +4110,13 @@ This block is the final deliverable of the review. Everything else is supporting
       label: "Orient & Scope",
       type: "open",
       instruction: "Apply the Review scope rules: infer scope from this conversation, git diff, and recent edits (default = work in this conversation only). Enumerate every file touched (created, modified, deleted). Call orient or start, then context action=gather for the inferred BET/feature. State scope in one explicit sentence and list all files in scope. Only ask the participant if scope is ambiguous. The review will assess: holistic coherence with our system, whether this brings us closer to our vision, and whether it makes our code and architecture cleaner.",
-      facilitatorGuidance: "Infer scope from conversation context, git status/diff, and recent edits \u2014 default is work in this conversation only. List every file touched (created, modified, or deleted) in the work under review; scope is not complete without this list. Call orient or start to load governance and active bets. Use context action=gather task='implementation review for [inferred-BET-or-feature]' to load related entries. State scope explicitly in one sentence (e.g. 'Scope: changes in this conversation for BET-72'). Present: stated scope, the full list of files touched, relevant BETs/DECs/BRs, and any stale entries orient surfaces. Frame the review: we will assess holistic coherence with our system, whether this brings us closer to our vision, and whether it makes our code and architecture cleaner. Ask the participant only if scope is ambiguous (e.g. 'Only the files we changed, or the whole feature?').",
+      facilitatorGuidance: "Infer scope from conversation context, git status/diff, and recent edits \u2014 default is work in this conversation only. List every file touched (created, modified, or deleted) in the work under review; scope is not complete without this list. Call orient or start to load governance and active bets. Use context action=gather task='implementation review for [inferred-BET-or-feature]' to load related entries. State scope explicitly in one sentence (e.g. 'Scope: changes in this conversation for BET-72'). Present: stated scope, the full list of files touched, relevant BETs/DECs/BRs, and any stale entries orient surfaces. Frame the review: we will assess holistic coherence with our system, whether this brings us closer to our vision, and whether it makes our code and architecture cleaner. Ask the participant only if scope is ambiguous (e.g. 'Only the files we changed, or the whole feature?'). Note vision anchors (principles, strategy, active bet constraints) \u2014 you will reference these in Rounds 02\u201305.",
       outputSchema: {
         field: "scope",
-        description: "Explicit scope statement, every file touched, BET/feature IDs and related Chain context",
+        description: "Explicit scope statement, every file touched, BET/feature IDs, related Chain context, vision anchors",
         format: "structured"
       },
-      maxDurationHint: "3 min"
+      maxDurationHint: "2 min"
     },
     {
       id: "standards-review",
@@ -4164,8 +4137,8 @@ This block is the final deliverable of the review. Everything else is supporting
       num: "03",
       label: "Code & Test Honesty",
       type: "open",
-      instruction: "Spawn sub-agents to review implementation and tests for the stated scope only. Did we meet high standards? Are tests validating real behavior or did we edit them just to pass?",
-      facilitatorGuidance: "Restrict all review to the scope stated in Round 01 (by default, work in this conversation only). Spawn 1\u20132 sub-agents in parallel: (1) explore agent \u2014 code review, architecture boundaries, type-safety for scoped files only. (2) generalPurpose agent \u2014 test review for scoped code: are tests asserting real behavior or were they edited to pass? Pass the scope (files/BET) explicitly to sub-agents so they do not touch other work. Use Context7 (query-docs) for relevant testing and framework best practices if needed. Classify any test failures: staleness, regression, or flaky. **Counter-Metric Mandate (STD-19):** When reporting test coverage, accuracy, or any quantitative result, include the denominator, what was excluded, and at least one counter-metric. Never report accuracy without recall. Never report pass rate without coverage. Synthesize: implementation grade, test honesty verdict, refactoring suggestions (within scope only).",
+      instruction: "Spawn sub-agents to review implementation and tests for the stated scope only. Fix every HIGH/MEDIUM finding before proceeding. Did we meet high standards? Are tests validating real behavior or did we edit them just to pass?",
+      facilitatorGuidance: "Restrict all review to the scope stated in Round 01 (by default, work in this conversation only). Spawn 1\u20132 sub-agents in parallel: (1) explore agent \u2014 code review, architecture boundaries, type-safety for scoped files only. (2) explore agent \u2014 test review for scoped code: are tests asserting real behavior or were they edited to pass? Pass the scope (files/BET) explicitly to sub-agents so they do not touch other work. Use Context7 (query-docs) for relevant testing and framework best practices if needed. Classify any test failures: staleness, regression, or flaky. **Fix-as-you-go (FEAT-172):** For every HIGH/MEDIUM finding: fix immediately, run lints, verify types. Only defer fixes estimated >5 min \u2014 capture deferred items as tensions on the Chain. After fixing, do a boy-scout pass on each scoped file: clean imports, improve naming, remove dead code. **Counter-Metric Mandate (STD-19):** When reporting test coverage, accuracy, or any quantitative result, include the denominator, what was excluded, and at least one counter-metric. Never report accuracy without recall. Never report pass rate without coverage. Synthesize: findings, fixes applied, implementation grade, test honesty verdict.",
       outputSchema: {
         field: "codeAndTests",
         description: "Implementation grade, test honesty, refactor suggestions",
@@ -4176,41 +4149,41 @@ This block is the final deliverable of the review. Everything else is supporting
     {
       id: "chain-validation",
       num: "04",
-      label: "Validate Chain Up to Date",
+      label: "Chain Validation & Learning Extraction",
       type: "synthesis",
-      instruction: "Run verify. Check orient for stale entries. Is the Chain current with the codebase?",
-      facilitatorGuidance: "Call verify (report mode) \u2014 checks glossary code mappings and cross-references. Orient surfaces stale entries (per workspace governance). Present trust score and any drift. If drift found: recommend update-entry or capture to reconcile.",
+      instruction: "Run verify. Check orient for stale entries. Is the Chain current with the codebase? Then extract learnings: did this review surface structural patterns that should become standards or rules?",
+      facilitatorGuidance: "**Chain validation:** Call verify (report mode) \u2014 checks glossary code mappings and cross-references. Orient surfaces stale entries (per workspace governance). Present trust score and any drift. If drift found: fix immediately via update-entry (with changeNote). **Learning extraction (FEAT-174, TEN-272):** Review all findings from Rounds 02 and 03. Ask: did this review surface a structural pattern that could recur? For each pattern: could it be a standard ('We always do X this way'), a business rule ('The system must do X'), or a lint rule (automated check)? Offer to capture. Also offer to capture any decisions, tensions, or new terms surfaced during the review. The goal: today's bug becomes tomorrow's automated check (TEN-272).",
       outputSchema: {
         field: "chainValidation",
-        description: "Verify trust score, stale entries, drift recommendations",
+        description: "Verify trust score, drift fixes, extracted learnings (patterns \u2192 standards/rules)",
         format: "structured"
       },
-      maxDurationHint: "3 min"
+      maxDurationHint: "5 min"
     },
     {
       id: "synthesis",
       num: "05",
       label: "Synthesis & Sign-Off",
       type: "commit",
-      instruction: "Summarize the review. Answer: Does this bring us closer to our vision and make our code and architecture cleaner? Refactoring needed? Ship or conditional? End with BET/chain IDs.",
-      facilitatorGuidance: "Present the full synthesis: standards pass/fail, code grade, test honesty, chain validation. Explicitly answer: Does this bring us closer to our vision and make our code and architecture cleaner? **Counter-Metric Mandate (STD-19):** For EVERY quantitative result you present, you MUST include: (1) the denominator \u2014 what is the total population measured, (2) the coverage/abstention rate \u2014 what was excluded, (3) at least one counter-metric that tells the opposite story (recall vs precision, error rate vs success rate), (4) the 'student exam' reframe \u2014 score on the full exam, not just questions answered. **Red-team your own synthesis:** Before presenting, ask yourself: 'What's the worst honest interpretation of these numbers? What metric looks good but hides a real problem? What would a skeptic challenge?' Present that alongside the headline. Recommend: ship, ship with conditions, or do not ship. CRITICAL: The output MUST end with one sentence: 'BET/feature IDs reviewed: [IDs]. [One-line summary].' Example: 'BET-xxx, STD-xxx reviewed. Conditional ship \u2014 fix [specific issues] and add [missing tests].' **Structured Verdict Block (REQUIRED):** After the full synthesis, present the verdict block with exactly 5 items: (1) Verdict: Y or N \u2014 one word. (2) What shipped: one sentence. (3) Why it matters: one sentence on the problem solved. (4) User benefit: one sentence on value for users. (5) How to validate: one sentence on verification. This block is the final deliverable. Everything else is supporting evidence.",
+      instruction: "Synthesize the review. Answer: Does this bring us closer to our vision and make our code and architecture cleaner? With fix-as-you-go, most issues are already resolved \u2014 summarize what was fixed, not what's left. End with BET/chain IDs.",
+      facilitatorGuidance: "Present the full synthesis: standards pass/fail, code grade, test honesty, chain validation, fixes applied. **Vision delta:** Cite specific principles/strategy entries from Round 01. Answer: does this bring us closer to [cited vision]? **Counter-Metric Mandate (STD-19):** For EVERY quantitative result you present, you MUST include: (1) the denominator \u2014 what is the total population measured, (2) the coverage/abstention rate \u2014 what was excluded, (3) at least one counter-metric that tells the opposite story (recall vs precision, error rate vs success rate), (4) the 'student exam' reframe \u2014 score on the full exam, not just questions answered. **Red-team your own synthesis:** Before presenting, ask yourself: 'What's the worst honest interpretation of these numbers? What metric looks good but hides a real problem? What would a skeptic challenge?' Present that alongside the headline. Recommend: ship, ship with conditions, or do not ship. CRITICAL: The output MUST end with one sentence: 'BET/feature IDs reviewed: [IDs]. [One-line summary].' Example: 'BET-xxx, STD-xxx reviewed. Conditional ship \u2014 fix [specific issues] and add [missing tests].' **Structured Verdict Block (REQUIRED):** After the full synthesis, present the verdict block with exactly 5 items: (1) Verdict: Y or N \u2014 one word. (2) What shipped: one sentence. (3) Why it matters: one sentence on the problem solved. (4) User benefit: one sentence on value for users. (5) How to validate: one sentence on verification. This block is the final deliverable. Everything else is supporting evidence.",
       outputSchema: {
         field: "synthesis",
-        description: "Full review synthesis with BET/chain IDs and structured verdict block (verdict Y/N, what shipped, why it matters, user benefit, how to validate)",
+        description: "Full review synthesis with vision delta, fixes applied, BET/chain IDs, and structured verdict block",
         format: "structured"
       },
-      maxDurationHint: "5 min"
+      maxDurationHint: "3 min"
     },
     {
       id: "capture",
       num: "06",
       label: "Capture & Close",
       type: "close",
-      instruction: "Finalize the review as an insight draft. Use session-wrapup. Thank the participant.",
-      facilitatorGuidance: "Summarize the review for finalization. Complete the terminal round through `workflows action=checkpoint` with `isFinal=true` so the workflow substrate creates the draft insight record. Include: BET/feature IDs, verdict, key findings, and the structured verdict block from Round 05. The insight description MUST include the 5-item verdict block (verdict Y/N, what shipped, why it matters, user benefit, how to validate). Run session-wrapup before closing. Thank the participant. Remind them to commit-entry when ready.",
+      instruction: "Finalize the review as an insight draft. Connect new entries from learning extraction. Use session-wrapup. Thank the participant.",
+      facilitatorGuidance: "Summarize the review for finalization. Complete the terminal round through `workflows action=checkpoint` with `isFinal=true` so the workflow substrate creates the draft insight record. Include: BET/feature IDs, verdict, key findings, fixes applied, and the structured verdict block from Round 05. The insight description MUST include the 5-item verdict block (verdict Y/N, what shipped, why it matters, user benefit, how to validate). If learnings were captured in Round 04: run graph action=suggest for each new entry, then relations action=batch-create. Run session-wrapup before closing. Thank the participant. State what was fixed, what was captured, what was deferred.",
       outputSchema: {
         field: "capture",
-        description: "Insight entry created, BET IDs referenced",
+        description: "Insight entry created, BET IDs referenced, learnings connected",
         format: "structured"
       },
       kbCollection: "insights",
@@ -5101,1128 +5074,18 @@ function parseListOutput(output) {
 
 // src/tools/facilitate.ts
 import { z as z12 } from "zod";
-
-// src/tools/facilitate-rubrics.ts
-var AGENT_DISCOUNT_FACTOR = 0.6;
-var DIMENSIONS = [
-  "problem_clarity",
-  "appetite",
-  "elements",
-  "architecture",
-  "risks",
-  "boundaries",
-  "done_when"
-];
-var DIMENSION_LABELS = {
-  problem_clarity: "Problem Clarity",
-  appetite: "Appetite Definition",
-  elements: "Element Decomposition",
-  architecture: "Architecture Grounding",
-  risks: "Risk Coverage",
-  boundaries: "Boundary Specification",
-  done_when: "Done-When Quality"
-};
-var SUGGESTED_ORDER = [
-  "problem_clarity",
-  "appetite",
-  "elements",
-  "architecture",
-  "risks",
-  "boundaries",
-  "done_when"
-];
-var PHASE_ORDER = [
-  "context",
-  "framing",
-  "elements",
-  "derisking",
-  "validation",
-  "capture"
-];
-var PHASE_LABELS = {
-  context: "Phase 0: Gather Context",
-  framing: "Phase 1: Frame the Problem",
-  elements: "Phase 2: Find the Elements",
-  derisking: "Phase 3: De-risk",
-  validation: "Phase 4: Validate & Contract",
-  capture: "Phase 5: Capture & Commit"
-};
-function contentFloor(content, isSmallBatch) {
-  const hasElements = content.elementCount >= 1;
-  const hasDerisking = content.riskCount >= 1 || content.noGoCount >= 1;
-  const hasArchOrSkipped = isSmallBatch || !!content.hasArchitectureText;
-  const wellShaped = content.elementCount >= 2 && hasDerisking && hasArchOrSkipped;
-  if (wellShaped && content.riskCount >= 1 && content.noGoCount >= 2) return "validation";
-  if (hasDerisking) return "derisking";
-  if (hasElements) return "elements";
-  return "context";
-}
-function laterPhase(a, b) {
-  return PHASE_ORDER.indexOf(a) >= PHASE_ORDER.indexOf(b) ? a : b;
-}
-function inferPhase(scorecard, isSmallBatch = false, content) {
-  let scorePhase;
-  if (scorecard.problem_clarity === 0 && scorecard.appetite === 0) scorePhase = "context";
-  else if (scorecard.problem_clarity < 6 || scorecard.appetite < 6) scorePhase = "framing";
-  else {
-    const archGate = isSmallBatch ? true : scorecard.architecture >= 4;
-    if (scorecard.elements < 6 || !archGate) scorePhase = "elements";
-    else if (scorecard.risks < 6 || scorecard.boundaries < 4 || scorecard.done_when < 4) scorePhase = "derisking";
-    else {
-      const activeDims = activeDimensions(isSmallBatch);
-      const allAboveThreshold = activeDims.every((d) => scorecard[d] >= 4);
-      if (!allAboveThreshold) scorePhase = "derisking";
-      else {
-        const highQuality = activeDims.every((d) => scorecard[d] >= 6);
-        scorePhase = highQuality ? "capture" : "validation";
-      }
-    }
-  }
-  if (!content) return scorePhase;
-  return laterPhase(scorePhase, contentFloor(content, isSmallBatch));
-}
-function activeDimensions(isSmallBatch) {
-  return isSmallBatch ? SUGGESTED_ORDER.filter((d) => d !== "architecture") : SUGGESTED_ORDER;
-}
-var WORKAROUND_SIGNALS = [
-  "workaround",
-  "currently",
-  "today",
-  "right now",
-  "manually",
-  "hack",
-  "instead",
-  "rather than",
-  "in practice",
-  "as-is"
-];
-var AFFECTED_SIGNALS = [
-  "user",
-  "team",
-  "developer",
-  "engineer",
-  "customer",
-  "everyone",
-  "nobody",
-  "people",
-  "stakeholder",
-  "builder"
-];
-var FREQUENCY_SIGNALS = [
-  "every time",
-  "always",
-  "often",
-  "rarely",
-  "daily",
-  "weekly",
-  "never",
-  "sometimes",
-  "constantly",
-  "repeatedly",
-  "each session",
-  "per session"
-];
-var APPETITE_SIGNALS = [
-  "week",
-  "weeks",
-  "day",
-  "days",
-  "month",
-  "sprint",
-  "small batch",
-  "big batch",
-  "appetite",
-  "time box",
-  "timebox",
-  "budget",
-  "phased"
-];
-var SCOPE_SIGNALS = [
-  "trade-off",
-  "tradeoff",
-  "trade off",
-  "not including",
-  "out of scope",
-  "defer",
-  "skip",
-  "cut",
-  "80%",
-  "good enough",
-  "mvp",
-  "v1",
-  "phase"
-];
-var RISK_SIGNALS = [
-  "risk",
-  "rabbit hole",
-  "unknown",
-  "complexity",
-  "might",
-  "could fail",
-  "latency",
-  "performance",
-  "coupling",
-  "dependency",
-  "fragile",
-  "brittle",
-  "unclear",
-  "uncertain",
-  "tricky"
-];
-var MITIGATION_SIGNALS = [
-  "patch",
-  "mitigate",
-  "accept",
-  "workaround",
-  "fallback",
-  "circuit breaker",
-  "degrade",
-  "graceful",
-  "monitor",
-  "benchmark"
-];
-var NOGO_SIGNALS = [
-  "no-go",
-  "nogo",
-  "won't",
-  "will not",
-  "must not",
-  "not building",
-  "out of scope",
-  "explicitly excluded",
-  "defer",
-  "not in v1",
-  "not in this bet"
-];
-var ARCHITECTURE_SIGNALS = [
-  "layer",
-  "boundary",
-  "dependency",
-  "api",
-  "contract",
-  "interface",
-  "module",
-  "component",
-  "service",
-  "schema",
-  "mermaid",
-  "diagram",
-  "infra",
-  "core",
-  "feature"
-];
-var ARCH_QUALITY_SIGNALS = [
-  "direction",
-  "imports",
-  "never imports",
-  "http only",
-  "separation",
-  "encapsulat",
-  "decouple",
-  "isolat"
-];
-var DONE_WHEN_SIGNALS = [
-  "done when",
-  "acceptance criteria",
-  "verified",
-  "test plan",
-  "validation",
-  "rollback",
-  "gate",
-  "threshold",
-  "metric",
-  "success",
-  "p95",
-  "p99"
-];
-function countMatches(text, signals) {
-  const lower = text.toLowerCase();
-  return signals.filter((s) => lower.includes(s)).length;
-}
-function clamp(n, min, max) {
-  return Math.max(min, Math.min(max, n));
-}
-function scoreProblemClarity(ctx) {
-  const text = ctx.dimensionTexts.problem_clarity;
-  const missing = [];
-  const satisfied = [];
-  const criteria = [];
-  let score = 0;
-  const hasWorkaround = countMatches(text, WORKAROUND_SIGNALS) > 0;
-  criteria.push({ label: "Current workaround described", met: hasWorkaround, weight: 3 });
-  if (hasWorkaround) {
-    satisfied.push("Current workaround described");
-    score += 3;
-  } else {
-    missing.push("Describe the current workaround \u2014 how do people deal with this today?");
-  }
-  const hasAffected = countMatches(text, AFFECTED_SIGNALS) > 0;
-  criteria.push({ label: "Affected people identified", met: hasAffected, weight: 2 });
-  if (hasAffected) {
-    satisfied.push("Affected people identified");
-    score += 2;
-  } else {
-    missing.push("Who experiences this problem? Be specific about the role or persona.");
-  }
-  const hasFrequency = countMatches(text, FREQUENCY_SIGNALS) > 0;
-  criteria.push({ label: "Frequency or severity stated", met: hasFrequency, weight: 2 });
-  if (hasFrequency) {
-    satisfied.push("Frequency or severity stated");
-    score += 2;
-  } else {
-    missing.push("How often does this happen, or how severe is it when it does?");
-  }
-  if (ctx.existingEntryIds.length > 0) {
-    satisfied.push(`Differentiated from ${ctx.existingEntryIds.length} existing entries`);
-    criteria.push({ label: "Differentiated from existing entries", met: true, weight: 2 });
-    score += 2;
-  } else if (/\b(TEN|DEC|ENT|FEAT|BET)-\w+/i.test(text)) {
-    satisfied.push("References existing Chain entries");
-    criteria.push({ label: "References existing Chain entries", met: true, weight: 1 });
-    score += 1;
-  } else {
-    missing.push("How does this differ from existing tensions or bets on the Chain?");
-    criteria.push({ label: "Differentiated from existing entries", met: false, weight: 2 });
-  }
-  const isSubstantive = text.length > 200;
-  criteria.push({ label: "Substantive description provided", met: isSubstantive, weight: 1 });
-  if (isSubstantive) {
-    satisfied.push("Substantive description provided");
-    score += 1;
-  }
-  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
-}
-function scoreAppetite(ctx) {
-  const text = ctx.dimensionTexts.appetite;
-  const missing = [];
-  const satisfied = [];
-  const criteria = [];
-  let score = 0;
-  const hasSizeDecl = /small\s*batch|big\s*batch|[1-6]\s*week/i.test(text);
-  const hasTimeSignals = countMatches(text, APPETITE_SIGNALS) > 0;
-  if (hasSizeDecl) {
-    satisfied.push("Size and timeframe declared");
-    criteria.push({ label: "Size and timeframe declared", met: true, weight: 4 });
-    score += 4;
-  } else if (hasTimeSignals) {
-    satisfied.push("Time constraint mentioned");
-    criteria.push({ label: "Size and timeframe declared", met: false, weight: 4 });
-    criteria.push({ label: "Time constraint mentioned", met: true, weight: 2 });
-    score += 2;
-    missing.push("Declare the batch size explicitly \u2014 Small Batch (1-2 weeks) or Big Batch (6 weeks).");
-  } else {
-    criteria.push({ label: "Size and timeframe declared", met: false, weight: 4 });
-    missing.push("Set a time constraint \u2014 how long is this bet allowed to take?");
-  }
-  const hasTradeoffs = countMatches(text, SCOPE_SIGNALS) > 0;
-  criteria.push({ label: "Scope bounded with trade-offs", met: hasTradeoffs, weight: 2 });
-  if (hasTradeoffs) {
-    satisfied.push("Scope bounded with trade-offs");
-    score += 2;
-  } else {
-    missing.push("What trade-offs are you making? What's the 80% cut?");
-  }
-  const hasPhased = /phase\s*[a-c1-3]|phased|milestone/i.test(text);
-  criteria.push({ label: "Phased delivery strategy", met: hasPhased, weight: 2 });
-  if (hasPhased) {
-    satisfied.push("Phased delivery strategy");
-    score += 2;
-  }
-  const hasGate = /gate|validate|dogfood|benchmark|circuit.?breaker/i.test(text);
-  criteria.push({ label: "Validation gate defined", met: hasGate, weight: 2 });
-  if (hasGate) {
-    satisfied.push("Validation gate defined");
-    score += 2;
-  } else {
-    missing.push("How will you know if this bet is working before full commitment?");
-  }
-  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
-}
-function scoreElements(ctx) {
-  const text = ctx.dimensionTexts.elements;
-  const missing = [];
-  const satisfied = [];
-  const criteria = [];
-  let score = 0;
-  const headingCount = (text.match(/###\s*Element\s*\d/gi) ?? []).length;
-  const inlineCount = (text.match(/element\s*\d|component\s*\d|piece\s*\d/gi) ?? []).length;
-  const ordinalCount = (text.match(/\b(first|second|third|fourth|fifth)\b[,:]?\s/gi) ?? []).length;
-  const numberedCount = (text.match(/^\s*\d+[.)]\s/gm) ?? []).length;
-  const namedCount = (text.match(/\belement\s+\d|[A-Z][a-z]+ (?:Engine|Store|Gate|Manager|Service|Module|Handler|Layer|Registry|Pipeline)\b/g) ?? []).length;
-  const textDescribed = Math.max(headingCount, inlineCount, ordinalCount, numberedCount, namedCount);
-  let elemMet = true;
-  let elemWeight = 0;
-  if (ctx.elementCount >= 3) {
-    satisfied.push(`${ctx.elementCount} elements captured on Chain`);
-    elemWeight = 5;
-    score += 5;
-  } else if (ctx.elementCount > 0) {
-    satisfied.push(`${ctx.elementCount} element(s) captured`);
-    elemWeight = ctx.elementCount * 2;
-    score += ctx.elementCount * 2;
-    if (ctx.elementCount < 3) {
-      missing.push(`Identify ${3 - ctx.elementCount} more solution elements for adequate decomposition.`);
-    }
-  } else if (textDescribed >= 3) {
-    satisfied.push(`${textDescribed} elements described in text`);
-    elemWeight = 4;
-    score += 4;
-    missing.push("Capture these elements as typed entries on the Chain.");
-  } else if (textDescribed > 0) {
-    satisfied.push(`${textDescribed} element(s) described in text`);
-    elemWeight = textDescribed * 2;
-    score += textDescribed * 2;
-    missing.push("Identify more solution elements \u2014 aim for 3+ independently describable pieces.");
-  } else {
-    elemMet = false;
-    elemWeight = 5;
-    missing.push("Identify solution elements \u2014 breadboard-level pieces, each independently describable.");
-  }
-  criteria.push({ label: "Solution elements identified", met: elemMet, weight: elemWeight });
-  const totalElements = Math.max(ctx.elementCount, textDescribed);
-  const decompMet = totalElements >= 2;
-  let decompWeight;
-  if (totalElements >= 3) {
-    satisfied.push("Multiple independently describable pieces");
-    decompWeight = 3;
-    score += 3;
-  } else if (totalElements >= 2) {
-    satisfied.push("Multiple independently describable pieces");
-    decompWeight = 2;
-    score += 2;
-  } else {
-    decompWeight = 3;
-  }
-  criteria.push({ label: "Adequate decomposition (3+ pieces)", met: decompMet, weight: decompWeight });
-  const govMet = ctx.governanceCount > 0;
-  criteria.push({ label: "Governance constraints applied", met: govMet, weight: 1 });
-  if (govMet) {
-    satisfied.push(`${ctx.governanceCount} governance entries constrain the solution`);
-    score += 1;
-  }
-  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
-}
-function scoreArchitecture(ctx) {
-  const text = ctx.dimensionTexts.architecture;
-  const missing = [];
-  const satisfied = [];
-  const criteria = [];
-  let score = 0;
-  const hasArchSection = ctx.hasArchitectureText;
-  criteria.push({ label: "Architecture section present", met: hasArchSection, weight: 3 });
-  if (hasArchSection) {
-    satisfied.push("Architecture section present in bet");
-    score += 3;
-  } else {
-    missing.push("Where does this live in the architecture? Name each layer and what belongs where.");
-  }
-  const archSignals = countMatches(text, ARCHITECTURE_SIGNALS);
-  const archVocabMet = archSignals > 0;
-  const archVocabWeight = archSignals >= 3 ? 2 : archSignals > 0 ? 1 : 2;
-  criteria.push({ label: "Architecture vocabulary used", met: archVocabMet, weight: archVocabWeight });
-  if (archSignals >= 3) {
-    satisfied.push("Architecture vocabulary used");
-    score += 2;
-  } else if (archSignals > 0) {
-    score += 1;
-  } else {
-    missing.push("Describe the API boundary, modules, and services involved.");
-  }
-  const hasDependencyDir = countMatches(text, ARCH_QUALITY_SIGNALS) > 0;
-  criteria.push({ label: "Dependency direction specified", met: hasDependencyDir, weight: 2 });
-  if (hasDependencyDir) {
-    satisfied.push("Dependency direction / boundaries specified");
-    score += 2;
-  } else {
-    missing.push("What dependencies does this create or remove? Specify direction.");
-  }
-  const hasDiagram = /mermaid|diagram|flowchart|graph/i.test(text);
-  criteria.push({ label: "Visual architecture diagram", met: hasDiagram, weight: 2 });
-  if (hasDiagram) {
-    satisfied.push("Visual architecture representation");
-    score += 2;
-  } else {
-    missing.push("Add an architecture diagram (Mermaid) showing layers and data flow.");
-  }
-  const govMet = ctx.governanceCount > 0;
-  criteria.push({ label: "Checked against governance", met: govMet, weight: 1 });
-  if (govMet) {
-    satisfied.push("Architecture checked against governance");
-    score += 1;
-  }
-  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
-}
-function scoreRisks(ctx) {
-  const text = ctx.dimensionTexts.risks;
-  const missing = [];
-  const satisfied = [];
-  const criteria = [];
-  let score = 0;
-  const riskSignalCount = countMatches(text, RISK_SIGNALS);
-  const textRiskCount = (text.match(/rabbit hole|risk:|risk \d|R\d:/gi) ?? []).length;
-  const totalRisks = Math.max(ctx.riskCount, textRiskCount, Math.min(riskSignalCount, 3));
-  let riskMet = true;
-  let riskWeight = 0;
-  if (ctx.riskCount >= 2) {
-    satisfied.push(`${ctx.riskCount} risks captured on Chain`);
-    riskWeight = 4;
-    score += 4;
-  } else if (totalRisks >= 2) {
-    satisfied.push(`${totalRisks} risks identified`);
-    riskWeight = 3;
-    score += 3;
-    if (ctx.riskCount === 0) missing.push("Capture identified risks as entries on the Chain.");
-  } else if (totalRisks > 0 || riskSignalCount > 0) {
-    satisfied.push("Risk language present");
-    riskWeight = 2;
-    score += 2;
-    missing.push("Identify more risks \u2014 aim for 2+ rabbit holes with mitigations.");
-  } else {
-    riskMet = false;
-    riskWeight = 4;
-    missing.push("Name the rabbit holes \u2014 what could go wrong, what's unknown?");
-  }
-  criteria.push({ label: "Risks identified", met: riskMet, weight: riskWeight });
-  const mitigationCount = countMatches(text, MITIGATION_SIGNALS);
-  let mitigMet = mitigationCount > 0;
-  let mitigWeight;
-  if (mitigationCount >= 2) {
-    satisfied.push("Multiple mitigations specified");
-    mitigWeight = 3;
-    score += 3;
-  } else if (mitigationCount > 0) {
-    satisfied.push("Mitigation present");
-    mitigWeight = 2;
-    score += 2;
-    missing.push("Each risk should have a mitigation or explicit acceptance.");
-  } else {
-    mitigMet = false;
-    mitigWeight = 3;
-    missing.push("Each risk needs a mitigation or explicit acceptance.");
-  }
-  criteria.push({ label: "Mitigations specified", met: mitigMet, weight: mitigWeight });
-  const hasCodebaseRisks = /codebase|architecture|coupling|dependency|schema|migration/i.test(text);
-  criteria.push({ label: "Codebase-level risks identified", met: hasCodebaseRisks, weight: 2 });
-  if (hasCodebaseRisks) {
-    satisfied.push("Codebase-level risks identified");
-    score += 2;
-  } else {
-    missing.push("Are there high-risk areas in the codebase? Check architecture and dependencies.");
-  }
-  const thorough = totalRisks >= 3;
-  criteria.push({ label: "Thorough risk coverage", met: thorough, weight: 1 });
-  if (thorough) {
-    satisfied.push("Thorough risk coverage");
-    score += 1;
-  }
-  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
-}
-function scoreBoundaries(ctx) {
-  const text = ctx.dimensionTexts.boundaries;
-  const missing = [];
-  const satisfied = [];
-  const criteria = [];
-  let score = 0;
-  const textNoGos = Math.max(countMatches(text, NOGO_SIGNALS), (text.match(/\bwon'?t\b|\bwill not\b/gi) ?? []).length);
-  const totalNoGos = Math.max(ctx.noGoCount, textNoGos);
-  let nogoMet = totalNoGos > 0;
-  let nogoWeight;
-  if (totalNoGos >= 3) {
-    satisfied.push(`${totalNoGos} explicit no-gos declared`);
-    nogoWeight = 5;
-    score += 5;
-  } else if (totalNoGos > 0) {
-    satisfied.push(`${totalNoGos} no-go(s) declared`);
-    nogoWeight = totalNoGos * 2;
-    score += totalNoGos * 2;
-    missing.push("Add more explicit no-gos to prevent scope creep.");
-  } else {
-    nogoMet = false;
-    nogoWeight = 5;
-    missing.push("Declare what you're NOT building \u2014 explicit no-gos prevent scope creep.");
-  }
-  criteria.push({ label: "No-gos declared", met: nogoMet, weight: nogoWeight });
-  const hasScopeCreep = /scope creep|prevent|boundary|limit|constrain|excluded/i.test(text);
-  criteria.push({ label: "Scope creep prevention language", met: hasScopeCreep, weight: 2 });
-  if (hasScopeCreep) {
-    satisfied.push("Scope creep prevention language");
-    score += 2;
-  }
-  const hasDirectional = /direction|instead.*will|rather.*than|not.*but/i.test(text);
-  criteria.push({ label: "Directional no-gos", met: hasDirectional, weight: 2 });
-  if (hasDirectional) {
-    satisfied.push("Each no-go prevents scope creep in a specific direction");
-    score += 2;
-  } else if (totalNoGos > 0) {
-    missing.push("Each no-go should prevent scope creep in a specific direction.");
-  }
-  const comprehensive = totalNoGos >= 5;
-  criteria.push({ label: "Comprehensive boundary specification", met: comprehensive, weight: 1 });
-  if (comprehensive) {
-    satisfied.push("Comprehensive boundary specification");
-    score += 1;
-  }
-  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
-}
-function scoreDoneWhen(ctx) {
-  const text = ctx.dimensionTexts.done_when ?? "";
-  const missing = [];
-  const satisfied = [];
-  const criteria = [];
-  let score = 0;
-  const hasSection = text.trim().length > 0;
-  criteria.push({ label: "Done-when section present", met: hasSection, weight: 3 });
-  if (hasSection) {
-    satisfied.push("Done-when section present");
-    score += 3;
-  } else {
-    missing.push("Define explicit done-when criteria.");
-  }
-  const hasMeasurableTargets = /\b\d+%|\bp\d{2}|\b>=?\s*\d+|\b<=?\s*\d+|target|threshold|SLO|SLA|median/i.test(text);
-  criteria.push({ label: "Measurable targets defined", met: hasMeasurableTargets, weight: 3 });
-  if (hasMeasurableTargets) {
-    satisfied.push("Measurable targets defined");
-    score += 3;
-  } else if (hasSection) {
-    missing.push("Add measurable targets (thresholds, percentages, latency targets, or numeric criteria).");
-  }
-  const hasValidationPlan = /\btest|verify|validation|contract test|rollback|drill|gate/i.test(text);
-  criteria.push({ label: "Validation plan specified", met: hasValidationPlan, weight: 2 });
-  if (hasValidationPlan) {
-    satisfied.push("Validation plan specified");
-    score += 2;
-  } else if (hasSection) {
-    missing.push("Specify how success will be validated (tests, gates, rollback drills).");
-  }
-  const hasSignals = countMatches(text, DONE_WHEN_SIGNALS) >= 3;
-  criteria.push({ label: "Operational signal coverage", met: hasSignals, weight: 2 });
-  if (hasSignals) {
-    satisfied.push("Operational signal coverage");
-    score += 2;
-  } else if (hasSection) {
-    missing.push("Include operational signals (metrics, gates, and release thresholds).");
-  }
-  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
-}
-var SCORERS = {
-  problem_clarity: scoreProblemClarity,
-  appetite: scoreAppetite,
-  elements: scoreElements,
-  architecture: scoreArchitecture,
-  risks: scoreRisks,
-  boundaries: scoreBoundaries,
-  done_when: scoreDoneWhen
-};
-function scoreDimension(dimension, ctx) {
-  const raw = SCORERS[dimension](ctx);
-  if (ctx.source === "agent_proposal") {
-    return {
-      ...raw,
-      score: clamp(Math.round(raw.score * AGENT_DISCOUNT_FACTOR), 0, 10)
-    };
-  }
-  return raw;
-}
-function scoreAll(ctx) {
-  const results = {};
-  for (const dim of DIMENSIONS) {
-    results[dim] = scoreDimension(dim, ctx);
-  }
-  return results;
-}
-function buildScorecard(ctx) {
-  const results = scoreAll(ctx);
-  return {
-    problem_clarity: results.problem_clarity.score,
-    appetite: results.appetite.score,
-    elements: results.elements.score,
-    architecture: results.architecture.score,
-    risks: results.risks.score,
-    boundaries: results.boundaries.score,
-    done_when: results.done_when.score
-  };
-}
-function buildDetailedScorecard(ctx, opts) {
-  const results = scoreAll(ctx);
-  const scorecard = {};
-  const criteria = {};
-  for (const dim of DIMENSIONS) {
-    scorecard[dim] = results[dim].score;
-    criteria[dim] = results[dim].criteria;
-  }
-  if (opts?.isSmallBatch) scorecard.architecture = -1;
-  return { scorecard, criteria };
-}
-function isCaptureReady(scorecard, isSmallBatch) {
-  const completed = completedDimensions(scorecard, 6, isSmallBatch);
-  const dims = activeDimensions(isSmallBatch);
-  const ready = completed.length >= (isSmallBatch ? 5 : 6) && dims.every((d) => scorecard[d] >= 4);
-  return { ready, completed };
-}
-function inferActiveDimension(scorecard, isSmallBatch = false) {
-  const order = activeDimensions(isSmallBatch);
-  const firstZero = order.find((d) => scorecard[d] === 0);
-  if (firstZero) return firstZero;
-  const firstWeak = order.find((d) => scorecard[d] < 6);
-  if (firstWeak) return firstWeak;
-  return order[order.length - 1];
-}
-function completedDimensions(scorecard, threshold = 6, isSmallBatch = false) {
-  return activeDimensions(isSmallBatch).filter((d) => scorecard[d] >= threshold);
-}
-function suggestCaptures(ctx, activeDimension) {
-  const suggestions = [];
-  const text = ctx.dimensionTexts[activeDimension];
-  if (text.length < 30) return suggestions;
-  if (activeDimension === "problem_clarity" || activeDimension === "appetite") {
-    if (countMatches(text, WORKAROUND_SIGNALS) > 0 && ctx.riskCount === 0) {
-      const match = text.match(/(?:workaround|currently|today|right now)[^.]{0,120}\./i);
-      if (match && isBalanced(match[0])) {
-        suggestions.push({
-          type: "tension",
-          name: extractPhrase(match[0], 60),
-          reason: "Workaround described \u2014 captures the pain point as a trackable tension",
-          confidence: 0.7
-        });
-      }
-    }
-  }
-  if (activeDimension === "elements") {
-    if (ctx.elementCount === 0 && /(?:service|component|module|layer|store|engine|kernel)/i.test(text)) {
-      const match = text.match(/(?:a |the )?(\w[\w\s]{2,30}(?:service|component|module|layer|store|engine|kernel))/i);
-      if (match && isBalanced(match[1])) {
-        suggestions.push({
-          type: "element",
-          name: capitalize(match[1].trim()),
-          reason: "Solution component identified \u2014 capture as a feature entry",
-          confidence: 0.8
-        });
-      }
-    }
-  }
-  if (activeDimension === "risks") {
-    if (ctx.riskCount === 0 && countMatches(text, RISK_SIGNALS) >= 2) {
-      const match = text.match(/(?:risk|rabbit hole|unknown|might|could fail)[^.]{0,120}\./i);
-      if (match && isBalanced(match[0])) {
-        suggestions.push({
-          type: "risk",
-          name: extractPhrase(match[0], 60),
-          reason: "Risk language detected \u2014 capture as a tension with mitigation",
-          confidence: 0.7
-        });
-      }
-    }
-  }
-  if (/(?:we(?:'ll| will) (?:use|go with|pick|choose)|decided to|decision:|instead of)/i.test(text)) {
-    const match = text.match(/(?:we(?:'ll| will) (?:use|go with|pick|choose)|decided to|decision:)[^.]{0,120}\./i);
-    if (match && isBalanced(match[0])) {
-      suggestions.push({
-        type: "decision",
-        name: extractPhrase(match[0], 60),
-        reason: "Decision language detected \u2014 capture rationale while it's fresh",
-        confidence: 0.6
-      });
-    }
-  }
-  return suggestions.slice(0, 3);
-}
-function extractPhrase(text, maxLen) {
-  const cleaned = text.replace(/^(?:the |a |an )/i, "").trim();
-  return cleaned.length > maxLen ? cleaned.slice(0, maxLen - 3) + "..." : cleaned;
-}
-function capitalize(s) {
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}
-function isBalanced(text) {
-  const opens = (text.match(/[("']/g) ?? []).length;
-  const closes = (text.match(/[)"']/g) ?? []).length;
-  return Math.abs(opens - closes) <= 1;
-}
-var PHASE_INVESTIGATIONS = {
-  context: (searchTerm) => ({
-    phase: "context",
-    dimension: "problem_clarity",
-    tasks: [
-      { target: "chain", query: `Search for entries related to: ${searchTerm}`, purpose: "Find existing tensions, decisions, and bets that overlap" },
-      { target: "chain", query: "List active governance: principles, standards, business-rules", purpose: "Surface constraints the solution must honor" },
-      { target: "codebase", query: `Search for code related to: ${searchTerm}`, purpose: "Understand current implementation and pain points" }
-    ],
-    proposalGuidance: "Synthesize findings into a 3-5 line context brief: what the Chain knows, what the codebase reveals, what governance applies.",
-    reactionPrompt: "Here's what I found. Does this match what you're seeing, or is the problem different from what the Chain suggests?"
-  }),
-  framing: (searchTerm) => ({
-    phase: "framing",
-    dimension: "problem_clarity",
-    tasks: [
-      { target: "codebase", query: `Find workarounds, TODOs, or hacks related to: ${searchTerm}`, purpose: "Surface concrete evidence of the problem" },
-      { target: "chain", query: `Search for tensions related to: ${searchTerm}`, purpose: "Quantify how often this problem occurs" }
-    ],
-    proposalGuidance: "Propose a problem statement based on codebase evidence. Include who's affected and what the workaround looks like in the code.",
-    reactionPrompt: "Based on the codebase, here's a draft problem statement. Does this capture it, or is the real problem different?"
-  }),
-  elements: (searchTerm, _betEntryId, elementNames) => ({
-    phase: "elements",
-    dimension: "elements",
-    tasks: [
-      { target: "codebase", query: `Find modules, services, and components that would be affected by: ${searchTerm}`, purpose: "Map the solution to existing architecture" },
-      ...elementNames?.length ? [{ target: "codebase", query: `Locate existing code paths for these elements: ${elementNames.join(", ")}`, purpose: "Ground each proposed element in current implementation" }] : [],
-      { target: "architecture", query: "Identify layer boundaries, API contracts, and dependency directions", purpose: "Ground elements in real architecture" },
-      { target: "chain", query: "Check DEC-31, STA-3, and other architecture standards", purpose: "Ensure elements respect existing decisions" }
-    ],
-    proposalGuidance: "Propose 3-5 solution elements at breadboard level. Each element should name the layer it lives in, what it does, and how it connects to existing code.",
-    reactionPrompt: "I've mapped out these solution elements based on the codebase. Which feel right? Which need adjustment?"
-  }),
-  derisking: (searchTerm, _betEntryId, elementNames) => ({
-    phase: "derisking",
-    dimension: "risks",
-    tasks: [
-      { target: "codebase", query: `Find fragile code, tight coupling, or missing tests near: ${searchTerm}`, purpose: "Surface technical risks from code" },
-      ...elementNames?.length ? [{ target: "codebase", query: `Check implementation complexity for: ${elementNames.join(", ")}`, purpose: "Assess element-specific risks" }] : [{ target: "codebase", query: "Check for performance-sensitive paths, database queries, and external dependencies", purpose: "Identify performance and reliability risks" }],
-      { target: "chain", query: "Search for related tensions and past decisions that constrain this solution", purpose: "Surface risks from existing constraints" }
-    ],
-    proposalGuidance: "Propose rabbit holes with severity and mitigations. Each risk should cite specific code or Chain evidence. Also propose no-gos \u2014 what should be explicitly excluded.",
-    reactionPrompt: "These are the risks I found in the codebase. Are these real concerns? What am I missing?"
-  }),
-  validation: () => null,
-  capture: () => null
-};
-function buildInvestigationBrief(phase, betName, betEntryId, betProblem, elementNames) {
-  const searchTerm = betProblem?.slice(0, 200) || betName;
-  const builder = PHASE_INVESTIGATIONS[phase];
-  return builder(searchTerm, betEntryId, elementNames);
-}
-function generateBuildContract(ctx) {
-  const lines = ["## Build Contract"];
-  const consult = [
-    ...ctx.governanceEntries.map((e) => `- \`${e.entryId}\` ${e.name} [${e.collection}]`),
-    ...ctx.relatedDecisions.map((e) => `- \`${e.entryId}\` ${e.name} [decision]`),
-    ...ctx.relatedTensions.map((e) => `- \`${e.entryId}\` ${e.name} [tension]`)
-  ];
-  if (consult.length > 0) {
-    lines.push("", "**Chain entries to consult before building:**");
-    lines.push(...consult);
-  } else {
-    lines.push("", "**Chain entries to consult:** Run `orient` to discover applicable rules.");
-  }
-  lines.push(
-    "",
-    "**Capture obligations during build:**",
-    "- New glossary terms that emerge from implementation",
-    "- Implementation decisions not covered in shaping",
-    "- Bugs or tensions discovered during build",
-    "- Any deviation from the shaped solution (capture as decision with rationale)",
-    "",
-    "**Post-build Chain update:**",
-    `- Update \`${ctx.betEntryId}\` with actual outcome vs. shaped intent`,
-    "- Commit any draft entries created during the build",
-    "- Capture a retrospective if the build deviated significantly"
-  );
-  return lines.join("\n");
-}
-
-// src/tools/facilitate-validation.ts
-function computeCommitBlockers(opts) {
-  const { betEntryId, betDocId, relations, hasStrategyLink, betData, sessionDrafts } = opts;
-  const blockers = [];
-  const links = betData.links ?? {};
-  const str = (key) => (links[key] ?? "").trim();
-  if (!hasStrategyLink) {
-    blockers.push({
-      entryId: betEntryId,
-      blocker: "Missing strategy link",
-      fix: `relations action=create from=${betEntryId} to=<strategy> type=related_to`
-    });
-  }
-  const MIN_FIELD_LENGTH = 20;
-  if (str("problem").length < MIN_FIELD_LENGTH) {
-    blockers.push({
-      entryId: betEntryId,
-      blocker: str("problem") ? "Problem statement too short (< 20 chars)" : "Missing problem statement",
-      fix: `update-entry entryId="${betEntryId}" data.problem="<problem description>"`
-    });
-  }
-  if (!str("appetite")) {
-    blockers.push({
-      entryId: betEntryId,
-      blocker: "Missing appetite",
-      fix: `update-entry entryId="${betEntryId}" data.appetite="<appetite declaration>"`
-    });
-  }
-  if (str("elements").length < MIN_FIELD_LENGTH) {
-    blockers.push({
-      entryId: betEntryId,
-      blocker: str("elements") ? "Solution elements too short (< 20 chars)" : "Missing solution elements",
-      fix: `facilitate action=respond betEntryId="${betEntryId}" dimension="elements"`
-    });
-  }
-  const hasFeatures = sessionDrafts.some((d) => d.collection === "features");
-  if (!hasFeatures && str("elements").length >= MIN_FIELD_LENGTH) {
-    blockers.push({
-      entryId: betEntryId,
-      blocker: "Elements described but no feature entries linked in constellation",
-      fix: `facilitate action=respond betEntryId="${betEntryId}" capture={type:"element", name:"...", description:"..."}`
-    });
-  }
-  for (const draft of sessionDrafts) {
-    if (!draft.name || draft.name.trim().length === 0) {
-      const draftRef = draft.entryId && draft.entryId.trim().length > 0 ? draft.entryId : "<draftId>";
-      blockers.push({
-        entryId: betEntryId,
-        blocker: `Draft constellation entry is missing a name`,
-        fix: `update-entry entryId="${draftRef}" name="<name>"`
-      });
-    }
-  }
-  return blockers;
-}
-
-// src/tools/facilitate-format.ts
-function formatCriteriaLine(criteria) {
-  return criteria.map((c) => `${c.met ? "\u2713" : "\u25CB"} ${c.label} (${c.weight}pt)`).join(" \xB7 ");
-}
-function appendElement(existing, element) {
-  const existingCount = (existing?.match(/###\s*Element\s*\d/gi) ?? []).length;
-  const num = existingCount + 1;
-  const id = element.entryId ? ` (${element.entryId})` : "";
-  const newBlock = `### Element ${num}: ${element.name}${id}
-
-${element.description}`;
-  return existing ? `${existing}
-
-${newBlock}` : newBlock;
-}
-function appendRabbitHole(existing, risk) {
-  const existingCount = (existing?.match(/###\s*RH\d/gi) ?? []).length;
-  const num = existingCount + 1;
-  const theme = risk.theme ? ` (${risk.theme})` : "";
-  const status = risk.status ? ` \u2014 ${risk.status}` : "";
-  const id = risk.entryId ? ` [${risk.entryId}]` : "";
-  const newBlock = `### RH${num}: ${risk.name}${theme}${status}${id}
-
-${risk.description}`;
-  return existing ? `${existing}
-
-${newBlock}` : newBlock;
-}
-function appendNoGo(existing, item) {
-  const line = `- **${item.title}.** ${item.explanation}`;
-  return existing ? `${existing}
-${line}` : line;
-}
-
-// src/tools/facilitate.ts
-var FACILITATE_ACTIONS = ["start", "respond", "score", "resume", "commit-constellation"];
-var captureItemSchema = z12.object({
-  type: z12.enum(["element", "risk", "noGo", "decision"]).describe("What to capture"),
-  name: z12.string().describe("Entry name"),
-  description: z12.string().describe("Entry description"),
-  theme: z12.string().optional().describe("Risk theme (for risk type)")
-});
+var FACILITATE_ACTIONS = ["resume", "commit-constellation"];
 var facilitateSchema = z12.object({
   action: z12.enum(FACILITATE_ACTIONS).describe(
-    "'start': begin shaping session context (entry created on first respond). 'respond': process user input, score, capture, return coaching. 'score': return current scorecard without advancing. 'resume': reconstruct session from existing bet entry. 'commit-constellation': atomically commit a bet and all its linked draft entries in one call. Requires betEntryId."
+    "'resume': load session state from an existing bet entry. 'commit-constellation': atomically commit a bet and all its linked draft entries in one call. Requires betEntryId."
   ),
-  sessionType: z12.enum(["shape"]).default("shape").optional().describe("Session type. Only 'shape' in v1."),
-  betEntryId: z12.string().optional().describe("Bet entry ID. Required for resume/score. For respond: omit on first call after start (entry created automatically); required for subsequent calls."),
-  operationId: z12.string().optional().describe("Optional idempotency key for commit-constellation retries."),
-  userInput: z12.string().optional().describe("User's input text for respond action."),
-  dimension: z12.string().optional().describe("Explicit dimension to score against (e.g. 'problem_clarity'). If omitted, inferred from scorecard."),
-  betName: z12.string().optional().describe("Name for the bet (used in start action)."),
-  source: z12.enum(["user", "agent_proposal", "user_reaction"]).default("user").optional().describe("ENT-59: Source of the input text. 'user' = typed by user (default, full score weight). 'agent_proposal' = agent-generated proposal (discounted score). 'user_reaction' = user reacting to agent proposal (full weight)."),
-  capture: z12.union([
-    captureItemSchema,
-    z12.array(captureItemSchema).max(15)
-  ]).optional().describe("Entry or entries to capture alongside the respond action. Accepts a single object or an array (max 15) for batch capture.")
+  betEntryId: z12.string().optional().describe("Bet entry ID. Required for both actions."),
+  operationId: z12.string().optional().describe("Optional idempotency key for commit-constellation retries.")
 });
-async function hasStrategyLinkForEntry(entryDocId, relations) {
-  const relatedDocIds = /* @__PURE__ */ new Set();
-  for (const rel of relations) {
-    if (rel.fromId === entryDocId && rel.toId) relatedDocIds.add(rel.toId);
-    if (rel.toId === entryDocId && rel.fromId) relatedDocIds.add(rel.fromId);
-  }
-  for (const docId of relatedDocIds) {
-    try {
-      const related = await mcpQuery("chain.getEntry", { id: docId });
-      if (related?.collectionSlug === "strategy") return true;
-    } catch {
-    }
-  }
-  return false;
-}
-function registerFacilitateTools(server) {
-  server.registerTool(
-    "facilitate",
-    {
-      title: "Facilitate \u2014 Coached Shaping",
-      description: "Server-controlled coached shaping session with real-time Chain capture.\n\n- **start**: Begin a coached session context only. No bet entry is created yet.\n- **first respond**: Call respond with `betName` to create the draft bet and capture initial problem context.\n- **respond**: Process user input \u2014 scores against 7 shaping rubrics (problem, appetite, elements, architecture, risks, boundaries, done-when), searches for overlap, captures to Chain, returns structured coaching response with phase tracking.\n- **score**: Return the current scorecard without advancing the session.\n- **resume**: Reconstruct session state from an existing bet entry on the Chain.\n- **commit-constellation**: Atomically commit a bet and all its linked draft entries (features, tensions, decisions) in one call. Validates strategy link and required fields before committing anything. Replaces 9-13 sequential commit-entry calls.\n\nThe structured response separates judgment (server) from coaching (agent) per DEC-56. Read the phase, scorecard, and coaching fields to determine what to say next. When captureReady is true, buildContract is auto-generated from Chain governance.",
-      inputSchema: facilitateSchema,
-      annotations: {
-        readOnlyHint: false,
-        destructiveHint: false,
-        idempotentHint: false,
-        openWorldHint: false
-      }
-    },
-    withEnvelope(async (args) => {
-      const parsed = facilitateSchema.safeParse(args);
-      if (!parsed.success) {
-        const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-        return validationResult(`Invalid arguments: ${issues}`);
-      }
-      const { action } = parsed.data;
-      return runWithToolContext({ tool: "facilitate", action }, async () => {
-        switch (action) {
-          case "start":
-            return handleStart2(parsed.data);
-          case "respond":
-            return handleRespond(parsed.data);
-          case "score":
-            return handleScore(parsed.data);
-          case "resume":
-            return handleResume(parsed.data);
-          case "commit-constellation":
-            return handleCommitConstellation(parsed.data);
-          default:
-            return validationResult(`Unknown action '${action}'. Valid: ${FACILITATE_ACTIONS.join(", ")}.`);
-        }
-      });
-    })
-  );
-}
 function buildStudioUrl(workspaceSlug, entryId) {
   const appUrl = process.env.PRODUCTBRAIN_APP_URL ?? "https://productbrain.io";
   return `${appUrl}/${workspaceSlug}/studio/entries/${entryId}`;
 }
-function buildDirective(scorecard, phase, betEntryId, captureReady, activeDimension, nextDimension) {
-  const b = betEntryId;
-  if (scorecard.problem_clarity >= 6 && scorecard.appetite === 0) {
-    return [
-      `Present this to the user exactly as formatted:`,
-      ``,
-      `**Appetite** \u2014 How much time is this idea worth? (Not how long it takes \u2014 how much you're willing to invest.)`,
-      `1. **Small Batch** \u2014 1-2 weeks, focused scope`,
-      `2. **Big Batch** \u2014 6 weeks, full treatment`,
-      ``,
-      `Wait for their answer. Then call \`facilitate action=respond betEntryId="${b}" dimension="appetite"\` with their choice.`
-    ].join("\n");
-  }
-  if (scorecard.problem_clarity >= 6 && scorecard.appetite >= 6 && scorecard.elements === 0) {
-    return [
-      `Synthesize the problem and appetite back to the user in 2-3 lines, then present:`,
-      ``,
-      `**Frame Go** \u2014 The problem is framed and appetite is set.`,
-      `1. **Go** \u2014 move to solution elements`,
-      `2. **Refine** \u2014 something's not right, let's adjust`,
-      ``,
-      `If Go: **investigate first** \u2014 use the investigationBrief in the structured response to search the codebase and Chain.`,
-      `Spawn sub-agents to explore the codebase for affected modules, existing architecture, and related patterns.`,
-      `Then propose 3-5 solution elements grounded in what you found.`,
-      `Present proposals for user reaction: "Based on the codebase, here are the elements I'd suggest. Which feel right?"`,
-      `For each confirmed element, call \`facilitate action=respond betEntryId="${b}" dimension="elements" source="user_reaction"\` with the user's reaction.`,
-      `If Refine: ask what needs adjusting, then call respond with dimension="problem_clarity" or "appetite".`
-    ].join("\n");
-  }
-  if (phase === "derisking" && scorecard.elements >= 6 && scorecard.risks >= 4 && scorecard.boundaries >= 4) {
-    return [
-      `Synthesize the shape so far in 3-4 lines, then present:`,
-      ``,
-      `**Shape Go** \u2014 Elements defined, risks covered.`,
-      `1. **Go** \u2014 validate and capture the pitch`,
-      `2. **Refine** \u2014 there's more to cover`,
-      ``,
-      `If Go: call \`facilitate action=score betEntryId="${b}"\` and present the full scorecard.`,
-      `If Refine: ask what needs work, continue with respond.`
-    ].join("\n");
-  }
-  if (captureReady) {
-    return [
-      `Present the full scorecard, then:`,
-      ``,
-      `**Ready to commit?**`,
-      `1. **Commit** \u2014 publish to the Chain as source of truth`,
-      `2. **Review** \u2014 show the full pitch first`,
-      `3. **Keep as draft** \u2014 not ready yet`,
-      ``,
-      `If Commit: call \`facilitate action=commit-constellation betEntryId="${b}"\` to publish the bet and all linked entries in one call.`,
-      `If Review: call \`facilitate action=score betEntryId="${b}"\` for the detailed view.`,
-      `If Draft: acknowledge and end the session.`
-    ].join("\n");
-  }
-  if (nextDimension && nextDimension !== activeDimension) {
-    const nextLabel = DIMENSION_LABELS[nextDimension];
-    const investigationPhases = ["elements", "architecture", "risks", "boundaries"];
-    const shouldInvestigate = investigationPhases.includes(nextDimension);
-    if (shouldInvestigate) {
-      return [
-        `Briefly synthesize what was just covered (2 lines max), then move to **${nextLabel}**.`,
-        `**Investigate first:** Use the investigationBrief to search the codebase and Chain before asking the user.`,
-        `Spawn sub-agents to gather evidence, then propose findings for user reaction.`,
-        `After the user reacts, call \`facilitate action=respond betEntryId="${b}" dimension="${nextDimension}" source="user_reaction"\` with their reaction.`,
-        `If the user provides their own input instead, call with source="user".`
-      ].join("\n");
-    }
-    return [
-      `Briefly synthesize what was just covered (2 lines max), then move to **${nextLabel}**.`,
-      `Ask ONE open question about ${nextLabel.toLowerCase()}. Keep it to 3 lines.`,
-      `After the user answers, call \`facilitate action=respond betEntryId="${b}" dimension="${nextDimension}"\` with their input.`
-    ].join("\n");
-  }
-  return null;
-}
-function emptyScorecard() {
-  return { problem_clarity: 0, appetite: 0, elements: 0, architecture: 0, risks: 0, boundaries: 0, done_when: 0 };
-}
-function detectSmallBatch(appetiteText) {
-  if (!appetiteText) return false;
-  return /small\s*batch|1[-–]2\s*week|2[-–]week|one.?week|two.?week/i.test(appetiteText);
-}
-function buildCachedScoringContext(betData, constellation) {
-  const cachedOverlapIds = typeof betData._overlapIds === "string" ? betData._overlapIds.split(",").filter((id) => id && id !== "_checked") : [];
-  const cachedGovCount = typeof betData._governanceCount === "number" ? betData._governanceCount : 0;
-  const syntheticChainSurfaced = Array.from({ length: cachedGovCount }, () => ({ collection: "principles" }));
-  return buildScoringContext("", betData, constellation, cachedOverlapIds, syntheticChainSurfaced);
-}
-function extractContentEvidence(ctx) {
-  return {
-    elementCount: ctx.elementCount,
-    riskCount: ctx.riskCount,
-    noGoCount: ctx.noGoCount,
-    hasArchitectureText: ctx.hasArchitectureText
-  };
-}
-function emptyResponse(betEntryId, studioUrl) {
-  return {
-    version: 2,
-    phase: "context",
-    phaseLabel: PHASE_LABELS.context,
-    scorecard: emptyScorecard(),
-    overlap: [],
-    alignment: [],
-    chainSurfaced: [],
-    suggestedCaptures: [],
-    sessionDrafts: [],
-    coaching: {
-      observation: "New shaping session started",
-      missing: ["Problem statement", "Appetite", "Solution elements", "Architecture", "Risks", "Boundaries", "Done-when criteria"],
-      pushback: "",
-      suggestedQuestion: "Describe the problem you want to solve. Who's affected? What's the workaround today?",
-      captureReady: false,
-      nextDimension: "problem_clarity"
-    },
-    captured: {
-      betEntryId,
-      studioUrl,
-      entriesCreated: [],
-      relationsCreated: 0
-    },
-    captureErrors: [],
-    navigation: {
-      completedDimensions: [],
-      activeDimension: "problem_clarity",
-      suggestedOrder: [...SUGGESTED_ORDER]
-    }
-  };
-}
 async function loadBetEntry(entryId) {
   try {
     return await mcpQuery("chain.getEntry", { entryId });
@@ -6288,801 +5151,39 @@ async function loadSessionDrafts(betEntryId, betInternalId) {
     return [];
   }
 }
-function buildScoringContext(userInput, betData, constellation, overlapIds, chainResults = [], activeDimension, source = "user") {
-  const links = betData.links ?? {};
-  const str = (key) => links[key] ?? "";
-  const accParts = [
-    str("problem"),
-    str("appetite"),
-    str("elements"),
-    str("architecture"),
-    str("rabbitHoles"),
-    str("noGos"),
-    str("done_when"),
-    str("doneWhen"),
-    str("solution"),
-    userInput
-  ];
-  const noGoText = str("noGos");
-  const noGoCount = (noGoText.match(/^- \*\*/gm) ?? []).length;
-  const elementsText = str("elements");
-  const elementHeaderCount = (elementsText.match(/###\s*Element\s*\d/gi) ?? []).length;
-  const governanceCollections = /* @__PURE__ */ new Set(["principles", "standards", "business-rules"]);
-  const governanceCount = chainResults.filter((e) => governanceCollections.has(e.collection)).length;
-  const hasArchitectureText = str("architecture").length > 20;
-  const join2 = (...parts) => parts.filter(Boolean).join("\n\n");
-  const inputFor = (dim) => activeDimension === dim ? userInput : "";
-  const dimensionTexts = {
-    problem_clarity: join2(str("problem"), inputFor("problem_clarity")),
-    appetite: join2(str("appetite"), inputFor("appetite")),
-    elements: join2(str("elements"), str("solution"), inputFor("elements")),
-    architecture: join2(str("architecture"), inputFor("architecture")),
-    risks: join2(str("rabbitHoles"), inputFor("risks")),
-    boundaries: join2(str("noGos"), inputFor("boundaries")),
-    done_when: join2(str("done_when"), str("doneWhen"), inputFor("done_when"))
-  };
-  return {
-    userInput,
-    accumulatedText: accParts.filter(Boolean).join("\n\n"),
-    dimensionTexts,
-    existingEntryIds: overlapIds,
-    elementCount: Math.max(constellation.elementCount, elementHeaderCount),
-    riskCount: constellation.riskCount,
-    noGoCount,
-    governanceCount,
-    decisionCount: constellation.decisionCount,
-    hasArchitectureText,
-    source
-  };
-}
-async function searchChain(text, opts = {}) {
-  const { maxResults = 8, excludeIds = [] } = opts;
-  if (text.length < 10) return [];
-  const query = text.slice(0, 300);
-  try {
-    const results = await mcpQuery(
-      "chain.searchEntries",
-      { query }
-    );
-    const excluded = new Set(excludeIds);
-    return (results ?? []).filter((e) => e.entryId && !excluded.has(e.entryId)).slice(0, maxResults).map((e) => ({
-      entryId: e.entryId,
-      name: e.name,
-      collection: e.collectionSlug ?? "unknown"
-    }));
-  } catch {
-    return [];
-  }
-}
-async function findAndLinkExisting(name, collectionSlug, betEntryId, relationType, agentSessionId) {
-  try {
-    const results = await mcpQuery(
-      "chain.searchEntries",
-      { query: name }
-    );
-    const match = (results ?? []).find(
-      (r) => r.entryId && r.name.toLowerCase() === name.toLowerCase() && (r.collectionSlug === collectionSlug || !r.collectionSlug)
-    );
-    if (!match?.entryId) return null;
-    try {
-      await mcpMutation("chain.createEntryRelation", {
-        fromEntryId: match.entryId,
-        toEntryId: betEntryId,
-        type: relationType,
-        sessionId: agentSessionId ?? void 0
-      });
-      return { entryId: match.entryId, linked: true };
-    } catch {
-      return { entryId: match.entryId, linked: false };
-    }
-  } catch {
-    return null;
-  }
-}
-async function handleStart2(args) {
-  requireWriteAccess();
-  const betName = args.betName ?? "Untitled Bet (Shaping)";
-  let orientContext = "";
-  try {
-    const orient = await mcpQuery("chain.getOrientEntries", {});
-    const sc = orient?.strategicContext;
-    const parts = [];
-    if (sc?.vision) parts.push(`Vision: ${sc.vision}`);
-    if (sc?.purpose) parts.push(`Purpose: ${sc.purpose}`);
-    if (sc?.activeBetCount) parts.push(`${sc.activeBetCount} active bet(s)`);
-    if (sc?.activeTensionCount) parts.push(`${sc.activeTensionCount} open tension(s)`);
-    if (orient?.activeBets?.length) {
-      parts.push("Active bets: " + orient.activeBets.map((b) => `${b.entryId ?? "?"} ${b.name}`).join(", "));
-    }
-    orientContext = parts.join(". ");
-  } catch {
-    orientContext = "Could not load workspace context.";
-  }
-  const investigationBrief = buildInvestigationBrief("context", betName, "pending");
-  const response = emptyResponse("pending", "");
-  if (investigationBrief) {
-    response.investigationBrief = investigationBrief;
-  }
-  const output = [
-    `# Shaping Session Started`,
-    "",
-    `**Bet:** ${betName} (draft entry will be created when you describe the problem)`,
-    `**Phase:** ${PHASE_LABELS.context}`,
-    "",
-    orientContext ? `**Workspace context:** ${orientContext}` : "",
-    "",
-    "No entry created yet \u2014 the bet will be saved to the Chain once you describe the problem.",
-    "",
-    "---",
-    "## Agent Directive",
-    "**Investigate first** \u2014 before asking the user, use the investigationBrief to search the codebase and Chain for context related to this bet.",
-    "Spawn sub-agents: one `explore` agent to search the codebase, one `generalPurpose` agent to search the Chain.",
-    "Synthesize findings into a 3-5 line context brief, then present to the user.",
-    "After presenting context, ask: **What's not working well? Describe the problem \u2014 who's affected, and what's the workaround today?**",
-    "Keep your message to 5 lines or fewer. Heavy context degrades the shaping experience.",
-    `After the user responds, call \`facilitate action=respond betName="${betName}" dimension="problem_clarity"\` with their answer as userInput.`,
-    `Note: pass betName (not betEntryId) \u2014 the entry will be created on the first respond call.`
-  ].filter(Boolean).join("\n");
-  return {
-    content: [{ type: "text", text: output }],
-    structuredContent: success(
-      `Shaping session started for "${betName}". Phase: context.`,
-      response,
-      [{ tool: "facilitate", description: "Describe the problem", parameters: { action: "respond", betName, dimension: "problem_clarity" } }]
-    )
-  };
-}
-async function processCaptures(opts) {
-  const { captureItems, betEntryId, betDocId, betData } = opts;
-  const captureErrors = [];
-  const entriesCreated = [];
-  let relationsCreated = 0;
-  const capAgentId = getAgentSessionId();
-  const CAPTURE_DEFAULTS = {
-    features: { dataField: "description", relationType: "part_of" },
-    tensions: { dataField: "description", relationType: "constrains" },
-    decisions: { dataField: "rationale", relationType: "informs" }
-  };
-  const FALLBACK_DEFAULTS = { dataField: "description", relationType: "related_to" };
-  let runningBetData = { ...betData };
-  const runningLinks = () => ({ ...runningBetData.links ?? {} });
-  for (const item of captureItems) {
-    if (item.type === "noGo") {
-      const curLinks = runningLinks();
-      const updatedNoGos = appendNoGo(
-        curLinks.noGos,
-        { title: item.name, explanation: item.description }
-      );
-      const newLinks = { ...curLinks, noGos: updatedNoGos };
-      runningBetData.links = newLinks;
-      try {
-        await mcpMutation("chain.updateEntry", {
-          entryId: betEntryId,
-          data: { links: newLinks },
-          changeNote: `Added no-go: ${item.name}`
-        });
-        await recordSessionActivity({ entryModified: betDocId });
-      } catch (updErr) {
-        captureErrors.push({
-          operation: "update",
-          detail: `noGos field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
-        });
+function registerFacilitateTools(server) {
+  server.registerTool(
+    "facilitate",
+    {
+      title: "Facilitate \u2014 Session Resume & Constellation Commit",
+      description: "Session state loading and atomic constellation commit for shaped bets.\n\n- **resume**: Load session state (bet data, constellation, drafts) from an existing bet entry.\n- **commit-constellation**: Atomically commit a bet and all its linked draft entries (features, tensions, decisions) in one call. Validates strategy link and required fields before committing anything. Replaces sequential commit-entry calls.\n\nScoring, coaching, and the facilitation loop are handled by the agent-side shaping skill.",
+      inputSchema: facilitateSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
       }
-      continue;
-    }
-    const resolved = await resolveCollection({
-      name: item.name,
-      description: item.description,
-      typeHint: item.type
-    });
-    if (!resolved) {
-      captureErrors.push({
-        operation: "classify",
-        detail: `Could not resolve collection for ${item.type} "${item.name}" \u2014 skipped.`
-      });
-      continue;
-    }
-    const { dataField, relationType } = CAPTURE_DEFAULTS[resolved.collection] ?? FALLBACK_DEFAULTS;
-    let capturedEntryId = null;
-    try {
-      const result = await mcpMutation(
-        "chain.createEntry",
-        {
-          collectionSlug: resolved.collection,
-          name: item.name,
-          status: "draft",
-          data: { [dataField]: item.description },
-          createdBy: capAgentId ? `agent:${capAgentId}` : "facilitate",
-          sessionId: capAgentId ?? void 0
-        }
-      );
-      capturedEntryId = result.entryId;
-      entriesCreated.push(result.entryId);
-    } catch (createErr) {
-      const msg = createErr instanceof Error ? createErr.message : String(createErr);
-      if (msg.includes("Duplicate entry") || msg.includes("already exists")) {
-        const fallback = await findAndLinkExisting(
-          item.name,
-          resolved.collection,
-          betEntryId,
-          relationType,
-          capAgentId
-        );
-        if (fallback) {
-          capturedEntryId = fallback.entryId;
-          entriesCreated.push(fallback.entryId);
-          if (fallback.linked) relationsCreated++;
-          captureErrors.push({
-            operation: "info",
-            detail: `Linked existing ${resolved.collection} entry \`${fallback.entryId}\` instead of creating duplicate.`
-          });
-        } else {
-          captureErrors.push({ operation: "capture", detail: `${item.type}: ${msg}` });
-        }
-      } else {
-        captureErrors.push({ operation: "capture", detail: `${item.type}: ${msg}` });
+    },
+    withEnvelope(async (args) => {
+      const parsed = facilitateSchema.safeParse(args);
+      if (!parsed.success) {
+        const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+        return validationResult(`Invalid arguments: ${issues}`);
       }
-    }
-    if (!capturedEntryId) continue;
-    try {
-      await mcpMutation("chain.createEntryRelation", {
-        fromEntryId: capturedEntryId,
-        toEntryId: betEntryId,
-        type: relationType,
-        sessionId: capAgentId ?? void 0
+      const { action } = parsed.data;
+      return runWithToolContext({ tool: "facilitate", action }, async () => {
+        switch (action) {
+          case "resume":
+            return handleResume(parsed.data);
+          case "commit-constellation":
+            return handleCommitConstellation(parsed.data);
+          default:
+            return validationResult(`Unknown action '${action}'. Valid: ${FACILITATE_ACTIONS.join(", ")}.`);
+        }
       });
-      relationsCreated++;
-    } catch (relErr) {
-      const msg = relErr instanceof Error ? relErr.message : String(relErr);
-      if (!msg.includes("already exists") && !msg.includes("Duplicate")) {
-        captureErrors.push({
-          operation: "relation",
-          detail: `${relationType} from ${capturedEntryId} to ${betEntryId}: ${msg}`
-        });
-      }
-    }
-    if (item.type === "element") {
-      const curLinks = runningLinks();
-      const updatedElements = appendElement(
-        curLinks.elements,
-        { name: item.name, description: item.description, entryId: capturedEntryId }
-      );
-      const newLinks = { ...curLinks, elements: updatedElements };
-      runningBetData.links = newLinks;
-      try {
-        await mcpMutation("chain.updateEntry", {
-          entryId: betEntryId,
-          data: { links: newLinks },
-          changeNote: `Added element: ${item.name}`
-        });
-        await recordSessionActivity({ entryModified: betDocId });
-      } catch (updErr) {
-        captureErrors.push({
-          operation: "update",
-          detail: `elements field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
-        });
-      }
-    } else if (item.type === "risk") {
-      const curLinks = runningLinks();
-      const updatedRisks = appendRabbitHole(
-        curLinks.rabbitHoles,
-        { name: item.name, description: item.description, theme: item.theme, entryId: capturedEntryId }
-      );
-      const newLinks = { ...curLinks, rabbitHoles: updatedRisks };
-      runningBetData.links = newLinks;
-      try {
-        await mcpMutation("chain.updateEntry", {
-          entryId: betEntryId,
-          data: { links: newLinks },
-          changeNote: `Added risk: ${item.name}`
-        });
-        await recordSessionActivity({ entryModified: betDocId });
-      } catch (updErr) {
-        captureErrors.push({
-          operation: "update",
-          detail: `rabbitHoles field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
-        });
-      }
-    }
-  }
-  return { entriesCreated, relationsCreated, captureErrors };
-}
-async function computeAndUpdateScores(opts) {
-  const {
-    betEntryId,
-    betDocId,
-    betData,
-    betEntry,
-    userInput,
-    argDimension,
-    source,
-    captureItems,
-    chainSurfaced,
-    constellation
-  } = opts;
-  const captureErrors = [];
-  const refreshedBet = await loadBetEntry(betEntryId);
-  const refreshedData = refreshedBet?.data ?? betData;
-  const refreshedConstellation = captureItems.length > 0 ? await loadConstellationState(betEntryId, refreshedBet?._id ?? betEntry._id) : constellation;
-  const sessionDrafts = await loadSessionDrafts(betEntryId, refreshedBet?._id ?? betEntry._id);
-  const constellationEntryIds = sessionDrafts.map((d) => d.entryId);
-  const alreadyCheckedOverlap = typeof refreshedData._overlapIds === "string";
-  let overlap = [];
-  if (!alreadyCheckedOverlap && captureItems.length === 0) {
-    const refreshedLinks = refreshedData.links ?? {};
-    const problemText = refreshedLinks.problem ?? userInput;
-    const overlapResults = await searchChain(problemText, { maxResults: 5, excludeIds: [betEntryId, ...constellationEntryIds] });
-    overlap = overlapResults.map((r) => ({
-      entryId: r.entryId,
-      similarity: "text_match",
-      summary: `${r.name} [${r.collection}]`
-    }));
-  }
-  const overlapIds = overlap.map((o) => o.entryId);
-  const refreshedLinksForAppetite = refreshedData.links ?? {};
-  const appetiteText = refreshedLinksForAppetite.appetite ?? "";
-  const isSmallBatch = detectSmallBatch(
-    argDimension === "appetite" ? userInput : appetiteText
-  );
-  let activeDimension;
-  if (argDimension && DIMENSIONS.includes(argDimension)) {
-    activeDimension = argDimension;
-  } else {
-    const prelim = buildScoringContext(userInput, refreshedData, refreshedConstellation, overlapIds, chainSurfaced, void 0, source);
-    activeDimension = inferActiveDimension(buildScorecard(prelim), isSmallBatch);
-  }
-  const scoringCtx = buildScoringContext(
-    userInput,
-    refreshedData,
-    refreshedConstellation,
-    overlapIds,
-    chainSurfaced,
-    activeDimension,
-    source
+    })
   );
-  const dimensionResult = scoreDimension(activeDimension, scoringCtx);
-  const { scorecard, criteria: scorecardCriteria } = buildDetailedScorecard(scoringCtx, { isSmallBatch });
-  const nextDimension = inferActiveDimension(scorecard, isSmallBatch);
-  const phase = inferPhase(scorecard, isSmallBatch, extractContentEvidence(scoringCtx));
-  try {
-    const fieldUpdates = {};
-    const linksUpdates = {};
-    const currentLinks = refreshedData.links ?? {};
-    const persist = (dim, field, minLen) => {
-      if (activeDimension === dim && !currentLinks[field] && userInput.length > minLen) {
-        linksUpdates[field] = userInput;
-      }
-    };
-    persist("problem_clarity", "problem", 50);
-    persist("appetite", "appetite", 20);
-    persist("architecture", "architecture", 50);
-    persist("done_when", "doneWhen", 30);
-    if (Object.keys(linksUpdates).length > 0) {
-      fieldUpdates.links = { ...currentLinks, ...linksUpdates };
-    }
-    if (!refreshedData._overlapIds) {
-      fieldUpdates._overlapIds = overlapIds.length > 0 ? overlapIds.join(",") : "_checked";
-    }
-    const govCount = chainSurfaced.filter(
-      (e) => ["principles", "standards", "business-rules"].includes(e.collection)
-    ).length;
-    if (govCount > 0) {
-      fieldUpdates._governanceCount = govCount;
-    }
-    if (Object.keys(fieldUpdates).length > 0) {
-      await mcpMutation("chain.updateEntry", {
-        entryId: betEntryId,
-        data: fieldUpdates,
-        changeNote: `Updated ${Object.keys(fieldUpdates).join(", ")} from shaping session`
-      });
-      await recordSessionActivity({ entryModified: refreshedBet?._id ?? betEntry._id });
-    }
-  } catch (updErr) {
-    captureErrors.push({
-      operation: "update",
-      detail: `bet fields: ${updErr instanceof Error ? updErr.message : String(updErr)}`
-    });
-  }
-  const alignment = [];
-  const governanceCollections = /* @__PURE__ */ new Set(["principles", "standards", "business-rules", "strategy", "chains"]);
-  for (const result of chainSurfaced) {
-    if (governanceCollections.has(result.collection)) {
-      alignment.push({ entryId: result.entryId, relationship: `governs [${result.collection}]` });
-    }
-  }
-  const { ready: captureReady, completed } = isCaptureReady(scorecard, isSmallBatch);
-  const observation = dimensionResult.satisfied.length > 0 ? `${DIMENSION_LABELS[activeDimension]}: ${dimensionResult.satisfied.join("; ")}` : `${DIMENSION_LABELS[activeDimension]}: needs more detail`;
-  const pushback = captureItems.length === 0 && overlap.length > 0 ? `${overlap[0].summary} already exists on the Chain. How does your bet differ?` : dimensionResult.missing.length > 0 ? dimensionResult.missing[0] : "";
-  const suggestedQuestion = dimensionResult.missing.length > 1 ? dimensionResult.missing[1] : dimensionResult.missing.length > 0 ? dimensionResult.missing[0] : `${DIMENSION_LABELS[nextDimension]} is next \u2014 ready to move on?`;
-  let buildContract;
-  if (captureReady) {
-    const contractCtx = {
-      betEntryId,
-      governanceEntries: chainSurfaced.filter((e) => ["principles", "standards", "business-rules"].includes(e.collection)).map((e) => ({ entryId: e.entryId, name: e.name, collection: e.collection })),
-      relatedDecisions: chainSurfaced.filter((e) => e.collection === "decisions").map((e) => ({ entryId: e.entryId, name: e.name })),
-      relatedTensions: chainSurfaced.filter((e) => e.collection === "tensions").map((e) => ({ entryId: e.entryId, name: e.name }))
-    };
-    buildContract = generateBuildContract(contractCtx);
-    const currentBCLinks = refreshedData.links ?? {};
-    if (currentBCLinks.buildContract !== buildContract) {
-      try {
-        const bcLinks = { ...refreshedData.links ?? {}, buildContract };
-        await mcpMutation("chain.updateEntry", {
-          entryId: betEntryId,
-          data: { links: bcLinks },
-          changeNote: "Updated build contract from shaping session"
-        });
-        await recordSessionActivity({ entryModified: refreshedBet?._id ?? betEntry._id });
-      } catch (updErr) {
-        captureErrors.push({
-          operation: "update",
-          detail: `buildContract field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
-        });
-      }
-    }
-  }
-  let commitBlockers;
-  if (captureReady) {
-    const hasStrategyLink = await hasStrategyLinkForEntry(
-      refreshedBet?._id ?? betEntry._id,
-      refreshedConstellation.relations
-    );
-    commitBlockers = computeCommitBlockers({
-      betEntryId,
-      betDocId: refreshedBet?._id ?? betEntry._id,
-      relations: refreshedConstellation.relations,
-      hasStrategyLink,
-      betData: refreshedData,
-      sessionDrafts
-    });
-    if (commitBlockers.length === 0) commitBlockers = void 0;
-  }
-  return {
-    scorecard,
-    scorecardCriteria,
-    phase,
-    activeDimension,
-    nextDimension,
-    dimensionResult,
-    overlap,
-    sessionDrafts,
-    alignment,
-    coaching: { observation, pushback, suggestedQuestion, captureReady },
-    completed,
-    isSmallBatch,
-    refreshedData,
-    scoringCtx,
-    captureErrors,
-    buildContract,
-    commitBlockers
-  };
-}
-function assembleResponse(opts) {
-  const {
-    betEntryId,
-    betName,
-    workspaceSlug,
-    scorecard,
-    scorecardCriteria,
-    phase,
-    activeDimension,
-    nextDimension,
-    dimensionResult,
-    coaching,
-    overlap,
-    sessionDrafts,
-    alignment,
-    chainSurfaced,
-    scoringCtx,
-    isSmallBatch,
-    completed,
-    refreshedData,
-    buildContract,
-    commitBlockers,
-    entriesCreated,
-    relationsCreated,
-    captureErrors,
-    captureItems
-  } = opts;
-  const studioUrl = buildStudioUrl(workspaceSlug, betEntryId);
-  const suggested = suggestCaptures(scoringCtx, activeDimension);
-  const assembleLinks = refreshedData.links ?? {};
-  const betProblem = assembleLinks.problem ?? "";
-  const responseBetName = refreshedData.description ?? betName;
-  const elementNames = (assembleLinks.elements ?? "").match(/###\s*Element\s*\d+:\s*(.+)/gi)?.map((h) => h.replace(/###\s*Element\s*\d+:\s*/i, "").trim()) ?? [];
-  const investigationBrief = buildInvestigationBrief(phase, responseBetName, betEntryId, betProblem, elementNames) ?? void 0;
-  const response = {
-    version: 2,
-    phase,
-    phaseLabel: PHASE_LABELS[phase],
-    scorecard,
-    overlap,
-    alignment,
-    chainSurfaced: chainSurfaced.map((r) => ({ entryId: r.entryId, relevance: r.name, collection: r.collection })),
-    suggestedCaptures: suggested,
-    sessionDrafts,
-    coaching: {
-      observation: coaching.observation,
-      missing: dimensionResult.missing,
-      pushback: coaching.pushback,
-      suggestedQuestion: coaching.suggestedQuestion,
-      captureReady: coaching.captureReady,
-      nextDimension
-    },
-    captured: {
-      betEntryId,
-      studioUrl,
-      entriesCreated,
-      relationsCreated
-    },
-    captureErrors,
-    navigation: {
-      completedDimensions: completed,
-      activeDimension,
-      suggestedOrder: activeDimensions(isSmallBatch)
-    },
-    buildContract,
-    directive: buildDirective(scorecard, phase, betEntryId, coaching.captureReady, activeDimension, nextDimension) || void 0,
-    investigationBrief,
-    commitBlockers,
-    scorecardCriteria
-  };
-  const STRUCTURED_DIMS = {
-    elements: "element",
-    risks: "risk",
-    boundaries: "noGo"
-  };
-  const expectedCaptureType = STRUCTURED_DIMS[activeDimension];
-  const dataLossWarning = expectedCaptureType && captureItems.length === 0 ? `**WARNING:** You discussed ${activeDimension} but did not use the \`capture\` parameter \u2014 nothing was saved to the bet. Re-send with \`capture={type:"${expectedCaptureType}", name:"...", description:"..."}\` to persist this.` : "";
-  const summaryParts = [
-    `# ${PHASE_LABELS[phase]} \u2014 ${DIMENSION_LABELS[activeDimension]}`,
-    "",
-    dataLossWarning,
-    `**Score:** ${DIMENSION_LABELS[activeDimension]}: ${scorecard[activeDimension]}/10 \u2014 ${formatCriteriaLine(dimensionResult.criteria)}`,
-    `**Phase:** ${PHASE_LABELS[phase]}`,
-    coaching.observation,
-    coaching.pushback ? `**Pushback:** ${coaching.pushback}` : "",
-    `**Next:** ${coaching.suggestedQuestion}`,
-    coaching.captureReady ? "\n**Capture ready** \u2014 the bet has enough shape to finalize." : "",
-    commitBlockers?.length ? `
-\u26A0 **Commit blockers (${commitBlockers.length}):** ${commitBlockers.map((b) => `${b.blocker} \u2192 \`${b.fix}\``).join("; ")}` : "",
-    entriesCreated.length > 0 ? `**Captured:** ${entriesCreated.join(", ")}` : "",
-    suggested.length > 0 ? `**Suggest capturing:** ${suggested.map((s) => `${s.type}: "${s.name}"`).join("; ")}` : "",
-    sessionDrafts.length > 0 ? `**Session drafts (${sessionDrafts.length}):** ${sessionDrafts.map((d) => `\`${d.entryId}\` ${d.name}`).join(", ")}` : "",
-    captureErrors.length > 0 ? `**Warnings:** ${captureErrors.map((e) => e.detail).join("; ")}` : ""
-  ];
-  const summaryText = `${PHASE_LABELS[phase]} \u2014 ${DIMENSION_LABELS[activeDimension]}: ${scorecard[activeDimension]}/10.${coaching.captureReady ? " Capture ready." : ""}`;
-  return {
-    content: [{ type: "text", text: summaryParts.filter(Boolean).join("\n") }],
-    structuredContent: success(
-      summaryText,
-      response,
-      [{ tool: "facilitate", description: "Continue shaping", parameters: { action: "respond", betEntryId, dimension: nextDimension } }]
-    )
-  };
-}
-async function handleRespond(args) {
-  requireWriteAccess();
-  const { userInput, betEntryId: argBetId, dimension: argDimension, capture: rawCapture, source: argSource, betName: argBetName } = args;
-  const source = argSource ?? "user";
-  const captureItems = rawCapture ? Array.isArray(rawCapture) ? rawCapture : [rawCapture] : [];
-  if (!userInput) {
-    return validationResult("`userInput` is required for respond action.");
-  }
-  let betId = argBetId;
-  if (!betId) {
-    const betName = argBetName ?? "Untitled Bet (Shaping)";
-    const agentId = getAgentSessionId();
-    try {
-      const result = await mcpMutation(
-        "chain.createEntry",
-        {
-          collectionSlug: "chains",
-          name: betName,
-          status: "draft",
-          data: {
-            chainTypeId: "bet",
-            description: `Shaping session for: ${betName}`,
-            status: "shaping",
-            shapingSessionActive: true,
-            links: {
-              problem: userInput,
-              appetite: "",
-              elements: "",
-              rabbitHoles: "",
-              noGos: "",
-              architecture: "",
-              buildContract: ""
-            }
-          },
-          createdBy: agentId ? `agent:${agentId}` : "facilitate",
-          sessionId: agentId ?? void 0
-        }
-      );
-      betId = result.entryId;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return {
-        content: [{ type: "text", text: `Failed to create bet entry: ${msg}` }],
-        structuredContent: failure("BACKEND_ERROR", `Failed to create bet entry: ${msg}`, "Check workspace access and try again.")
-      };
-    }
-  }
-  const [betEntry, constellation, chainSurfaced] = await Promise.all([
-    loadBetEntry(betId),
-    loadConstellationState(betId),
-    searchChain(userInput, { maxResults: 8 })
-  ]);
-  if (!betEntry) {
-    return {
-      content: [{ type: "text", text: `Bet \`${betId}\` not found. Use start to create a session.` }],
-      structuredContent: failure(
-        "NOT_FOUND",
-        `Bet '${betId}' not found.`,
-        "Use facilitate action=start to begin a new session.",
-        [{ tool: "facilitate", description: "Start session", parameters: { action: "start" } }]
-      )
-    };
-  }
-  const betData = betEntry.data ?? {};
-  let entriesCreated = [];
-  let relationsCreated = 0;
-  const captureErrors = [];
-  if (captureItems.length > 0) {
-    const capResult = await processCaptures({
-      captureItems,
-      betEntryId: betId,
-      betDocId: betEntry._id,
-      betData
-    });
-    entriesCreated = capResult.entriesCreated;
-    relationsCreated = capResult.relationsCreated;
-    captureErrors.push(...capResult.captureErrors);
-  }
-  const scoreResult = await computeAndUpdateScores({
-    betEntryId: betId,
-    betDocId: betEntry._id,
-    betData,
-    betEntry,
-    userInput,
-    argDimension,
-    source,
-    captureItems,
-    chainSurfaced,
-    constellation
-  });
-  captureErrors.push(...scoreResult.captureErrors);
-  const wsCtx = await getWorkspaceContext();
-  return assembleResponse({
-    betEntryId: betId,
-    betName: betEntry.name,
-    workspaceSlug: wsCtx.workspaceSlug,
-    scorecard: scoreResult.scorecard,
-    scorecardCriteria: scoreResult.scorecardCriteria,
-    phase: scoreResult.phase,
-    activeDimension: scoreResult.activeDimension,
-    nextDimension: scoreResult.nextDimension,
-    dimensionResult: scoreResult.dimensionResult,
-    coaching: scoreResult.coaching,
-    overlap: scoreResult.overlap,
-    sessionDrafts: scoreResult.sessionDrafts,
-    alignment: scoreResult.alignment,
-    chainSurfaced,
-    scoringCtx: scoreResult.scoringCtx,
-    isSmallBatch: scoreResult.isSmallBatch,
-    completed: scoreResult.completed,
-    refreshedData: scoreResult.refreshedData,
-    buildContract: scoreResult.buildContract,
-    commitBlockers: scoreResult.commitBlockers,
-    entriesCreated,
-    relationsCreated,
-    captureErrors,
-    captureItems
-  });
-}
-async function handleScore(args) {
-  const betId = args.betEntryId;
-  if (!betId) {
-    return validationResult("`betEntryId` is required for score action.");
-  }
-  const betEntry = await loadBetEntry(betId);
-  if (!betEntry) {
-    return {
-      content: [{ type: "text", text: `Bet \`${betId}\` not found.` }],
-      structuredContent: failure(
-        "NOT_FOUND",
-        `Bet '${betId}' not found.`,
-        "Use facilitate action=start to begin a session.",
-        [{ tool: "facilitate", description: "Start session", parameters: { action: "start" } }]
-      )
-    };
-  }
-  const constellation = await loadConstellationState(betId, betEntry._id);
-  const betData = betEntry.data ?? {};
-  const scoreLinks = betData.links ?? {};
-  const isSmallBatch = detectSmallBatch(scoreLinks.appetite ?? "");
-  const scoringCtx = buildCachedScoringContext(betData, constellation);
-  const { scorecard, criteria: scorecardCriteria } = buildDetailedScorecard(scoringCtx, { isSmallBatch });
-  const dims = activeDimensions(isSmallBatch);
-  const { ready: captureReady, completed } = isCaptureReady(scorecard, isSmallBatch);
-  const active = inferActiveDimension(scorecard, isSmallBatch);
-  const phase = inferPhase(scorecard, isSmallBatch, extractContentEvidence(scoringCtx));
-  const lines = [
-    `# Scorecard \u2014 ${betEntry.name}`,
-    `**Phase:** ${PHASE_LABELS[phase]}`,
-    "",
-    "| Dimension | Score | Status |",
-    "|-----------|-------|--------|"
-  ];
-  for (const dim of dims) {
-    const label = DIMENSION_LABELS[dim];
-    const score = scorecard[dim];
-    const status = score >= 6 ? "done" : score > 0 ? "in progress" : "not started";
-    const marker = dim === active ? " **<-**" : "";
-    lines.push(`| ${label} | ${score}/10 | ${status}${marker} |`);
-  }
-  lines.push("");
-  lines.push("### Criteria Detail");
-  for (const dim of dims) {
-    const label = DIMENSION_LABELS[dim];
-    lines.push(`**${label} (${scorecard[dim]}/10):** ${formatCriteriaLine(scorecardCriteria[dim])}`);
-  }
-  lines.push("");
-  lines.push(`Completed: ${completed.length}/${dims.length}`);
-  lines.push(`Next dimension: ${DIMENSION_LABELS[active]}`);
-  const sessionDrafts = await loadSessionDrafts(betId, betEntry._id);
-  const constellationDrafts = sessionDrafts.filter((d) => d.collection !== "unknown");
-  if (sessionDrafts.length > 0) {
-    lines.push("");
-    lines.push(`**Session drafts (${sessionDrafts.length}):** ${sessionDrafts.map((d) => `\`${d.entryId}\` ${d.name}`).join(", ")}`);
-  }
-  const hasStrategyLink = await hasStrategyLinkForEntry(betEntry._id, constellation.relations);
-  const commitBlockers = computeCommitBlockers({
-    betEntryId: betId,
-    betDocId: betEntry._id,
-    relations: constellation.relations,
-    hasStrategyLink,
-    betData,
-    sessionDrafts
-  });
-  if (captureReady) {
-    lines.push("");
-    lines.push("**Capture ready** \u2014 the bet has enough shape to finalize.");
-    if (constellationDrafts.length > 0) {
-      lines.push("");
-      lines.push(`**Constellation entries to commit alongside the bet:**`);
-      for (const draft of constellationDrafts) {
-        lines.push(`- \`${draft.entryId}\` ${draft.name} [${draft.collection}]`);
-      }
-      lines.push("");
-      lines.push("When committing, also commit these constellation entries to keep the graph consistent.");
-    }
-  }
-  if (commitBlockers.length > 0) {
-    lines.push("");
-    lines.push(`\u26A0 **Commit blockers (${commitBlockers.length}):**`);
-    for (const b of commitBlockers) {
-      lines.push(`- ${b.blocker} \u2192 \`${b.fix}\``);
-    }
-  }
-  return {
-    content: [{ type: "text", text: lines.join("\n") }],
-    structuredContent: success(
-      `Scorecard for ${betEntry.name}: ${completed.length}/${dims.length} complete. Phase: ${PHASE_LABELS[phase]}.${captureReady ? " Capture ready." : ""}`,
-      {
-        scorecard,
-        phase,
-        phaseLabel: PHASE_LABELS[phase],
-        completedDimensions: completed,
-        nextDimension: active,
-        sessionDrafts,
-        captureReady,
-        constellationDrafts,
-        commitBlockers: commitBlockers.length > 0 ? commitBlockers : void 0,
-        scorecardCriteria
-      }
-    )
-  };
 }
 async function handleResume(args) {
   const betId = args.betEntryId;
@@ -7096,100 +5197,47 @@ async function handleResume(args) {
       structuredContent: failure(
         "NOT_FOUND",
         `Bet '${betId}' not found.`,
-        "Use facilitate action=start to begin a new session.",
-        [{ tool: "facilitate", description: "Start session", parameters: { action: "start" } }]
+        "Use `capture` to create a bet entry, then resume."
       )
     };
   }
-  const constellation = await loadConstellationState(betId, betEntry._id);
-  const betData = betEntry.data ?? {};
-  const resumeLinks = betData.links ?? {};
-  const isSmallBatch = detectSmallBatch(resumeLinks.appetite ?? "");
-  const scoringCtx = buildCachedScoringContext(betData, constellation);
-  const { scorecard, criteria: scorecardCriteria } = buildDetailedScorecard(scoringCtx, { isSmallBatch });
-  const dims = activeDimensions(isSmallBatch);
-  const { ready: captureReady, completed } = isCaptureReady(scorecard, isSmallBatch);
-  const active = inferActiveDimension(scorecard, isSmallBatch);
-  const phase = inferPhase(scorecard, isSmallBatch, extractContentEvidence(scoringCtx));
-  const wsCtx = await getWorkspaceContext();
+  const [constellation, sessionDrafts, wsCtx] = await Promise.all([
+    loadConstellationState(betId, betEntry._id),
+    loadSessionDrafts(betId, betEntry._id),
+    getWorkspaceContext()
+  ]);
   const studioUrl = buildStudioUrl(wsCtx.workspaceSlug, betId);
+  const betData = betEntry.data ?? {};
   const constellationSummary = [];
   if (constellation.elementCount > 0) constellationSummary.push(`${constellation.elementCount} element(s)`);
   if (constellation.riskCount > 0) constellationSummary.push(`${constellation.riskCount} risk(s)`);
   if (constellation.decisionCount > 0) constellationSummary.push(`${constellation.decisionCount} decision(s)`);
-  const sessionDrafts = await loadSessionDrafts(betId, betEntry._id);
-  const response = {
-    version: 2,
-    phase,
-    phaseLabel: PHASE_LABELS[phase],
-    scorecard,
-    overlap: [],
-    alignment: [],
-    chainSurfaced: [],
-    suggestedCaptures: [],
-    sessionDrafts,
-    coaching: {
-      observation: `Resuming session for "${betEntry.name}". ${constellationSummary.length > 0 ? `Constellation: ${constellationSummary.join(", ")}.` : "No constellation entries yet."}`,
-      missing: dims.filter((d) => scorecard[d] < 6).map((d) => `${DIMENSION_LABELS[d]} needs work (${scorecard[d]}/10)`),
-      pushback: "",
-      suggestedQuestion: `Continue with ${DIMENSION_LABELS[active]}?`,
-      captureReady,
-      nextDimension: active
-    },
-    captured: {
-      betEntryId: betId,
-      studioUrl,
-      entriesCreated: [],
-      relationsCreated: 0
-    },
-    captureErrors: [],
-    navigation: {
-      completedDimensions: completed,
-      activeDimension: active,
-      suggestedOrder: dims
-    },
-    scorecardCriteria
-  };
-  const directive = buildDirective(scorecard, phase, betId, captureReady, active, active);
-  const scorecardLines = dims.map((dim) => {
-    const s = scorecard[dim];
-    const bar = s > 0 ? "\u2588".repeat(s) + "\u2591".repeat(10 - s) : "\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591";
-    const arrow = dim === active ? " \u25C0 next" : "";
-    return `| ${DIMENSION_LABELS[dim]} | ${bar} ${s}/10${arrow} |`;
-  });
-  const criteriaDetail = dims.map(
-    (dim) => `**${DIMENSION_LABELS[dim]} (${scorecard[dim]}/10):** ${formatCriteriaLine(scorecardCriteria[dim])}`
-  );
   const output = [
-    `# Session Resumed \u2014 ${betEntry.name}`,
+    `# Session State \u2014 ${betEntry.name}`,
     "",
     `**Bet:** \`${betId}\``,
     `**Studio:** ${studioUrl}`,
     `**Status:** ${betEntry.status}`,
-    `**Phase:** ${PHASE_LABELS[phase]}`,
     constellationSummary.length > 0 ? `**Constellation:** ${constellationSummary.join(", ")}` : "**Constellation:** Empty \u2014 no entries captured yet.",
-    sessionDrafts.length > 0 ? `**Session drafts (${sessionDrafts.length}):** ${sessionDrafts.map((d) => `\`${d.entryId}\` ${d.name}`).join(", ")}` : "",
-    "",
-    "## Scorecard",
-    "| Dimension | Score |",
-    "|---|---|",
-    ...scorecardLines,
-    "",
-    "### Criteria Detail",
-    ...criteriaDetail,
-    "",
-    `Continue with ${DIMENSION_LABELS[active]}?`,
-    directive ? `
----
-## Agent Directive
-${directive}` : ""
+    sessionDrafts.length > 0 ? `**Session drafts (${sessionDrafts.length}):** ${sessionDrafts.map((d) => `\`${d.entryId}\` ${d.name}`).join(", ")}` : ""
   ].filter(Boolean).join("\n");
   return {
     content: [{ type: "text", text: output }],
     structuredContent: success(
-      `Resumed session for "${betEntry.name}". Phase: ${PHASE_LABELS[phase]}. Next: ${DIMENSION_LABELS[active]}.`,
-      response,
-      [{ tool: "facilitate", description: `Continue with ${DIMENSION_LABELS[active]}`, parameters: { action: "respond", betEntryId: betId, dimension: active } }]
+      `Loaded session state for "${betEntry.name}".`,
+      {
+        betEntryId: betId,
+        betName: betEntry.name,
+        betStatus: betEntry.status,
+        betData,
+        studioUrl,
+        constellation: {
+          elementCount: constellation.elementCount,
+          riskCount: constellation.riskCount,
+          decisionCount: constellation.decisionCount
+        },
+        sessionDrafts
+      }
     )
   };
 }
@@ -7206,26 +5254,14 @@ async function handleCommitConstellation(args) {
       structuredContent: failure(
         "NOT_FOUND",
         `Bet '${betId}' not found.`,
-        "Use facilitate action=start to begin a session.",
-        [{ tool: "facilitate", description: "Start session", parameters: { action: "start" } }]
+        "Use 'capture' to create a bet entry first, then pass its ID here.",
+        [{ tool: "capture", description: "Create a bet entry", parameters: { name: "<bet name>", description: "<bet description>" } }]
       )
     };
   }
   const betData = betEntry.data ?? {};
   const operationId = args.operationId ?? `${betId}:${getAgentSessionId() ?? "sessionless"}:${betEntry.status}:${betEntry.currentVersion ?? 0}`;
-  const relations = await mcpQuery("chain.listEntryRelations", {
-    entryId: betId
-  });
-  const hasStrategyLink = await hasStrategyLinkForEntry(betEntry._id, relations);
-  const sessionDrafts = await loadSessionDrafts(betId, betEntry._id);
-  const commitBlockerItems = computeCommitBlockers({
-    betEntryId: betId,
-    betDocId: betEntry._id,
-    relations,
-    hasStrategyLink,
-    betData,
-    sessionDrafts
-  });
+  const { blockers: commitBlockerItems, totalRelations } = await mcpQuery("chain.validateCommitConstellation", { betEntryId: betId });
   if (commitBlockerItems.length > 0) {
     return {
       content: [{
@@ -7248,14 +5284,14 @@ async function handleCommitConstellation(args) {
           operationId,
           blockers: commitBlockerItems,
           committedIds: [],
-          totalRelations: relations.length
+          totalRelations
         }
       )
     };
   }
   let contradictionWarnings = [];
   try {
-    const { runContradictionCheck } = await import("./smart-capture-HSQTA5JW.js");
+    const { runContradictionCheck } = await import("./smart-capture-VFCEUDDW.js");
     const commitLinks = betData.links ?? {};
     const descField = commitLinks.problem ?? betData.description ?? "";
     contradictionWarnings = await runContradictionCheck(
@@ -7292,7 +5328,7 @@ No constellation entries were committed.`
         "BACKEND_ERROR",
         `Bet commit failed: ${msg}`,
         "Retry or check for commit blockers.",
-        [{ tool: "facilitate", description: "Check scorecard", parameters: { action: "score", betEntryId: betId } }]
+        [{ tool: "facilitate", description: "Resume session", parameters: { action: "resume", betEntryId: betId } }]
       )
     };
   }
@@ -8437,10 +6473,12 @@ Available presets: ${listPresets().map((p) => `\`${p.id}\``).join(", ")}`,
   const skipped = [];
   for (const col of preset.collections) {
     try {
+      const purpose = col.purpose ?? col.description;
       await mcpCall("chain.createCollection", {
         slug: col.slug,
         name: col.name,
         description: col.description,
+        purpose,
         icon: col.icon,
         idPrefix: col.idPrefix,
         fields: col.fields,
@@ -10376,6 +8414,7 @@ function formatScanReport(result) {
 
 // src/tools/orient.ts
 import { z as z20 } from "zod";
+var PURPOSE_GAP_PREFIX = "purpose-gap-";
 function extractSessionEntryIds(priorSessions) {
   const allSeen = /* @__PURE__ */ new Set();
   const all = [];
@@ -10531,6 +8570,10 @@ function registerOrientTool(server) {
           const oneLiner = formatGapOneLiner(briefGaps[0]);
           if (oneLiner) lines.push(oneLiner);
         }
+        const briefClassificationGaps = briefGaps.filter((g) => g.id?.startsWith?.(PURPOSE_GAP_PREFIX));
+        if (briefClassificationGaps.length > 0) {
+          lines.push(`${briefClassificationGaps.length} collection(s) with weak purpose \u2014 classification may be inaccurate.`);
+        }
         if (recoveryBlock) {
           lines.push("");
           lines.push(...formatRecoveryBlock(recoveryBlock));
@@ -10804,6 +8847,16 @@ function registerOrientTool(server) {
           lines.push("");
         }
       }
+      const classificationGaps = readiness?.gaps?.filter((g) => g.id?.startsWith?.(PURPOSE_GAP_PREFIX)) ?? [];
+      if (classificationGaps.length > 0) {
+        lines.push("## Classification gaps");
+        lines.push("_Collections with weak purpose \u2014 entry classification may be inaccurate._");
+        lines.push("");
+        for (const g of classificationGaps) {
+          lines.push(`- ${g.label ?? g.id?.replace?.("purpose-gap-", "") ?? "unknown"}`);
+        }
+        lines.push("");
+      }
       if (errors.length > 0) {
         lines.push("## Errors");
         for (const err of errors) lines.push(`- ${err}`);
@@ -11442,7 +9495,7 @@ Browse: \`entries action=list collection=tracking-events\`.`
     "## Knowledge Graph\nEntries are connected via typed relations (`entryRelations` table). Relations are bidirectional and collection-agnostic \u2014 any entry can link to any other entry.\n\n**Recommended relation types** (extensible \u2014 any string accepted):\n- `governs` \u2014 a rule constrains behavior of a feature\n- `defines_term_for` \u2014 a glossary term is canonical vocabulary for a feature/area\n- `belongs_to` \u2014 a feature belongs to a product area or parent concept\n- `informs` \u2014 a decision or insight informs a feature\n- `fills_slot` \u2014 an ingredient entry fills a slot in a map\n- `surfaces_tension_in` \u2014 a tension exists within a feature area\n- `related_to`, `depends_on`, `replaces`, `conflicts_with`, `references`, `confused_with`\n\nEach relation type is defined as a glossary entry (prefix `GT-REL-*`) to prevent terminology drift.\n\n**Tools:**\n- `context action=gather` \u2014 get the full context around any entry (multi-hop graph traversal)\n- `graph action=suggest` \u2014 discover potential connections for an entry\n- `relations action=create` \u2014 create a typed link between two entries\n- `graph action=find` \u2014 list direct relations for an entry\n\n**Convention:** When creating or updating entries in governed collections, always use `graph action=suggest` to discover and create relevant relations."
   );
   sections.push(
-    "## Creating Knowledge\n**Entries:** Use `capture` as the primary tool for creating new entries. It handles the full workflow in one call:\n1. Creates the entry with collection-aware defaults (auto-fills dates, infers domains, sets priority)\n2. Auto-links related entries from across the chain (up to 5 confident matches)\n3. Returns a quality scorecard (X/10) with actionable improvement suggestions\n\n**Smart profiles** exist for: `tensions`, `business-rules`, `glossary`, `decisions`, `features`, `audiences`, `strategy`, `standards`, `maps`, `chains`, `tracking-events`.\nAll other collections use the `ENT-{random}` fallback profile.\n\n**Processes:** Use `chain action=create` with a template (e.g., `strategy-coherence`, `idm-proposal`). Fill links with `chain action=edit`.\n\n**Maps:** Use `map action=create` with a template (e.g., `lean-canvas`). Fill slots with `map-slot action=add`. Commit with `map-version action=commit`.\nNote: committing a map version creates a snapshot but does NOT change the entry status. To activate: `update-entry entryId=MAP-xxx status=active autoPublish=true`.\nUse `map-suggest` to discover ingredients for empty slots.\n\n**Prompts** (invoke via MCP prompt protocol):\n- `name-check` \u2014 verify a name against glossary conventions\n- `draft-decision-record` \u2014 scaffold a decision entry\n- `review-against-rules` \u2014 check work against business rules for a domain\n- `draft-rule-from-context` \u2014 create a new business rule from context\n- `run-workflow` \u2014 run a structured ceremony (e.g., retrospective)\n\nUse `quality action=check` to score existing entries retroactively.\nUse `update-entry` for post-creation adjustments (status changes, field updates, deprecation)."
+    "## Creating Knowledge\n**Entries:** Use `capture` as the primary tool for creating new entries. It handles the full workflow in one call:\n1. Creates the entry with collection-aware defaults (auto-fills dates, infers domains, sets priority)\n2. Auto-links related entries from across the chain (up to 5 confident matches)\n3. Returns a quality scorecard (X/10) with actionable improvement suggestions\n\n**Smart profiles** exist for: `tensions`, `business-rules`, `glossary`, `decisions`, `features`, `audiences`, `strategy`, `standards`, `maps`, `chains`, `tracking-events`.\nAll other collections use the `ENT-{random}` fallback profile.\n\n**Processes:** Use `chain action=create` with a template (e.g., `strategy-coherence`, `idm-proposal`). Fill links with `chain action=edit`.\n\n**Maps:** Use `map action=create` with a template (e.g., `lean-canvas`). Fill slots with `map-slot action=add`. Commit with `map-version action=commit`.\nNote: committing a map version creates a snapshot but does NOT change the entry status. To activate: `update-entry entryId=MAP-xxx status=active autoPublish=true`.\nUse `map-suggest` to discover ingredients for empty slots.\n\n**Prompts** (invoke via MCP prompt protocol):\n- `name-check` \u2014 verify a name against glossary conventions\n- `draft-decision-record` \u2014 scaffold a decision entry\n- `review-against-rules` \u2014 check work against business rules for a domain\n- `draft-rule-from-context` \u2014 create a new business rule from context\n\nUse `quality action=check` to score existing entries retroactively.\nUse `update-entry` for post-creation adjustments (status changes, field updates, deprecation)."
   );
   sections.push(
     "## Where to Go Next\n- **Create entry** \u2192 `capture` tool (auto-links + quality score in one call)\n- **Full context** \u2192 `context action=gather` (by entry ID or task description)\n- **Discover links** \u2192 `graph action=suggest`\n- **Quality audit** \u2192 `quality action=check`\n- **Terminology** \u2192 `name-check` prompt or `productbrain://terminology` resource\n- **Schema details** \u2192 `productbrain://collections` resource or `collections action=list`\n- **Labels** \u2192 `productbrain://labels` resource or `labels` tool\n- **Any collection** \u2192 `productbrain://{slug}/entries` resource\n- **Log a decision** \u2192 `draft-decision-record` prompt\n- **Build a map** \u2192 `map action=create` + `map-slot action=add` + `map-version action=commit`\n- **Architecture map** \u2192 `architecture action=show` tool (layered system visualization)\n- **Explore a layer** \u2192 `architecture action=explore` tool (drill into Auth, Core, Features, etc.)\n- **Growth funnel** \u2192 `productbrain://growth-funnel` resource or `entries action=list collection=strategy status=draft`\n- **Audiences** \u2192 `productbrain://audiences/entries` resource or `entries action=list collection=audiences`\n- **Session identity** \u2192 `health action=whoami`\n- **Health check** \u2192 `health action=check`\n- **Debug MCP calls** \u2192 `health action=audit`"
@@ -11467,7 +9520,7 @@ var AGENT_CHEATSHEET = `# Product Brain \u2014 Agent Cheatsheet
 | \`quality\` | Score an entry | \`entryId\` |
 | \`session\` | Start / close agent session | \`action\` |
 | \`health\` | Check / audit / whoami | \`action\` |
-| \`facilitate\` | Shaping workflows | \`action\`: start, respond, status |
+| \`facilitate\` | Session resume & constellation commit | \`action\`: resume, commit-constellation |
 
 ## Collection Prefixes
 GLO (glossary), BR (business-rules), PRI (principles), STD (standards),
@@ -12191,11 +10244,8 @@ Use one of these IDs to run a workflow.`
       } catch {
         kbContext = "\n_Could not load chain context \u2014 proceed without it._";
       }
-      const isFacilitated = descriptor?.runtime.kind === "facilitated";
-      const roundsPlan = wf.rounds.map((r, index) => {
-        const isLastRound = index === wf.rounds.length - 1;
-        const checkpointLine = isFacilitated ? isLastRound ? `**Checkpoint**: After completing this round, persist with \`workflows action="checkpoint" workflowId="${wf.id}" roundId="${r.id}" summaryEntryId=<betEntryId>\` to finalize the durable run and link the bet.` : `**Checkpoint**: After completing this round via \`facilitate\`, also persist with \`workflows action="checkpoint" workflowId="${wf.id}" roundId="${r.id}"\`` : `**Checkpoint**: Immediately persist this round with \`workflows action="checkpoint" workflowId="${wf.id}" roundId="${r.id}"\``;
-        return `### Round ${r.num}: ${r.label}
+      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}
@@ -12204,13 +10254,13 @@ Use one of these IDs to run a workflow.`
 ` + (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})
-` + checkpointLine;
-      }).join("\n\n---\n\n");
+**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 is resolved at runtime.";
+      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",
@@ -12223,25 +10273,7 @@ Use it \u2014 don't make them repeat themselves.
       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"}
-` : `Primary output: ${outputDescription}
-Use the workflow guidance to capture the primary record directly rather than relying on final summary auto-capture.
-`;
-      const checkpointingBlock = isFacilitated ? `## Checkpointing & Resume (Facilitated Workflow)
-
-This workflow uses \`${descriptor?.runtime.primaryTool ?? "facilitate"}\` as its primary tool, with durable workflow runs for tracking and observability.
-1. Before starting, check for an existing run with \`workflows action="get-run" workflowId="${wf.id}"\`.
-2. The \`${descriptor?.runtime.primaryTool ?? "facilitate"}\` tool drives the session. Use it for scoring, coaching, capture, and constellation management.
-3. After completing EACH round via \`${descriptor?.runtime.primaryTool ?? "facilitate"}\`, also call \`workflows action="checkpoint" workflowId="${wf.id}" roundId="<round-id>" output=<round-output>\` to mirror progress to the durable run.
-4. On the final round, pass \`summaryEntryId=<betEntryId>\` to link the bet as the run's summary. Do NOT use \`isFinal: true\` \u2014 the run auto-completes when all rounds are checkpointed.
-5. If a checkpoint fails, continue the session \u2014 \`${descriptor?.runtime.primaryTool ?? "facilitate"}\` state is preserved independently.
-` : `## Checkpointing & Resume
-
-This workflow now supports durable workflow runs.
-1. Before starting, check for an existing run in the current session with \`workflows action="get-run" workflowId="${wf.id}"\`.
-2. If an active run exists, resume from its \`currentRoundId\` instead of restarting the workflow.
-3. After completing EACH round, immediately call \`workflows action="checkpoint" workflowId="${wf.id}" roundId="<round-id>" output=<round-output>\`.
-4. Only call \`isFinal: true\` from the terminal round when the workflow supports summary capture.
-5. If a checkpoint fails, say so explicitly and continue the conversation as backup.
+` : `${outputDescription}
 `;
       return {
         messages: [
@@ -12261,7 +10293,15 @@ ${wf.facilitatorPreamble}
 
 ---
 
-${checkpointingBlock}
+## 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
@@ -12278,7 +10318,7 @@ ${wf.errorRecovery}
 
 ## Chain Output
 
-` + chainOutputBlock + kbContext + `
+${chainOutputBlock}` + kbContext + `
 
 ---
 
@@ -12289,167 +10329,6 @@ ${wf.errorRecovery}
       };
     }
   );
-  server.prompt(
-    "shape-a-bet",
-    "Launch a coached shaping session powered by the facilitate tool. Dynamically loads workspace context, governance constraints, and coaching rubrics. Use when the user wants to shape a bet, define a pitch, or scope work.",
-    {
-      idea: z23.string().describe("Brief description of the idea or feature to shape (e.g. 'Improve the glossary editing flow')")
-    },
-    async ({ idea }) => {
-      let strategicContext = "";
-      let governanceContext = "";
-      let activeBetsContext = "";
-      let tensionsContext = "";
-      try {
-        const orient = await mcpQuery("chain.getOrientEntries", {});
-        const sc = orient?.strategicContext;
-        if (sc?.vision) strategicContext += `**Vision:** ${sc.vision}
-`;
-        if (sc?.purpose) strategicContext += `**Purpose:** ${sc.purpose}
-`;
-        if (sc?.currentBet) strategicContext += `**Current bet:** ${sc.currentBet}
-`;
-        strategicContext += `${sc?.activeBetCount ?? 0} active bet(s), ${sc?.activeTensionCount ?? 0} open tension(s).
-`;
-        if (orient?.activeBets?.length) {
-          activeBetsContext = orient.activeBets.map((b) => `- \`${b.entryId ?? "?"}\` ${b.name}`).join("\n");
-        }
-        const govParts = [];
-        if (orient?.principles?.length) {
-          govParts.push("**Principles:**\n" + orient.principles.map((p) => `- \`${p.entryId}\` ${p.name}`).join("\n"));
-        }
-        if (orient?.standards?.length) {
-          govParts.push("**Standards:**\n" + orient.standards.map((s) => `- \`${s.entryId}\` ${s.name}`).join("\n"));
-        }
-        if (orient?.businessRules?.length) {
-          govParts.push("**Business Rules:**\n" + orient.businessRules.map((r) => `- \`${r.entryId}\` ${r.name}`).join("\n"));
-        }
-        governanceContext = govParts.join("\n\n");
-      } catch {
-        strategicContext = "_Could not load workspace context \u2014 proceed without it._\n";
-      }
-      try {
-        const tensions = await mcpQuery(
-          "chain.listEntries",
-          { collectionSlug: "tensions" }
-        );
-        const open = (tensions ?? []).filter((t) => t.workflowStatus === "open");
-        if (open.length > 0) {
-          tensionsContext = open.slice(0, 10).map((t) => `- \`${t.entryId ?? "?"}\` ${t.name}`).join("\n");
-        }
-      } catch {
-      }
-      return {
-        messages: [{
-          role: "user",
-          content: {
-            type: "text",
-            text: `# Shape a Bet: ${idea}
-
-You are a **coached shaping facilitator** powered by the \`facilitate\` tool. You guide the user through structured shaping while the server scores, captures, and coaches.
-
-## Your Role (DEC-56 Boundary)
-
-The **server judges** \u2014 it scores input against 7 rubric dimensions, detects overlap with existing Chain entries, and checks alignment with governance. The server returns structured coaching responses.
-**You coach** \u2014 you interpret the structured response, synthesize it naturally, decide tone, follow up on weak areas, and push back when the shaping isn't sharp enough.
-The \`coaching.suggestedQuestion\` is a suggestion, not a script \u2014 rephrase or skip based on conversation flow.
-
-## Rubric Dimensions (7 scoring criteria)
-
-Each scored 0-10 by the server:
-1. **Problem Clarity** \u2014 workaround described, who affected, frequency/severity, differentiated from existing tensions
-2. **Appetite Definition** \u2014 time constraint explicit, scope bounded, trade-offs acknowledged
-3. **Element Decomposition** \u2014 breadboard-level pieces identified, independently describable, no implementation leaks
-4. **Architecture Fit** \u2014 layer boundaries and dependency implications are explicit, aligned with existing system constraints
-5. **Risk Coverage** \u2014 rabbit holes named, mitigations or acceptances, codebase-level risks
-6. **Boundary Specification** \u2014 explicit no-gos, each prevents scope creep in a specific direction
-7. **Done-When Quality** \u2014 testable completion outcomes, measurable verification criteria, and clear acceptance conditions
-
-## How to Use the Facilitate Tool
-
-### Prerequisites
-1. \`session action=start\` (if not already active)
-2. \`orient\` (loads context and unlocks writes)
-
-### Session Flow
-1. **Start:** \`facilitate action=start betName="${idea}"\`
-   Starts shaping context only (no entry is created yet).
-
-2. **First respond:** \`facilitate action=respond betName="${idea}" userInput="<user's input>"\`
-   This creates the draft bet and captures the initial problem context.
-
-   Save \`captured.betEntryId\` from the response and reuse it for every subsequent call.
-
-3. **Respond (repeat):** \`facilitate action=respond betEntryId="..." userInput="<user's input>"\`
-   Optionally add \`dimension="problem_clarity"\` to target a specific dimension.
-
-   **CRITICAL \u2014 Capture is REQUIRED for structured items:**
-   Elements, risks, and no-gos MUST include the \`capture\` parameter. Without it, nothing is saved to the bet \u2014 the data is silently lost and you will receive a WARNING.
-   - Elements: \`capture={type:"element", name:"...", description:"..."}\`
-   - Risks: \`capture={type:"risk", name:"...", description:"...", theme:"implementation"}\`
-   - No-gos: \`capture={type:"noGo", name:"...", description:"..."}\`
-   Each element, risk, and no-go needs its own \`respond\` call with \`capture\`.
-
-4. **Score (anytime):** \`facilitate action=score betEntryId="..."\`
-   Check the scorecard without advancing.
-
-5. **Resume:** \`facilitate action=resume betEntryId="..."\`
-   Reconstruct session from Chain state if returning to an existing bet.
-
-### Reading the Response
-The \`respond\` action returns JSON with:
-- \`scorecard\` \u2014 current scores per dimension (0-10)
-- \`overlap\` \u2014 existing Chain entries that may duplicate this work
-- \`chainSurfaced\` \u2014 related entries the user might not know about (weave into coaching)
-- \`coaching.observation\` \u2014 what the server observed
-- \`coaching.missing\` \u2014 what's still needed
-- \`coaching.pushback\` \u2014 challenge to present to the user
-- \`coaching.suggestedQuestion\` \u2014 next question to ask
-- \`coaching.captureReady\` \u2014 true when 3+ dimensions are complete
-- \`navigation.activeDimension\` \u2014 the dimension being coached
-- \`captured\` \u2014 entries created this turn, Studio URL
-- \`captureErrors\` \u2014 partial failures (non-blocking)
-
-### Coaching Style
-- One dimension at a time. Don't dump all dimensions at once.
-- Push back on vague problems. "Who's affected?" is always a valid question.
-- When \`chainSurfaced\` returns related entries, weave them in: "There's a decision on the Chain about this \u2014 DEC-56 says..."
-- When \`overlap\` finds matches, challenge: "This tension already exists. How is your bet different?"
-- When \`captureReady\` is true, offer to finalize. Don't force completion.
-- Keep chat messages short (5 lines or fewer). The tool does the heavy lifting.
-
-## Workspace Context
-
-` + (strategicContext ? `### Strategic Context
-${strategicContext}
-` : "") + (activeBetsContext ? `### Active Bets
-${activeBetsContext}
-
-` : "") + (tensionsContext ? `### Open Tensions
-${tensionsContext}
-
-` : "") + (governanceContext ? `### Governance Constraints
-_The shaping must honor these:_
-
-${governanceContext}
-
-` : "") + `## Constellation Capture (STA-1)
-The facilitate tool captures in real-time:
-- Elements \u2192 \`features\` collection, \`part_of\` \u2192 bet
-- Risks \u2192 \`tensions\` collection, \`constrains\` \u2192 bet
-- Decisions \u2192 \`decisions\` collection, \`informs\` \u2192 bet
-- No-gos \u2192 updated on the bet entry directly
-
-Walk away mid-session and everything captured so far exists as drafts. \`facilitate action=resume\` picks it up.
-
----
-
-**Begin now.** Call \`facilitate action=start betName="${idea}"\` and then ask the user to describe the problem.`
-          }
-        }]
-      };
-    }
-  );
   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.",
@@ -12998,4 +10877,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-BWK4N5YU.js.map
+//# sourceMappingURL=chunk-2TAMQOP7.js.map