@productbrain/mcp 0.0.1-beta.32 → 0.0.1-beta.34

package/dist/{chunk-THAYIBTL.js → chunk-HTL6Y2AO.js}

@@ -25,11 +25,11 @@ import {
   startAgentSession,
   trackWriteTool,
   translateStaleToolNames
-} from "./chunk-UOT3O5FN.js";
+} from "./chunk-TPX6TOGV.js";
 import {
   trackQualityCheck,
   trackQualityVerdict
-} from "./chunk-SJ2ODB3Y.js";
+} from "./chunk-TB24VJ4Z.js";
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -125,7 +125,7 @@ ${formatted}` }]
     },
     async ({ entryId }) => {
       requireWriteAccess();
-      const { runContradictionCheck } = await import("./smart-capture-6TQM35CV.js");
+      const { runContradictionCheck } = await import("./smart-capture-QMBL4KGX.js");
       const entry = await mcpQuery("chain.getEntry", { entryId });
       if (!entry) {
         return {
@@ -1569,7 +1569,7 @@ function registerLabelTools(server) {
 }
 
 // src/tools/health.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/tools/session.ts
 import { z as z9 } from "zod";
@@ -2311,8 +2311,200 @@ Create a Cursor Plan with these rounds as tasks. Mark each in_progress as you en
 
 The retro must never fail silently. Always communicate state.`
 };
+var SHAPE_WORKFLOW = {
+  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.",
+  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
+
+- 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`,
+  rounds: [
+    {
+      id: "context",
+      num: "01",
+      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?'",
+      outputSchema: {
+        field: "context",
+        description: "Chain context: related entries, governance, existing decisions",
+        format: "structured"
+      },
+      maxDurationHint: "2 min"
+    },
+    {
+      id: "framing",
+      num: "02",
+      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.",
+      questions: [
+        {
+          id: "appetite",
+          prompt: "How much time is this idea worth? Not how long it'll take \u2014 how much are you willing to invest?",
+          options: [
+            { id: "small", label: "Small Batch \u2014 1-2 weeks, focused scope" },
+            { id: "big", label: "Big Batch \u2014 6 weeks, full treatment" }
+          ]
+        },
+        {
+          id: "frame-go",
+          prompt: "Frame Go \u2014 the problem is tight enough to shape a solution. Proceed to elements?",
+          options: [
+            { id: "go", label: "Frame Go \u2014 move to elements" },
+            { id: "refine", label: "Refine the frame \u2014 something's not right" }
+          ]
+        }
+      ],
+      outputSchema: {
+        field: "framing",
+        description: "Confirmed problem statement and appetite",
+        format: "structured"
+      },
+      kbCollection: "bets",
+      maxDurationHint: "10 min"
+    },
+    {
+      id: "elements",
+      num: "03",
+      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.",
+      outputSchema: {
+        field: "elements",
+        description: "Core solution elements and architecture",
+        format: "structured"
+      },
+      kbCollection: "features",
+      maxDurationHint: "15 min"
+    },
+    {
+      id: "derisking",
+      num: "04",
+      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. When risks score 6+ and boundaries score 4+, present Shape Go gate: 'Is this buildable within the appetite?'",
+      questions: [
+        {
+          id: "shape-go",
+          prompt: "Shape Go \u2014 the solution fits the appetite and risks are managed. Proceed to validation?",
+          options: [
+            { id: "go", label: "Shape Go \u2014 move to validation" },
+            { id: "cut", label: "Cut scope \u2014 this grew beyond appetite" },
+            { id: "refine", label: "Refine \u2014 more de-risking needed" }
+          ]
+        }
+      ],
+      outputSchema: {
+        field: "derisking",
+        description: "Rabbit holes with patches, explicit no-gos",
+        format: "structured"
+      },
+      kbCollection: "tensions",
+      maxDurationHint: "10 min"
+    },
+    {
+      id: "validation",
+      num: "05",
+      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. Present the build contract. Ask: 'Anything to adjust before we capture to the Chain?'",
+      outputSchema: {
+        field: "validation",
+        description: "Completeness check result and build contract",
+        format: "structured"
+      },
+      maxDurationHint: "5 min"
+    },
+    {
+      id: "capture",
+      num: "06",
+      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.",
+      outputSchema: {
+        field: "capture",
+        description: "Final capture summary \u2014 entries committed, relations created",
+        format: "structured"
+      },
+      kbCollection: "bets",
+      maxDurationHint: "5 min"
+    }
+  ],
+  kbOutputCollection: "bets",
+  kbOutputTemplate: {
+    nameTemplate: "{betName}",
+    descriptionField: "problem"
+  },
+  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.
+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."
+
+The shaping must never fail silently. Always communicate state.`
+};
 var WORKFLOWS = /* @__PURE__ */ new Map([
-  ["retro", RETRO_WORKFLOW]
+  ["retro", RETRO_WORKFLOW],
+  ["shape", SHAPE_WORKFLOW]
 ]);
 function getWorkflow(id) {
   return WORKFLOWS.get(id);
@@ -2498,10 +2690,1567 @@ This checkpoint was NOT saved. The conversation context is preserved \u2014 cont
   return { content: [{ type: "text", text: lines.join("\n") }] };
 }
 
+// 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"
+];
+var DIMENSION_LABELS = {
+  problem_clarity: "Problem Clarity",
+  appetite: "Appetite Definition",
+  elements: "Element Decomposition",
+  architecture: "Architecture Grounding",
+  risks: "Risk Coverage",
+  boundaries: "Boundary Specification"
+};
+var SUGGESTED_ORDER = [
+  "problem_clarity",
+  "appetite",
+  "elements",
+  "architecture",
+  "risks",
+  "boundaries"
+];
+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 inferPhase(scorecard, isSmallBatch = false) {
+  if (scorecard.problem_clarity === 0 && scorecard.appetite === 0) return "context";
+  if (scorecard.problem_clarity < 6 || scorecard.appetite < 6) return "framing";
+  const archGate = isSmallBatch ? true : scorecard.architecture >= 4;
+  if (scorecard.elements < 6 || !archGate) return "elements";
+  if (scorecard.risks < 6 || scorecard.boundaries < 4) return "derisking";
+  const activeDims = activeDimensions(isSmallBatch);
+  const allAboveThreshold = activeDims.every((d) => scorecard[d] >= 4);
+  if (!allAboveThreshold) return "derisking";
+  const highQuality = activeDims.every((d) => scorecard[d] >= 6);
+  if (!highQuality) return "validation";
+  return "capture";
+}
+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"
+];
+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 = [];
+  let score = 0;
+  if (countMatches(text, WORKAROUND_SIGNALS) > 0) {
+    satisfied.push("Current workaround described");
+    score += 3;
+  } else {
+    missing.push("Describe the current workaround \u2014 how do people deal with this today?");
+  }
+  if (countMatches(text, AFFECTED_SIGNALS) > 0) {
+    satisfied.push("Affected people identified");
+    score += 2;
+  } else {
+    missing.push("Who experiences this problem? Be specific about the role or persona.");
+  }
+  if (countMatches(text, FREQUENCY_SIGNALS) > 0) {
+    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`);
+    score += 2;
+  } else if (/\b(TEN|DEC|ENT|FEAT|BET)-\w+/i.test(text)) {
+    satisfied.push("References existing Chain entries");
+    score += 1;
+  } else {
+    missing.push("How does this differ from existing tensions or bets on the Chain?");
+  }
+  if (text.length > 200) {
+    satisfied.push("Substantive description provided");
+    score += 1;
+  }
+  return { score: clamp(score, 0, 10), missing, satisfied };
+}
+function scoreAppetite(ctx) {
+  const text = ctx.dimensionTexts.appetite;
+  const missing = [];
+  const satisfied = [];
+  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");
+    score += 4;
+  } else if (hasTimeSignals) {
+    satisfied.push("Time constraint mentioned");
+    score += 2;
+    missing.push("Declare the batch size explicitly \u2014 Small Batch (1-2 weeks) or Big Batch (6 weeks).");
+  } else {
+    missing.push("Set a time constraint \u2014 how long is this bet allowed to take?");
+  }
+  if (countMatches(text, SCOPE_SIGNALS) > 0) {
+    satisfied.push("Scope bounded with trade-offs");
+    score += 2;
+  } else {
+    missing.push("What trade-offs are you making? What's the 80% cut?");
+  }
+  if (/phase\s*[a-c1-3]|phased|milestone/i.test(text)) {
+    satisfied.push("Phased delivery strategy");
+    score += 2;
+  }
+  if (/gate|validate|dogfood|benchmark|circuit.?breaker/i.test(text)) {
+    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 };
+}
+function scoreElements(ctx) {
+  const text = ctx.dimensionTexts.elements;
+  const missing = [];
+  const satisfied = [];
+  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);
+  if (ctx.elementCount >= 3) {
+    satisfied.push(`${ctx.elementCount} elements captured on Chain`);
+    score += 5;
+  } else if (ctx.elementCount > 0) {
+    satisfied.push(`${ctx.elementCount} element(s) captured`);
+    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`);
+    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`);
+    score += textDescribed * 2;
+    missing.push("Identify more solution elements \u2014 aim for 3+ independently describable pieces.");
+  } else {
+    missing.push("Identify solution elements \u2014 breadboard-level pieces, each independently describable.");
+  }
+  if (text.length > 20) {
+    const hasNoImpl = !/\b(implement|code|function|class|import|export|module)\b/i.test(text) || /breadboard|concept|capability|value/i.test(text);
+    if (hasNoImpl) {
+      satisfied.push("Abstraction level appropriate");
+      score += 2;
+    } else {
+      missing.push("Elements should be at breadboard level \u2014 capabilities, not implementation details.");
+    }
+  }
+  const totalElements = Math.max(ctx.elementCount, textDescribed);
+  if (totalElements >= 2) {
+    satisfied.push("Multiple independently describable pieces");
+    score += 2;
+  }
+  if (ctx.governanceCount > 0) {
+    satisfied.push(`${ctx.governanceCount} governance entries constrain the solution`);
+    score += 1;
+  }
+  return { score: clamp(score, 0, 10), missing, satisfied };
+}
+function scoreArchitecture(ctx) {
+  const text = ctx.dimensionTexts.architecture;
+  const missing = [];
+  const satisfied = [];
+  let score = 0;
+  if (ctx.hasArchitectureText) {
+    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);
+  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.");
+  }
+  if (countMatches(text, ARCH_QUALITY_SIGNALS) > 0) {
+    satisfied.push("Dependency direction / boundaries specified");
+    score += 2;
+  } else {
+    missing.push("What dependencies does this create or remove? Specify direction.");
+  }
+  if (/mermaid|diagram|flowchart|graph/i.test(text)) {
+    satisfied.push("Visual architecture representation");
+    score += 2;
+  } else {
+    missing.push("Add an architecture diagram (Mermaid) showing layers and data flow.");
+  }
+  if (ctx.governanceCount > 0) {
+    satisfied.push("Architecture checked against governance");
+    score += 1;
+  }
+  return { score: clamp(score, 0, 10), missing, satisfied };
+}
+function scoreRisks(ctx) {
+  const text = ctx.dimensionTexts.risks;
+  const missing = [];
+  const satisfied = [];
+  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));
+  if (ctx.riskCount >= 2) {
+    satisfied.push(`${ctx.riskCount} risks captured on Chain`);
+    score += 4;
+  } else if (totalRisks >= 2) {
+    satisfied.push(`${totalRisks} risks identified`);
+    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");
+    score += 2;
+    missing.push("Identify more risks \u2014 aim for 2+ rabbit holes with mitigations.");
+  } else {
+    missing.push("Name the rabbit holes \u2014 what could go wrong, what's unknown?");
+  }
+  const mitigationCount = countMatches(text, MITIGATION_SIGNALS);
+  if (mitigationCount >= 2) {
+    satisfied.push("Multiple mitigations specified");
+    score += 3;
+  } else if (mitigationCount > 0) {
+    satisfied.push("Mitigation present");
+    score += 2;
+    missing.push("Each risk should have a mitigation or explicit acceptance.");
+  } else {
+    missing.push("Each risk needs a mitigation or explicit acceptance.");
+  }
+  if (/codebase|architecture|coupling|dependency|schema|migration/i.test(text)) {
+    satisfied.push("Codebase-level risks identified");
+    score += 2;
+  } else {
+    missing.push("Are there high-risk areas in the codebase? Check architecture and dependencies.");
+  }
+  if (totalRisks >= 3) {
+    satisfied.push("Thorough risk coverage");
+    score += 1;
+  }
+  return { score: clamp(score, 0, 10), missing, satisfied };
+}
+function scoreBoundaries(ctx) {
+  const text = ctx.dimensionTexts.boundaries;
+  const missing = [];
+  const satisfied = [];
+  let score = 0;
+  const noGoSignals = countMatches(text, NOGO_SIGNALS);
+  const wontStatements = (text.match(/\bwon'?t\b|\bwill not\b/gi) ?? []).length;
+  const totalNoGos = Math.max(ctx.noGoCount, noGoSignals, wontStatements);
+  if (totalNoGos >= 3) {
+    satisfied.push(`${totalNoGos} explicit no-gos declared`);
+    score += 5;
+  } else if (totalNoGos > 0) {
+    satisfied.push(`${totalNoGos} no-go(s) declared`);
+    score += totalNoGos * 2;
+    missing.push("Add more explicit no-gos to prevent scope creep.");
+  } else {
+    missing.push("Declare what you're NOT building \u2014 explicit no-gos prevent scope creep.");
+  }
+  if (/scope creep|prevent|boundary|limit|constrain|excluded/i.test(text)) {
+    satisfied.push("Scope creep prevention language");
+    score += 2;
+  }
+  if (/direction|instead.*will|rather.*than|not.*but/i.test(text)) {
+    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.");
+  }
+  if (totalNoGos >= 5) {
+    satisfied.push("Comprehensive boundary specification");
+    score += 1;
+  }
+  return { score: clamp(score, 0, 10), missing, satisfied };
+}
+var SCORERS = {
+  problem_clarity: scoreProblemClarity,
+  appetite: scoreAppetite,
+  elements: scoreElements,
+  architecture: scoreArchitecture,
+  risks: scoreRisks,
+  boundaries: scoreBoundaries
+};
+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
+  };
+}
+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)[^.]*\./i);
+      if (match) {
+        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) {
+        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)[^.]*\./i);
+      if (match) {
+        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:)[^.]*\./i);
+    if (match) {
+      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);
+}
+var PHASE_INVESTIGATIONS = {
+  context: (betName) => ({
+    phase: "context",
+    dimension: "problem_clarity",
+    tasks: [
+      { target: "chain", query: `Search for entries related to: ${betName}`, 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: ${betName}`, 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: (betName) => ({
+    phase: "framing",
+    dimension: "problem_clarity",
+    tasks: [
+      { target: "codebase", query: `Find workarounds, TODOs, or hacks related to: ${betName}`, purpose: "Surface concrete evidence of the problem" },
+      { target: "chain", query: "Search for related tensions and user complaints", 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: (betName) => ({
+    phase: "elements",
+    dimension: "elements",
+    tasks: [
+      { target: "codebase", query: `Find modules, services, and components that would be affected by: ${betName}`, purpose: "Map the solution to existing architecture" },
+      { 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: (betName) => ({
+    phase: "derisking",
+    dimension: "risks",
+    tasks: [
+      { target: "codebase", query: `Find fragile code, tight coupling, or missing tests near: ${betName}`, purpose: "Surface technical risks from code" },
+      { 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) {
+  const builder = PHASE_INVESTIGATIONS[phase];
+  return builder(betName, betEntryId);
+}
+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-format.ts
+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"];
+var facilitateSchema = z12.object({
+  action: z12.enum(FACILITATE_ACTIONS).describe(
+    "'start': create draft bet and begin session. 'respond': process user input, score, capture, return coaching. 'score': return current scorecard without advancing. 'resume': reconstruct session from existing bet entry."
+  ),
+  sessionType: z12.enum(["shape"]).default("shape").optional().describe("Session type. Only 'shape' in v1."),
+  betEntryId: z12.string().optional().describe("Bet entry ID for resume action."),
+  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.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)")
+  }).optional().describe("Entry to capture alongside the respond action.")
+});
+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**: Create a draft bet on the Chain and begin a coached session. Returns Studio URL, initial context, and first coaching prompt.\n- **respond**: Process user input \u2014 scores against 6 shaping rubrics (problem, appetite, elements, architecture, risks, boundaries), 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\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
+      }
+    },
+    async (args) => {
+      const parsed = facilitateSchema.safeParse(args);
+      if (!parsed.success) {
+        const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+        return {
+          content: [{ type: "text", text: `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);
+          default:
+            return {
+              content: [{
+                type: "text",
+                text: `Unknown action '${action}'. Valid: ${FACILITATE_ACTIONS.join(", ")}.`
+              }]
+            };
+        }
+      });
+    }
+  );
+}
+function buildStudioUrl(workspaceSlug, entryId) {
+  return `https://productbrain.app/${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 \`commit-entry entryId="${b}"\`.`,
+      `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 };
+}
+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 emptyResponse(betEntryId, studioUrl) {
+  return {
+    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"],
+      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 });
+  } catch {
+    return null;
+  }
+}
+async function loadConstellationState(betEntryId, betInternalId) {
+  try {
+    const relations = await mcpQuery("chain.listEntryRelations", {
+      entryId: betEntryId
+    });
+    const internalId = betInternalId ?? (await loadBetEntry(betEntryId))?._id;
+    const elementCount = relations.filter(
+      (r) => r.type === "part_of" && r.toId === internalId
+    ).length;
+    const riskCount = relations.filter((r) => r.type === "constrains").length;
+    const decisionCount = relations.filter((r) => r.type === "informs").length;
+    return { relations, elementCount, riskCount, decisionCount };
+  } catch {
+    return { relations: [], elementCount: 0, riskCount: 0, decisionCount: 0 };
+  }
+}
+var RELATION_TO_COLLECTION = {
+  part_of: "features",
+  constrains: "tensions",
+  informs: "decisions"
+};
+async function loadSessionDrafts(betEntryId, betInternalId) {
+  try {
+    const relations = await mcpQuery("chain.listEntryRelations", {
+      entryId: betEntryId
+    });
+    const internalId = betInternalId ?? (await loadBetEntry(betEntryId))?._id;
+    const incoming = relations.filter(
+      (r) => r.toId === internalId && ["part_of", "constrains", "informs"].includes(r.type)
+    );
+    const drafts = [];
+    for (const rel of incoming.slice(0, 15)) {
+      try {
+        const entry = await mcpQuery(
+          "chain.getEntry",
+          { id: rel.fromId }
+        );
+        if (entry?.entryId) {
+          drafts.push({
+            entryId: entry.entryId,
+            name: entry.name,
+            collection: RELATION_TO_COLLECTION[rel.type] ?? "unknown",
+            relationType: rel.type
+          });
+        }
+      } catch {
+      }
+    }
+    return drafts;
+  } catch {
+    return [];
+  }
+}
+function buildScoringContext(userInput, betData, constellation, overlapIds, chainSurfaced = [], activeDimension, source = "user") {
+  const str = (key) => betData[key] ?? "";
+  const accParts = [
+    str("problem"),
+    str("appetite"),
+    str("elements"),
+    str("architecture"),
+    str("rabbitHoles"),
+    str("noGos"),
+    str("solution"),
+    userInput
+  ];
+  const noGoText = str("noGos");
+  const bulletNoGos = (noGoText.match(/^- \*\*/gm) ?? []).length;
+  const boundariesFull = [noGoText, activeDimension === "boundaries" ? userInput : ""].join("\n");
+  const wontNoGos = (boundariesFull.match(/\bwon'?t\b|\bwill not\b/gi) ?? []).length;
+  const noGoCount = Math.max(bulletNoGos, wontNoGos);
+  const governanceCollections = /* @__PURE__ */ new Set(["principles", "standards", "business-rules"]);
+  const governanceCount = chainSurfaced.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"))
+  };
+  return {
+    userInput,
+    accumulatedText: accParts.filter(Boolean).join("\n\n"),
+    dimensionTexts,
+    existingEntryIds: overlapIds,
+    elementCount: constellation.elementCount,
+    riskCount: constellation.riskCount,
+    noGoCount,
+    governanceCount,
+    decisionCount: constellation.decisionCount,
+    hasArchitectureText,
+    source
+  };
+}
+async function searchOverlap(text) {
+  if (text.length < 20) return [];
+  const query = text.slice(0, 200);
+  try {
+    const results = await mcpQuery(
+      "chain.searchEntries",
+      { query }
+    );
+    return (results ?? []).filter((r) => r.entryId).slice(0, 5).map((r) => ({
+      entryId: r.entryId,
+      similarity: "text_match",
+      summary: `${r.name} [${r.collectionSlug ?? "unknown"}]`
+    }));
+  } catch {
+    return [];
+  }
+}
+async function gatherChainContext(text, betName) {
+  if (text.length < 10 && (!betName || betName.length < 5)) return [];
+  const searchText = (text.length >= 10 ? text : betName ?? "").slice(0, 300);
+  try {
+    const results = await mcpQuery(
+      "chain.searchEntries",
+      { query: searchText }
+    );
+    return (results ?? []).filter((e) => e.entryId).slice(0, 8).map((e) => ({
+      entryId: e.entryId,
+      relevance: e.name,
+      collection: e.collectionSlug ?? "unknown"
+    }));
+  } catch {
+    return [];
+  }
+}
+async function findAndLinkExisting(name, collectionSlug, betEntryId, relationType) {
+  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
+      });
+      await recordSessionActivity({ relationCreated: true });
+      return { entryId: match.entryId, linked: true };
+    } catch {
+      return { entryId: match.entryId, linked: false };
+    }
+  } catch {
+    return null;
+  }
+}
+async function handleStart2(args) {
+  requireWriteAccess();
+  const wsCtx = await getWorkspaceContext();
+  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?.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.";
+  }
+  let betEntryId;
+  let docId;
+  const agentId = getAgentSessionId();
+  try {
+    const result = await mcpMutation(
+      "chain.createEntry",
+      {
+        collectionSlug: "bets",
+        name: betName,
+        status: "draft",
+        data: {
+          problem: "",
+          appetite: "",
+          elements: "",
+          rabbitHoles: "",
+          noGos: "",
+          architecture: "",
+          buildContract: "",
+          description: `Shaping session for: ${betName}`,
+          status: "shaping",
+          shapingSessionActive: true
+        },
+        createdBy: agentId ? `agent:${agentId}` : "facilitate",
+        sessionId: agentId ?? void 0
+      }
+    );
+    betEntryId = result.entryId;
+    docId = result.docId;
+    await recordSessionActivity({ entryCreated: docId });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: "text", text: `Failed to create bet entry: ${msg}` }],
+      isError: true
+    };
+  }
+  const studioUrl = buildStudioUrl(wsCtx.workspaceSlug, betEntryId);
+  const response = emptyResponse(betEntryId, studioUrl);
+  const investigationBrief = buildInvestigationBrief("context", betName, betEntryId);
+  if (investigationBrief) {
+    response.investigationBrief = investigationBrief;
+  }
+  const output = [
+    `# Shaping Session Started`,
+    "",
+    `**Bet:** ${betName} (\`${betEntryId}\`)`,
+    `**Studio:** ${studioUrl}`,
+    `**Phase:** ${PHASE_LABELS.context}`,
+    "",
+    orientContext ? `**Workspace context:** ${orientContext}` : "",
+    "",
+    "Session is active. The bet exists as a draft on the Chain.",
+    "",
+    "---",
+    "## 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 betEntryId="${betEntryId}" dimension="problem_clarity"\` with their answer as userInput.`
+  ].filter(Boolean).join("\n");
+  return {
+    content: [{ type: "text", text: output }],
+    structuredContent: response
+  };
+}
+async function handleRespond(args) {
+  requireWriteAccess();
+  const { userInput, betEntryId: argBetId, dimension: argDimension, capture: captureArg, source: argSource } = args;
+  const source = argSource ?? "user";
+  if (!userInput) {
+    return {
+      content: [{ type: "text", text: "`userInput` is required for respond action." }]
+    };
+  }
+  if (!argBetId) {
+    return {
+      content: [{ type: "text", text: "`betEntryId` is required for respond action. Use start first." }]
+    };
+  }
+  const captureErrors = [];
+  const entriesCreated = [];
+  let relationsCreated = 0;
+  const [betEntry, constellation, overlap, chainSurfaced] = await Promise.all([
+    loadBetEntry(argBetId),
+    loadConstellationState(argBetId),
+    captureArg ? Promise.resolve([]) : searchOverlap(userInput),
+    gatherChainContext(userInput)
+  ]);
+  if (!betEntry) {
+    return {
+      content: [{ type: "text", text: `Bet \`${argBetId}\` not found. Use start to create a session.` }]
+    };
+  }
+  const betData = betEntry.data ?? {};
+  if (captureArg) {
+    const capAgentId = getAgentSessionId();
+    const collectionMap = {
+      element: { slug: "features", dataField: "description", relationType: "part_of" },
+      risk: { slug: "tensions", dataField: "description", relationType: "constrains" },
+      decision: { slug: "decisions", dataField: "rationale", relationType: "informs" }
+    };
+    if (captureArg.type === "noGo") {
+      const updatedNoGos = appendNoGo(
+        betData.noGos,
+        { title: captureArg.name, explanation: captureArg.description }
+      );
+      try {
+        await mcpMutation("chain.updateEntry", {
+          entryId: argBetId,
+          data: { noGos: updatedNoGos },
+          changeNote: `Added no-go: ${captureArg.name}`
+        });
+        await recordSessionActivity({ entryModified: betEntry._id });
+      } catch (updErr) {
+        captureErrors.push({
+          operation: "update",
+          detail: `noGos field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
+        });
+      }
+    } else {
+      const mapping = collectionMap[captureArg.type];
+      if (mapping) {
+        let capturedEntryId = null;
+        try {
+          const result = await mcpMutation(
+            "chain.createEntry",
+            {
+              collectionSlug: mapping.slug,
+              name: captureArg.name,
+              status: "draft",
+              data: { [mapping.dataField]: captureArg.description },
+              createdBy: capAgentId ? `agent:${capAgentId}` : "facilitate",
+              sessionId: capAgentId ?? void 0
+            }
+          );
+          capturedEntryId = result.entryId;
+          entriesCreated.push(result.entryId);
+          await recordSessionActivity({ entryCreated: result.docId });
+        } catch (createErr) {
+          const msg = createErr instanceof Error ? createErr.message : String(createErr);
+          if (msg.includes("Duplicate entry") || msg.includes("already exists")) {
+            const fallback = await findAndLinkExisting(
+              captureArg.name,
+              mapping.slug,
+              argBetId,
+              mapping.relationType
+            );
+            if (fallback) {
+              capturedEntryId = fallback.entryId;
+              entriesCreated.push(fallback.entryId);
+              if (fallback.linked) relationsCreated++;
+              captureErrors.push({
+                operation: "info",
+                detail: `Linked existing ${mapping.slug} entry \`${fallback.entryId}\` instead of creating duplicate.`
+              });
+            } else {
+              captureErrors.push({ operation: "capture", detail: `${captureArg.type}: ${msg}` });
+            }
+          } else {
+            captureErrors.push({ operation: "capture", detail: `${captureArg.type}: ${msg}` });
+          }
+        }
+        if (capturedEntryId) {
+          try {
+            await mcpMutation("chain.createEntryRelation", {
+              fromEntryId: capturedEntryId,
+              toEntryId: argBetId,
+              type: mapping.relationType
+            });
+            relationsCreated++;
+            await recordSessionActivity({ relationCreated: true });
+          } catch (relErr) {
+            const msg = relErr instanceof Error ? relErr.message : String(relErr);
+            if (!msg.includes("already exists") && !msg.includes("Duplicate")) {
+              captureErrors.push({
+                operation: "relation",
+                detail: `${mapping.relationType} from ${capturedEntryId} to ${argBetId}: ${msg}`
+              });
+            }
+          }
+          if (captureArg.type === "element") {
+            const updatedElements = appendElement(
+              betData.elements,
+              { name: captureArg.name, description: captureArg.description, entryId: capturedEntryId }
+            );
+            try {
+              await mcpMutation("chain.updateEntry", {
+                entryId: argBetId,
+                data: { elements: updatedElements },
+                changeNote: `Added element: ${captureArg.name}`
+              });
+              await recordSessionActivity({ entryModified: betEntry._id });
+            } catch (updErr) {
+              captureErrors.push({
+                operation: "update",
+                detail: `elements field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
+              });
+            }
+          } else if (captureArg.type === "risk") {
+            const updatedRisks = appendRabbitHole(
+              betData.rabbitHoles,
+              { name: captureArg.name, description: captureArg.description, theme: captureArg.theme, entryId: capturedEntryId }
+            );
+            try {
+              await mcpMutation("chain.updateEntry", {
+                entryId: argBetId,
+                data: { rabbitHoles: updatedRisks },
+                changeNote: `Added risk: ${captureArg.name}`
+              });
+              await recordSessionActivity({ entryModified: betEntry._id });
+            } catch (updErr) {
+              captureErrors.push({
+                operation: "update",
+                detail: `rabbitHoles field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  const refreshedBet = await loadBetEntry(argBetId);
+  const refreshedData = refreshedBet?.data ?? betData;
+  const refreshedConstellation = captureArg ? await loadConstellationState(argBetId, refreshedBet?._id ?? betEntry._id) : constellation;
+  const overlapIds = overlap.map((o) => o.entryId);
+  const appetiteText = refreshedData.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 = buildScorecard(scoringCtx);
+  if (isSmallBatch) scorecard.architecture = -1;
+  const completed = completedDimensions(scorecard, 6, isSmallBatch);
+  const nextDimension = inferActiveDimension(scorecard, isSmallBatch);
+  const phase = inferPhase(scorecard, isSmallBatch);
+  try {
+    const fieldUpdates = {};
+    const persist = (dim, field, minLen) => {
+      if (activeDimension === dim && !refreshedData[field] && userInput.length > minLen) {
+        fieldUpdates[field] = userInput;
+      }
+    };
+    persist("problem_clarity", "problem", 50);
+    persist("appetite", "appetite", 20);
+    persist("architecture", "architecture", 50);
+    if (overlapIds.length > 0 && !refreshedData._overlapIds) {
+      fieldUpdates._overlapIds = overlapIds.join(",");
+    }
+    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: argBetId,
+        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", "bets"]);
+  for (const surfaced of chainSurfaced) {
+    if (governanceCollections.has(surfaced.collection)) {
+      alignment.push({ entryId: surfaced.entryId, relationship: `governs [${surfaced.collection}]` });
+    }
+  }
+  const dims = activeDimensions(isSmallBatch);
+  const captureReady = completed.length >= (isSmallBatch ? 3 : 4) && dims.every((d) => scorecard[d] > 0);
+  const observation = dimensionResult.satisfied.length > 0 ? `${DIMENSION_LABELS[activeDimension]}: ${dimensionResult.satisfied.join("; ")}` : `${DIMENSION_LABELS[activeDimension]}: needs more detail`;
+  const pushback = !captureArg && 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?`;
+  const wsCtx = await getWorkspaceContext();
+  const studioUrl = buildStudioUrl(wsCtx.workspaceSlug, argBetId);
+  let buildContract;
+  if (captureReady) {
+    const contractCtx = {
+      betEntryId: argBetId,
+      governanceEntries: chainSurfaced.filter((e) => ["principles", "standards", "business-rules"].includes(e.collection)).map((e) => ({ entryId: e.entryId, name: e.relevance, collection: e.collection })),
+      relatedDecisions: chainSurfaced.filter((e) => e.collection === "decisions").map((e) => ({ entryId: e.entryId, name: e.relevance })),
+      relatedTensions: chainSurfaced.filter((e) => e.collection === "tensions").map((e) => ({ entryId: e.entryId, name: e.relevance }))
+    };
+    buildContract = generateBuildContract(contractCtx);
+  }
+  const suggested = suggestCaptures(scoringCtx, activeDimension);
+  const sessionDrafts = await loadSessionDrafts(argBetId, refreshedBet?._id ?? betEntry._id);
+  const betName = refreshedData.description ?? betEntry.name;
+  const investigationBrief = buildInvestigationBrief(phase, betName, argBetId) ?? void 0;
+  const response = {
+    phase,
+    phaseLabel: PHASE_LABELS[phase],
+    scorecard,
+    overlap,
+    alignment,
+    chainSurfaced,
+    suggestedCaptures: suggested,
+    sessionDrafts,
+    coaching: {
+      observation,
+      missing: dimensionResult.missing,
+      pushback,
+      suggestedQuestion,
+      captureReady,
+      nextDimension
+    },
+    captured: {
+      betEntryId: argBetId,
+      studioUrl,
+      entriesCreated,
+      relationsCreated
+    },
+    captureErrors,
+    navigation: {
+      completedDimensions: completed,
+      activeDimension,
+      suggestedOrder: dims
+    },
+    buildContract,
+    investigationBrief
+  };
+  const STRUCTURED_DIMS = {
+    elements: "element",
+    risks: "risk",
+    boundaries: "noGo"
+  };
+  const expectedCaptureType = STRUCTURED_DIMS[activeDimension];
+  const dataLossWarning = expectedCaptureType && !captureArg ? `**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 directive = buildDirective(scorecard, phase, argBetId, captureReady, activeDimension, nextDimension);
+  const summaryParts = [
+    `# ${PHASE_LABELS[phase]} \u2014 ${DIMENSION_LABELS[activeDimension]}`,
+    "",
+    dataLossWarning,
+    `**Score:** ${scorecard[activeDimension]}/10 | **Phase:** ${PHASE_LABELS[phase]}`,
+    observation,
+    pushback ? `**Pushback:** ${pushback}` : "",
+    `**Next:** ${suggestedQuestion}`,
+    captureReady ? "\n**Capture ready** \u2014 the bet has enough shape to finalize." : "",
+    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("; ")}` : "",
+    directive ? `
+---
+## Agent Directive
+${directive}` : "",
+    investigationBrief ? `
+## Investigation Brief
+${investigationBrief.tasks.map((t) => `- **${t.target}:** ${t.query} \u2014 ${t.purpose}`).join("\n")}
+
+**Proposal guidance:** ${investigationBrief.proposalGuidance}
+**Reaction prompt:** ${investigationBrief.reactionPrompt}` : ""
+  ];
+  return {
+    content: [{ type: "text", text: summaryParts.filter(Boolean).join("\n") }],
+    structuredContent: response
+  };
+}
+async function handleScore(args) {
+  const betId = args.betEntryId;
+  if (!betId) {
+    return {
+      content: [{ type: "text", text: "`betEntryId` is required for score action." }]
+    };
+  }
+  const betEntry = await loadBetEntry(betId);
+  if (!betEntry) {
+    return {
+      content: [{ type: "text", text: `Bet \`${betId}\` not found.` }]
+    };
+  }
+  const constellation = await loadConstellationState(betId, betEntry._id);
+  const betData = betEntry.data ?? {};
+  const isSmallBatch = detectSmallBatch(betData.appetite ?? "");
+  const cachedOverlapIds = typeof betData._overlapIds === "string" ? betData._overlapIds.split(",").filter(Boolean) : [];
+  const cachedGovCount = typeof betData._governanceCount === "number" ? betData._governanceCount : 0;
+  const syntheticChainSurfaced = Array.from({ length: cachedGovCount }, () => ({ collection: "principles" }));
+  const scoringCtx = buildScoringContext("", betData, constellation, cachedOverlapIds, syntheticChainSurfaced);
+  const scorecard = buildScorecard(scoringCtx);
+  if (isSmallBatch) scorecard.architecture = -1;
+  const dims = activeDimensions(isSmallBatch);
+  const completed = completedDimensions(scorecard, 6, isSmallBatch);
+  const active = inferActiveDimension(scorecard, isSmallBatch);
+  const phase = inferPhase(scorecard, isSmallBatch);
+  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(`Completed: ${completed.length}/${dims.length}`);
+  lines.push(`Next dimension: ${DIMENSION_LABELS[active]}`);
+  const sessionDrafts = await loadSessionDrafts(betId, betEntry._id);
+  if (sessionDrafts.length > 0) {
+    lines.push("");
+    lines.push(`**Session drafts (${sessionDrafts.length}):** ${sessionDrafts.map((d) => `\`${d.entryId}\` ${d.name}`).join(", ")}`);
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: { scorecard, phase, phaseLabel: PHASE_LABELS[phase], completedDimensions: completed, nextDimension: active, sessionDrafts }
+  };
+}
+async function handleResume(args) {
+  const betId = args.betEntryId;
+  if (!betId) {
+    return {
+      content: [{ type: "text", text: "`betEntryId` is required for resume action." }]
+    };
+  }
+  const betEntry = await loadBetEntry(betId);
+  if (!betEntry) {
+    return {
+      content: [{ type: "text", text: `Bet \`${betId}\` not found. Cannot resume.` }]
+    };
+  }
+  const constellation = await loadConstellationState(betId, betEntry._id);
+  const betData = betEntry.data ?? {};
+  const isSmallBatch = detectSmallBatch(betData.appetite ?? "");
+  const cachedOverlapIds = typeof betData._overlapIds === "string" ? betData._overlapIds.split(",").filter(Boolean) : [];
+  const cachedGovCount = typeof betData._governanceCount === "number" ? betData._governanceCount : 0;
+  const syntheticChainSurfaced = Array.from({ length: cachedGovCount }, () => ({ collection: "principles" }));
+  const scoringCtx = buildScoringContext("", betData, constellation, cachedOverlapIds, syntheticChainSurfaced);
+  const scorecard = buildScorecard(scoringCtx);
+  if (isSmallBatch) scorecard.architecture = -1;
+  const dims = activeDimensions(isSmallBatch);
+  const completed = completedDimensions(scorecard, 6, isSmallBatch);
+  const active = inferActiveDimension(scorecard, isSmallBatch);
+  const phase = inferPhase(scorecard, isSmallBatch);
+  const wsCtx = await getWorkspaceContext();
+  const studioUrl = buildStudioUrl(wsCtx.workspaceSlug, betId);
+  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 captureReady = completed.length >= (isSmallBatch ? 3 : 4) && dims.every((d) => scorecard[d] > 0);
+  const sessionDrafts = await loadSessionDrafts(betId, betEntry._id);
+  const response = {
+    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
+    }
+  };
+  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 output = [
+    `# Session Resumed \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,
+    "",
+    `Continue with ${DIMENSION_LABELS[active]}?`,
+    directive ? `
+---
+## Agent Directive
+${directive}` : ""
+  ].filter(Boolean).join("\n");
+  return {
+    content: [{ type: "text", text: output }],
+    structuredContent: response
+  };
+}
+
 // src/tools/verify.ts
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function resolveProjectRoot() {
   const candidates = [
     process.env.WORKSPACE_PATH,
@@ -2645,9 +4394,9 @@ function formatTrustReport(collection, entryCount, mappings, refs, fixes, mode,
   lines.push("", "---", `_Schema: ${schemaTableCount} tables parsed from convex/schema.ts. Project root: ${projectRoot}_`);
   return lines.join("\n");
 }
-var verifySchema = z12.object({
-  collection: z12.string().default("glossary").describe("Collection slug to verify (default: glossary)"),
-  mode: z12.enum(["report", "fix"]).default("report").describe("'report' = read-only trust report. 'fix' = also update drifted codeMapping statuses.")
+var verifySchema = z13.object({
+  collection: z13.string().default("glossary").describe("Collection slug to verify (default: glossary)"),
+  mode: z13.enum(["report", "fix"]).default("report").describe("'report' = read-only trust report. 'fix' = also update drifted codeMapping statuses.")
 });
 function registerVerifyTools(server) {
   const verifyTool = server.registerTool(
@@ -2789,7 +4538,7 @@ function registerVerifyTools(server) {
 }
 
 // src/tools/start.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/presets/collections.ts
 var GOVERNANCE_CORE = [
@@ -3073,8 +4822,8 @@ function buildOperatingProtocol(workspaceStandards) {
 }
 
 // src/tools/start.ts
-var startSchema = z13.object({
-  preset: z13.string().optional().describe(
+var startSchema = z14.object({
+  preset: z14.string().optional().describe(
     "Collection preset ID to seed (e.g. 'software-product', 'content-business', 'agency', 'saas-api', 'general'). Only used for fresh workspaces. If omitted on a fresh workspace, returns the preset menu."
   )
 });
@@ -3165,7 +4914,6 @@ Available presets: ${listPresets().map((p) => `\`${p.id}\``).join(", ")}`;
         icon: col.icon,
         idPrefix: col.idPrefix,
         fields: col.fields,
-        stratum: "working",
         createdBy: "preset:" + presetId
       });
       seeded.push(col.name);
@@ -3411,9 +5159,9 @@ async function buildOrientResponse(wsCtx, agentSessionId, errors) {
 }
 
 // src/tools/usage.ts
-import { z as z14 } from "zod";
-var usageSummarySchema = z14.object({
-  periodDays: z14.number().min(1).max(90).optional().describe("Number of days to look back (default 30, max 90)")
+import { z as z15 } from "zod";
+var usageSummarySchema = z15.object({
+  periodDays: z15.number().min(1).max(90).optional().describe("Number of days to look back (default 30, max 90)")
 });
 function registerUsageTools(server) {
   server.registerTool(
@@ -3476,43 +5224,43 @@ function registerUsageTools(server) {
 }
 
 // src/tools/gitchain.ts
-import { z as z15 } from "zod";
-var chainSchema = z15.object({
-  action: z15.enum(["create", "get", "list", "edit"]).describe("Action: create a process, get process details, list all processes, or edit a process link"),
-  chainEntryId: z15.string().optional().describe("Chain entry ID (required for get/edit)"),
-  title: z15.string().optional().describe("Process title (required for create)"),
-  chainTypeId: z15.string().optional().default("strategy-coherence").describe("Process template slug for create: 'strategy-coherence', 'idm-proposal', or any custom template slug"),
-  description: z15.string().optional().describe("Description (for create)"),
-  linkId: z15.string().optional().describe("Link to edit (for edit action): problem, insight, choice, action, outcome"),
-  content: z15.string().optional().describe("New content for the link (for edit action)"),
-  status: z15.string().optional().describe("Filter by status for list: 'draft' or 'active'"),
-  author: z15.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
+import { z as z16 } from "zod";
+var chainSchema = z16.object({
+  action: z16.enum(["create", "get", "list", "edit"]).describe("Action: create a process, get process details, list all processes, or edit a process link"),
+  chainEntryId: z16.string().optional().describe("Chain entry ID (required for get/edit)"),
+  title: z16.string().optional().describe("Process title (required for create)"),
+  chainTypeId: z16.string().optional().default("strategy-coherence").describe("Process template slug for create: 'strategy-coherence', 'idm-proposal', or any custom template slug"),
+  description: z16.string().optional().describe("Description (for create)"),
+  linkId: z16.string().optional().describe("Link to edit (for edit action): problem, insight, choice, action, outcome"),
+  content: z16.string().optional().describe("New content for the link (for edit action)"),
+  status: z16.string().optional().describe("Filter by status for list: 'draft' or 'active'"),
+  author: z16.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
-var chainVersionSchema = z15.object({
-  action: z15.enum(["commit", "list", "diff", "revert", "history"]).describe("Action: commit a snapshot, list commits, diff two versions, revert to a version, or view history"),
-  chainEntryId: z15.string().describe("The chain's entry ID"),
-  commitMessage: z15.string().optional().describe("Commit message (required for commit). Convention: type(link): description"),
-  versionA: z15.number().optional().describe("Earlier version for diff"),
-  versionB: z15.number().optional().describe("Later version for diff"),
-  toVersion: z15.number().optional().describe("Version number to revert to"),
-  author: z15.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
+var chainVersionSchema = z16.object({
+  action: z16.enum(["commit", "list", "diff", "revert", "history"]).describe("Action: commit a snapshot, list commits, diff two versions, revert to a version, or view history"),
+  chainEntryId: z16.string().describe("The chain's entry ID"),
+  commitMessage: z16.string().optional().describe("Commit message (required for commit). Convention: type(link): description"),
+  versionA: z16.number().optional().describe("Earlier version for diff"),
+  versionB: z16.number().optional().describe("Later version for diff"),
+  toVersion: z16.number().optional().describe("Version number to revert to"),
+  author: z16.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
-var chainBranchSchema = z15.object({
-  action: z15.enum(["create", "list", "merge", "conflicts"]).describe("Action: create a branch, list branches, merge a branch, or check for conflicts"),
-  chainEntryId: z15.string().describe("The chain's entry ID"),
-  branchName: z15.string().optional().describe("Branch name (required for merge/conflicts, optional for create)"),
-  strategy: z15.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) or 'squash'"),
-  author: z15.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
+var chainBranchSchema = z16.object({
+  action: z16.enum(["create", "list", "merge", "conflicts"]).describe("Action: create a branch, list branches, merge a branch, or check for conflicts"),
+  chainEntryId: z16.string().describe("The chain's entry ID"),
+  branchName: z16.string().optional().describe("Branch name (required for merge/conflicts, optional for create)"),
+  strategy: z16.enum(["merge_commit", "squash"]).optional().describe("Merge strategy: 'merge_commit' (default) or 'squash'"),
+  author: z16.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
-var chainReviewSchema = z15.object({
-  action: z15.enum(["gate", "comment", "resolve-comment", "list-comments"]).describe("Action: run coherence gate, add a comment, resolve a comment, or list comments"),
-  chainEntryId: z15.string().describe("The chain's entry ID"),
-  commitMessage: z15.string().optional().describe("Commit message to lint (for gate action)"),
-  versionNumber: z15.number().optional().describe("Version to comment on or list comments for"),
-  linkId: z15.string().optional().describe("Link this comment targets (optional for comment)"),
-  body: z15.string().optional().describe("Comment text (required for comment action)"),
-  commentId: z15.string().optional().describe("Comment ID (required for resolve-comment)"),
-  author: z15.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
+var chainReviewSchema = z16.object({
+  action: z16.enum(["gate", "comment", "resolve-comment", "list-comments"]).describe("Action: run coherence gate, add a comment, resolve a comment, or list comments"),
+  chainEntryId: z16.string().describe("The chain's entry ID"),
+  commitMessage: z16.string().optional().describe("Commit message to lint (for gate action)"),
+  versionNumber: z16.number().optional().describe("Version to comment on or list comments for"),
+  linkId: z16.string().optional().describe("Link this comment targets (optional for comment)"),
+  body: z16.string().optional().describe("Comment text (required for comment action)"),
+  commentId: z16.string().optional().describe("Comment ID (required for resolve-comment)"),
+  author: z16.string().optional().describe("Who is performing the action. Defaults to 'mcp'.")
 });
 function linkSummary(links) {
   return Object.entries(links).map(([id, content]) => {
@@ -3895,38 +5643,38 @@ ${formatted}`
 }
 
 // src/tools/maps.ts
-import { z as z16 } from "zod";
-var createAudienceMapSetSchema = z16.object({
-  audienceEntryId: z16.string().describe("Entry ID of the audience (e.g. STR-fb7hje)")
+import { z as z17 } from "zod";
+var createAudienceMapSetSchema = z17.object({
+  audienceEntryId: z17.string().describe("Entry ID of the audience (e.g. STR-fb7hje)")
 });
-var mapSchema = z16.object({
-  action: z16.enum(["create", "get", "list"]).describe("Action: create a map, get map details, or list all maps"),
-  mapEntryId: z16.string().optional().describe("Map entry ID (for get)"),
-  title: z16.string().optional().describe("Map title (for create)"),
-  templateId: z16.string().optional().default("lean-canvas").describe("Template slug for create: 'lean-canvas' or any composed template"),
-  description: z16.string().optional().describe("Description (for create)"),
-  slotIds: z16.array(z16.string()).optional().describe("Slot IDs to initialize (for create; auto-populated from template if omitted)"),
-  status: z16.string().optional().describe("Filter by status for list")
+var mapSchema = z17.object({
+  action: z17.enum(["create", "get", "list"]).describe("Action: create a map, get map details, or list all maps"),
+  mapEntryId: z17.string().optional().describe("Map entry ID (for get)"),
+  title: z17.string().optional().describe("Map title (for create)"),
+  templateId: z17.string().optional().default("lean-canvas").describe("Template slug for create: 'lean-canvas' or any composed template"),
+  description: z17.string().optional().describe("Description (for create)"),
+  slotIds: z17.array(z17.string()).optional().describe("Slot IDs to initialize (for create; auto-populated from template if omitted)"),
+  status: z17.string().optional().describe("Filter by status for list")
 });
-var mapSlotSchema = z16.object({
-  action: z16.enum(["add", "remove", "replace", "list"]).describe("Action: add/remove/replace an ingredient in a slot, or list slot contents"),
-  mapEntryId: z16.string().describe("Map entry ID"),
-  slotId: z16.string().optional().describe("Slot ID (e.g. 'problem', 'customer-segments')"),
-  ingredientEntryId: z16.string().optional().describe("Ingredient entry ID to add/remove"),
-  newIngredientEntryId: z16.string().optional().describe("New ingredient entry ID (for replace)"),
-  label: z16.string().optional().describe("Display label override"),
-  author: z16.string().optional().describe("Who is performing the action")
+var mapSlotSchema = z17.object({
+  action: z17.enum(["add", "remove", "replace", "list"]).describe("Action: add/remove/replace an ingredient in a slot, or list slot contents"),
+  mapEntryId: z17.string().describe("Map entry ID"),
+  slotId: z17.string().optional().describe("Slot ID (e.g. 'problem', 'customer-segments')"),
+  ingredientEntryId: z17.string().optional().describe("Ingredient entry ID to add/remove"),
+  newIngredientEntryId: z17.string().optional().describe("New ingredient entry ID (for replace)"),
+  label: z17.string().optional().describe("Display label override"),
+  author: z17.string().optional().describe("Who is performing the action")
 });
-var mapVersionSchema = z16.object({
-  action: z16.enum(["commit", "list", "history"]).describe("Action: commit the map, list commits, or view commit history"),
-  mapEntryId: z16.string().describe("Map entry ID"),
-  commitMessage: z16.string().optional().describe("Commit message (for commit action)"),
-  author: z16.string().optional().describe("Who is committing")
+var mapVersionSchema = z17.object({
+  action: z17.enum(["commit", "list", "history"]).describe("Action: commit the map, list commits, or view commit history"),
+  mapEntryId: z17.string().describe("Map entry ID"),
+  commitMessage: z17.string().optional().describe("Commit message (for commit action)"),
+  author: z17.string().optional().describe("Who is committing")
 });
-var mapSuggestSchema = z16.object({
-  mapEntryId: z16.string().describe("Map entry ID to suggest ingredients for"),
-  slotId: z16.string().optional().describe("Specific slot to find ingredients for (or all empty slots)"),
-  query: z16.string().optional().describe("Optional search query to narrow ingredient suggestions")
+var mapSuggestSchema = z17.object({
+  mapEntryId: z17.string().describe("Map entry ID to suggest ingredients for"),
+  slotId: z17.string().optional().describe("Specific slot to find ingredients for (or all empty slots)"),
+  query: z17.string().optional().describe("Optional search query to narrow ingredient suggestions")
 });
 function slotSummary(slots) {
   return Object.entries(slots).map(([id, refs]) => {
@@ -4352,7 +6100,7 @@ Use \`map-slot action=add mapEntryId="${mapEntryId}" slotId="..." ingredientEntr
 // src/tools/architecture.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
 import { resolve as resolve2, relative, dirname, normalize } from "path";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var COLLECTION_SLUG = "architecture";
 var COLLECTION_FIELDS = [
   { key: "archType", label: "Architecture Type", type: "select", required: true, options: ["template", "layer", "node", "flow"], searchable: true },
@@ -4509,14 +6257,14 @@ var SEED_FLOWS = [
   { entryId: "ARCH-flow-knowledge-trust", name: "Knowledge Trust Flow", order: 3, data: { archType: "flow", sourceNode: "ARCH-node-mcp", targetNode: "ARCH-node-glossary", description: "MCP verify tool checks entries against codebase \u2192 file existence, schema references validated \u2192 trust scores updated", color: "#22c55e" } },
   { entryId: "ARCH-flow-analytics", name: "Analytics Flow", order: 4, data: { archType: "flow", sourceNode: "ARCH-node-command-center", targetNode: "ARCH-node-posthog", description: "Feature views and actions tracked \u2192 workspace-scoped events \u2192 PostHog group analytics \u2192 Command Center metrics", color: "#ec4899" } }
 ];
-var architectureSchema = z17.object({
-  action: z17.enum(["show", "explore", "flow"]).describe("Action: show full map, explore a layer, or visualize a flow"),
-  template: z17.string().optional().describe("Template entry ID to filter by (for show)"),
-  layer: z17.string().optional().describe("Layer name or entry ID (for explore), e.g. 'Core' or 'ARCH-layer-core'"),
-  flow: z17.string().optional().describe("Flow name or entry ID (for flow), e.g. 'Smart Capture Flow'")
+var architectureSchema = z18.object({
+  action: z18.enum(["show", "explore", "flow"]).describe("Action: show full map, explore a layer, or visualize a flow"),
+  template: z18.string().optional().describe("Template entry ID to filter by (for show)"),
+  layer: z18.string().optional().describe("Layer name or entry ID (for explore), e.g. 'Core' or 'ARCH-layer-core'"),
+  flow: z18.string().optional().describe("Flow name or entry ID (for flow), e.g. 'Smart Capture Flow'")
 });
-var architectureAdminSchema = z17.object({
-  action: z17.enum(["seed", "check"]).describe("Action: seed default architecture data, or check dependency health")
+var architectureAdminSchema = z18.object({
+  action: z18.enum(["seed", "check"]).describe("Action: seed default architecture data, or check dependency health")
 });
 function registerArchitectureTools(server) {
   server.registerTool(
@@ -5191,45 +6939,45 @@ ${logLines.join("\n")}` }],
   };
 }
 var HEALTH_ACTIONS = ["check", "whoami", "status", "audit", "self-test"];
-var healthSchema = z18.object({
-  action: z18.enum(HEALTH_ACTIONS).describe(
+var healthSchema = z19.object({
+  action: z19.enum(HEALTH_ACTIONS).describe(
     "'check': connectivity and workspace stats. 'whoami': session identity. 'status': workspace readiness. 'audit': session audit log. 'self-test': validate all tool schemas."
   ),
-  limit: z18.number().min(1).max(50).default(20).optional().describe("For audit: how many recent calls to show (max 50)")
+  limit: z19.number().min(1).max(50).default(20).optional().describe("For audit: how many recent calls to show (max 50)")
 });
-var orientSchema = z18.object({
-  mode: z18.enum(["full", "brief"]).optional().default("full").describe("full = full context (default). brief = compact summary for mid-session re-orientation."),
-  task: z18.string().optional().describe("Natural-language task description for task-scoped context. When provided, orient returns scored, relevant entries for the task.")
+var orientSchema = z19.object({
+  mode: z19.enum(["full", "brief"]).optional().default("full").describe("full = full context (default). brief = compact summary for mid-session re-orientation."),
+  task: z19.string().optional().describe("Natural-language task description for task-scoped context. When provided, orient returns scored, relevant entries for the task.")
 });
-var healthCheckOutputSchema = z18.object({
-  healthy: z18.boolean(),
-  collections: z18.number(),
-  entries: z18.number(),
-  latencyMs: z18.number(),
-  workspace: z18.string()
+var healthCheckOutputSchema = z19.object({
+  healthy: z19.boolean(),
+  collections: z19.number(),
+  entries: z19.number(),
+  latencyMs: z19.number(),
+  workspace: z19.string()
 });
-var healthStatusOutputSchema = z18.object({
-  readinessScore: z18.number(),
-  activeEntries: z18.number(),
-  totalRelations: z18.number(),
-  orphanedEntries: z18.number(),
-  gaps: z18.array(z18.object({ label: z18.string(), guidance: z18.string() }))
+var healthStatusOutputSchema = z19.object({
+  readinessScore: z19.number(),
+  activeEntries: z19.number(),
+  totalRelations: z19.number(),
+  orphanedEntries: z19.number(),
+  gaps: z19.array(z19.object({ label: z19.string(), guidance: z19.string() }))
 });
-var healthAuditOutputSchema = z18.object({
-  totalCalls: z18.number(),
-  calls: z18.array(z18.object({
-    tool: z18.string(),
-    action: z18.string().optional(),
-    timestamp: z18.string(),
-    durationMs: z18.number().optional()
+var healthAuditOutputSchema = z19.object({
+  totalCalls: z19.number(),
+  calls: z19.array(z19.object({
+    tool: z19.string(),
+    action: z19.string().optional(),
+    timestamp: z19.string(),
+    durationMs: z19.number().optional()
   }))
 });
-var healthWhoamiOutputSchema = z18.object({
-  workspaceId: z18.string(),
-  workspaceName: z18.string(),
-  scope: z18.string(),
-  sessionId: z18.union([z18.string(), z18.null()]),
-  oriented: z18.boolean()
+var healthWhoamiOutputSchema = z19.object({
+  workspaceId: z19.string(),
+  workspaceName: z19.string(),
+  scope: z19.string(),
+  sessionId: z19.union([z19.string(), z19.null()]),
+  oriented: z19.boolean()
 });
 var ALL_TOOL_SCHEMAS = [
   { name: "entries", schema: entriesSchema },
@@ -5262,16 +7010,17 @@ var ALL_TOOL_SCHEMAS = [
   { name: "map-version", schema: mapVersionSchema },
   { name: "map-suggest", schema: mapSuggestSchema },
   { name: "architecture", schema: architectureSchema },
-  { name: "architecture-admin", schema: architectureAdminSchema }
+  { name: "architecture-admin", schema: architectureAdminSchema },
+  { name: "facilitate", schema: facilitateSchema }
 ];
-var selfTestOutputSchema = z18.object({
-  passed: z18.number(),
-  failed: z18.number(),
-  total: z18.number(),
-  results: z18.array(z18.object({
-    tool: z18.string(),
-    valid: z18.boolean(),
-    error: z18.string().optional()
+var selfTestOutputSchema = z19.object({
+  passed: z19.number(),
+  failed: z19.number(),
+  total: z19.number(),
+  results: z19.array(z19.object({
+    tool: z19.string(),
+    valid: z19.boolean(),
+    error: z19.string().optional()
   }))
 });
 function handleSelfTest() {
@@ -5354,6 +7103,12 @@ function registerHealthTools(server) {
     async ({ mode = "full", task } = {}) => {
       const errors = [];
       const agentSessionId = getAgentSessionId();
+      if (isSessionOriented() && mode === "brief" && !task) {
+        return {
+          content: [{ type: "text", text: "Already oriented. Session active, writes unlocked. Use `orient mode='full'` or `orient task='...'` for full context." }],
+          structuredContent: { alreadyOriented: true, sessionId: agentSessionId }
+        };
+      }
       let wsCtx = null;
       try {
         wsCtx = await getWorkspaceContext();
@@ -5624,7 +7379,7 @@ function registerHealthTools(server) {
           const standardsForProtocol = (orientEntries.standards ?? []).map((e) => ({
             entryId: e.entryId,
             name: e.name,
-            description: typeof e.description === "string" ? e.description : void 0
+            description: typeof e.preview === "string" ? e.preview : void 0
           }));
           lines.push(...buildOperatingProtocol(standardsForProtocol));
         }
@@ -6092,12 +7847,12 @@ ${entry.labels.map((l) => `- ${l.name ?? l.slug}`).join("\n")}`);
 }
 
 // src/prompts/index.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 function registerPrompts(server) {
   server.prompt(
     "review-against-rules",
     "Review code or a design decision against all business rules for a given domain. Fetches the rules and asks you to do a structured compliance review.",
-    { domain: z19.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
+    { domain: z20.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
     async ({ domain }) => {
       const entries = await mcpQuery("chain.listEntries", { collectionSlug: "business-rules" });
       const rules = entries.filter((e) => e.data?.domain === domain);
@@ -6150,7 +7905,7 @@ Provide a structured review with a compliance status for each rule (COMPLIANT /
   server.prompt(
     "name-check",
     "Check variable names, field names, or API names against the glossary for terminology alignment. Flags drift from canonical terms.",
-    { names: z19.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
+    { names: z20.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
     async ({ names }) => {
       const terms = await mcpQuery("chain.listEntries", { collectionSlug: "glossary" });
       const glossaryContext = terms.map(
@@ -6186,7 +7941,7 @@ Format as a table: Name | Status | Canonical Form | Action Needed`
   server.prompt(
     "draft-decision-record",
     "Draft a structured decision record from a description of what was decided. Includes context from recent decisions and relevant rules.",
-    { context: z19.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
+    { context: z20.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
     async ({ context }) => {
       const recentDecisions = await mcpQuery("chain.listEntries", { collectionSlug: "decisions" });
       const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
@@ -6224,8 +7979,8 @@ After drafting, I can log it using the capture tool with collection "decisions".
     "draft-rule-from-context",
     "Draft a new business rule from an observation or discovery made while coding. Fetches existing rules for the domain to ensure consistency.",
     {
-      observation: z19.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
-      domain: z19.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
+      observation: z20.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
+      domain: z20.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
     },
     async ({ observation, domain }) => {
       const allRules = await mcpQuery("chain.listEntries", { collectionSlug: "business-rules" });
@@ -6266,10 +8021,10 @@ Make sure the rule is consistent with existing rules and doesn't contradict them
     "run-workflow",
     "Launch a Chainwork workflow (retro, shape, IDM) in Facilitator Mode. Returns the full workflow definition, facilitation instructions, and round structure. The agent enters Facilitator Mode and guides the participant through each round.",
     {
-      workflow: z19.string().describe(
+      workflow: z20.string().describe(
         "Workflow ID to run. Available: " + listWorkflows().map((w) => `'${w.id}' (${w.name})`).join(", ")
       ),
-      context: z19.string().optional().describe(
+      context: z20.string().optional().describe(
         "Optional context from the participant (e.g., 'retro on last sprint', 'shape the Chainwork API bet')"
       )
     },
@@ -6371,11 +8126,52 @@ Description field: ${wf.kbOutputTemplate.descriptionField}
   );
   server.prompt(
     "shape-a-bet",
-    "Choreograph shaping a product bet using the constellation capture pattern. Guides through problem framing, appetite, solution elements, risk identification, boundaries, and constellation capture. Use when the user wants to shape a bet, define a pitch, or scope work using Shape Up methodology.",
+    "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: z19.string().describe("Brief description of the idea or feature to shape (e.g. 'Improve the glossary editing flow')")
+      idea: z20.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?.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.status === "draft" || t.status === "active");
+        if (open.length > 0) {
+          tensionsContext = open.slice(0, 10).map((t) => `- \`${t.entryId ?? "?"}\` ${t.name}`).join("\n");
+        }
+      } catch {
+      }
       return {
         messages: [{
           role: "user",
@@ -6383,56 +8179,98 @@ Description field: ${wf.kbOutputTemplate.descriptionField}
             type: "text",
             text: `# Shape a Bet: ${idea}
 
-You are shaping a product bet using the **constellation capture pattern**. The bet will live on the Chain with connected elements, tensions, and decisions.
+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.
 
-## Prerequisites
-1. **Start session** (if not already): \`session action=start\`
-2. **Orient**: \`orient\` \u2014 loads workspace context and recent activity
+## Your Role (DEC-56 Boundary)
 
-## Shaping Steps (execute in order)
+The **server judges** \u2014 it scores input against 5 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.
 
-### Step 1: Problem Framing
-Discuss the problem with the user. Narrow to a specific, concrete problem statement. Capture the problem in 2\u20133 sentences.
+## Rubric Dimensions (5 scoring criteria)
 
-### Step 2: Set Appetite
-Agree on appetite (e.g. "2 weeks", "6 weeks"). This bounds the solution.
+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. **Risk Coverage** \u2014 rabbit holes named, mitigations or acceptances, codebase-level risks
+5. **Boundary Specification** \u2014 explicit no-gos, each prevents scope creep in a specific direction
 
-### Step 3: Solution Elements
-Identify 3\u20135 solution elements. For each element that is a distinct feature, capture it:
-\`\`\`
-capture collection="features" name="<Element Name>" description="<What this element does>"
-\`\`\`
-Note the entryIds for relation linking.
+## How to Use the Facilitate Tool
 
-### Step 4: Rabbit Holes
-Identify risks. For each risk that is a known tension, capture or link:
-\`\`\`
-capture collection="tensions" name="<Risk>" description="<Risk, patch, mitigation>"
-\`\`\`
-Or link existing tensions.
+### Prerequisites
+1. \`session action=start\` (if not already active)
+2. \`orient\` (loads context and unlocks writes)
 
-### Step 5: No-Gos
-Declare what is out of scope. List explicitly.
+### Session Flow
+1. **Start:** \`facilitate action=start betName="${idea}"\`
+   Creates a draft bet on the Chain. Returns Studio URL and initial coaching prompt.
 
-### Step 6: Constellation Capture
-Capture the bet and connect the constellation:
-\`\`\`
-capture collection="bets" name="<Bet Name>" description="<Problem statement>" data='{"problem":"...","appetite":"...","elements":"...","rabbitHoles":"...","noGos":"..."}'
-\`\`\`
-Then create relations:
-\`\`\`
-relations action=batch-create relations=[
-  {from:"<element-entry-id>",to:"<bet-entry-id>",type:"part_of"},
-  {from:"<tension-entry-id>",to:"<element-or-bet-id>",type:"constrains"},
-  ...
-]
-\`\`\`
-Use \`graph action=suggest entryId="<bet-id>"\` to discover more connections.
+2. **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\`.
+
+3. **Score (anytime):** \`facilitate action=score betEntryId="..."\`
+   Check the scorecard without advancing.
+
+4. **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
 
-### Step 7: Present & Commit
-Show the user the captured bet and constellation. The capture response includes a **View in Studio** link for bets \u2014 share it. Only call \`commit-entry\` when the user confirms.
+` + (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 with Step 1.** Ask the user to describe the problem they want to solve.`
+**Begin now.** Call \`facilitate action=start betName="${idea}"\` and then ask the user to describe the problem.`
           }
         }]
       };
@@ -6442,9 +8280,9 @@ Show the user the captured bet and constellation. The capture response includes
     "capture-and-connect",
     "Guided workflow: capture a knowledge entry, discover graph connections, create relations, and prepare for commit. Encodes the capture \u2192 suggest \u2192 batch-create \u2192 commit choreography as a step-by-step guide.",
     {
-      collection: z19.string().describe("Collection slug (e.g. 'glossary', 'business-rules', 'decisions', 'tensions')"),
-      name: z19.string().describe("Entry name"),
-      description: z19.string().describe("Entry description")
+      collection: z20.string().describe("Collection slug (e.g. 'glossary', 'business-rules', 'decisions', 'tensions')"),
+      name: z20.string().describe("Entry name"),
+      description: z20.string().describe("Entry description")
     },
     async ({ collection, name, description }) => {
       const collections = await mcpQuery("chain.listCollections");
@@ -6498,7 +8336,7 @@ Only call \`commit-entry\` when the user explicitly confirms.
     "deep-dive",
     "Explore everything the Chain knows about a topic or entry. Assembles entry details, graph context, related business rules, and glossary terms into a comprehensive briefing.",
     {
-      topic: z19.string().describe("Entry ID (e.g. 'BR-001') or topic to explore (e.g. 'authentication')")
+      topic: z20.string().describe("Entry ID (e.g. 'BR-001') or topic to explore (e.g. 'authentication')")
     },
     async ({ topic }) => {
       const isEntryId = /^[A-Z]+-\d+$/i.test(topic) || /^[A-Z]+-[a-z0-9]+$/i.test(topic);
@@ -6581,7 +8419,7 @@ ${contextInstructions}`
     "pre-commit-check",
     "Run a readiness check before committing an entry to the Chain. Validates quality score, required relations, and business rule compliance.",
     {
-      entryId: z19.string().describe("Entry ID to check (e.g. 'GT-019', 'DEC-005')")
+      entryId: z20.string().describe("Entry ID to check (e.g. 'GT-019', 'DEC-005')")
     },
     async ({ entryId }) => {
       return {
@@ -6638,7 +8476,7 @@ If ready, ask the user to confirm. If not, suggest specific improvements.
 }
 
 // src/server.ts
-var SERVER_VERSION = "0.7.0";
+var SERVER_VERSION = "0.7.2";
 var INSTRUCTIONS = [
   "Product Brain \u2014 the single source of truth for product knowledge.",
   "Terminology, standards, and core data all live here \u2014 no need to check external docs.",
@@ -6739,6 +8577,7 @@ function createProductBrainServer() {
   if (enabledModules.has("arch")) registerArchitectureTools(server);
   registerStartTools(server);
   registerUsageTools(server);
+  registerFacilitateTools(server);
   registerResources(server);
   registerPrompts(server);
   return server;
@@ -6748,4 +8587,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-THAYIBTL.js.map
+//# sourceMappingURL=chunk-HTL6Y2AO.js.map