@productbrain/mcp 0.0.1-beta.39 → 0.0.1-beta.40

package/dist/{chunk-XCKGFYDP.js → chunk-6WVRGNJU.js}

@@ -25,11 +25,11 @@ import {
   startAgentSession,
   trackWriteTool,
   translateStaleToolNames
-} from "./chunk-7VJP2IMS.js";
+} from "./chunk-M264FY2V.js";
 import {
   trackQualityCheck,
   trackQualityVerdict
-} from "./chunk-TB24VJ4Z.js";
+} from "./chunk-P7ABQEFK.js";
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -85,6 +85,23 @@ function registerKnowledgeTools(server) {
     },
     async ({ entryId, name, status: rawStatus, workflowStatus: rawWorkflowStatus, data, order, canonicalKey, autoPublish, changeNote }) => {
       requireWriteAccess();
+      const PROMOTED_FIELDS = ["status", "workflowStatus", "name", "order", "canonicalKey"];
+      const topLevelByField = { status: rawStatus, workflowStatus: rawWorkflowStatus, name, order, canonicalKey };
+      const confusedFields = [];
+      if (data) {
+        for (const field of PROMOTED_FIELDS) {
+          if (field in data && topLevelByField[field] === void 0) {
+            confusedFields.push(field);
+          }
+        }
+      }
+      const fieldsProvided = [];
+      if (name !== void 0) fieldsProvided.push("name");
+      if (rawStatus !== void 0) fieldsProvided.push("status");
+      if (rawWorkflowStatus !== void 0) fieldsProvided.push("workflowStatus");
+      if (data !== void 0) fieldsProvided.push("data");
+      if (order !== void 0) fieldsProvided.push("order");
+      if (canonicalKey !== void 0) fieldsProvided.push("canonicalKey");
       let status = rawStatus;
       let workflowStatus = rawWorkflowStatus;
       let deprecationWarning;
@@ -120,13 +137,25 @@ function registerKnowledgeTools(server) {
         `Internal ID: ${id}`,
         `**Workspace:** ${wsCtx.workspaceSlug} (${wsCtx.workspaceId})`
       ];
+      if (fieldsProvided.length > 0) {
+        responseLines.push(`**Fields provided:** ${fieldsProvided.join(", ")}`);
+      } else {
+        responseLines.push("");
+        responseLines.push("\u26A0\uFE0F No fields to update were provided \u2014 only `entryId` was set.");
+      }
       if (deprecationWarning) {
         responseLines.push("");
         responseLines.push(deprecationWarning);
       }
+      if (confusedFields.length > 0) {
+        responseLines.push("");
+        for (const field of confusedFields) {
+          responseLines.push(`\u26A0\uFE0F \`data.${field}\` detected \u2014 did you mean the top-level \`${field}\` parameter?`);
+        }
+      }
       return {
         content: [{ type: "text", text: responseLines.join("\n") }],
-        structuredContent: { entryId: id, versionMode }
+        structuredContent: { entryId: id, versionMode, fieldsProvided, confusedFields }
       };
     }
   );
@@ -166,7 +195,7 @@ ${formatted}` }]
     },
     async ({ entryId }) => {
       requireWriteAccess();
-      const { runContradictionCheck } = await import("./smart-capture-E53YEHHO.js");
+      const { runContradictionCheck } = await import("./smart-capture-GH4CXVVX.js");
       const entry = await mcpQuery("chain.getEntry", { entryId });
       if (!entry) {
         return {
@@ -2828,7 +2857,8 @@ var DIMENSIONS = [
   "elements",
   "architecture",
   "risks",
-  "boundaries"
+  "boundaries",
+  "done_when"
 ];
 var DIMENSION_LABELS = {
   problem_clarity: "Problem Clarity",
@@ -2836,7 +2866,8 @@ var DIMENSION_LABELS = {
   elements: "Element Decomposition",
   architecture: "Architecture Grounding",
   risks: "Risk Coverage",
-  boundaries: "Boundary Specification"
+  boundaries: "Boundary Specification",
+  done_when: "Done-When Quality"
 };
 var SUGGESTED_ORDER = [
   "problem_clarity",
@@ -2844,7 +2875,16 @@ var SUGGESTED_ORDER = [
   "elements",
   "architecture",
   "risks",
-  "boundaries"
+  "boundaries",
+  "done_when"
+];
+var PHASE_ORDER = [
+  "context",
+  "framing",
+  "elements",
+  "derisking",
+  "validation",
+  "capture"
 ];
 var PHASE_LABELS = {
   context: "Phase 0: Gather Context",
@@ -2854,18 +2894,39 @@ var PHASE_LABELS = {
   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 contentFloor(content, isSmallBatch) {
+  const hasElements = content.elementCount >= 1;
+  const hasDerisking = content.riskCount >= 1 || content.noGoCount >= 1;
+  const hasArchOrSkipped = isSmallBatch || !!content.hasArchitectureText;
+  const wellShaped = content.elementCount >= 2 && hasDerisking && hasArchOrSkipped;
+  if (wellShaped && content.riskCount >= 1 && content.noGoCount >= 2) return "validation";
+  if (hasDerisking) return "derisking";
+  if (hasElements) return "elements";
+  return "context";
+}
+function laterPhase(a, b) {
+  return PHASE_ORDER.indexOf(a) >= PHASE_ORDER.indexOf(b) ? a : b;
+}
+function inferPhase(scorecard, isSmallBatch = false, content) {
+  let scorePhase;
+  if (scorecard.problem_clarity === 0 && scorecard.appetite === 0) scorePhase = "context";
+  else if (scorecard.problem_clarity < 6 || scorecard.appetite < 6) scorePhase = "framing";
+  else {
+    const archGate = isSmallBatch ? true : scorecard.architecture >= 4;
+    if (scorecard.elements < 6 || !archGate) scorePhase = "elements";
+    else if (scorecard.risks < 6 || scorecard.boundaries < 4 || scorecard.done_when < 4) scorePhase = "derisking";
+    else {
+      const activeDims = activeDimensions(isSmallBatch);
+      const allAboveThreshold = activeDims.every((d) => scorecard[d] >= 4);
+      if (!allAboveThreshold) scorePhase = "derisking";
+      else {
+        const highQuality = activeDims.every((d) => scorecard[d] >= 6);
+        scorePhase = highQuality ? "capture" : "validation";
+      }
+    }
+  }
+  if (!content) return scorePhase;
+  return laterPhase(scorePhase, contentFloor(content, isSmallBatch));
 }
 function activeDimensions(isSmallBatch) {
   return isSmallBatch ? SUGGESTED_ORDER.filter((d) => d !== "architecture") : SUGGESTED_ORDER;
@@ -3007,6 +3068,20 @@ var ARCH_QUALITY_SIGNALS = [
   "decouple",
   "isolat"
 ];
+var DONE_WHEN_SIGNALS = [
+  "done when",
+  "acceptance criteria",
+  "verified",
+  "test plan",
+  "validation",
+  "rollback",
+  "gate",
+  "threshold",
+  "metric",
+  "success",
+  "p95",
+  "p99"
+];
 function countMatches(text, signals) {
   const lower = text.toLowerCase();
   return signals.filter((s) => lower.includes(s)).length;
@@ -3018,20 +3093,27 @@ function scoreProblemClarity(ctx) {
   const text = ctx.dimensionTexts.problem_clarity;
   const missing = [];
   const satisfied = [];
+  const criteria = [];
   let score = 0;
-  if (countMatches(text, WORKAROUND_SIGNALS) > 0) {
+  const hasWorkaround = countMatches(text, WORKAROUND_SIGNALS) > 0;
+  criteria.push({ label: "Current workaround described", met: hasWorkaround, weight: 3 });
+  if (hasWorkaround) {
     satisfied.push("Current workaround described");
     score += 3;
   } else {
     missing.push("Describe the current workaround \u2014 how do people deal with this today?");
   }
-  if (countMatches(text, AFFECTED_SIGNALS) > 0) {
+  const hasAffected = countMatches(text, AFFECTED_SIGNALS) > 0;
+  criteria.push({ label: "Affected people identified", met: hasAffected, weight: 2 });
+  if (hasAffected) {
     satisfied.push("Affected people identified");
     score += 2;
   } else {
     missing.push("Who experiences this problem? Be specific about the role or persona.");
   }
-  if (countMatches(text, FREQUENCY_SIGNALS) > 0) {
+  const hasFrequency = countMatches(text, FREQUENCY_SIGNALS) > 0;
+  criteria.push({ label: "Frequency or severity stated", met: hasFrequency, weight: 2 });
+  if (hasFrequency) {
     satisfied.push("Frequency or severity stated");
     score += 2;
   } else {
@@ -3039,58 +3121,75 @@ function scoreProblemClarity(ctx) {
   }
   if (ctx.existingEntryIds.length > 0) {
     satisfied.push(`Differentiated from ${ctx.existingEntryIds.length} existing entries`);
+    criteria.push({ label: "Differentiated from existing entries", met: true, weight: 2 });
     score += 2;
   } else if (/\b(TEN|DEC|ENT|FEAT|BET)-\w+/i.test(text)) {
     satisfied.push("References existing Chain entries");
+    criteria.push({ label: "References existing Chain entries", met: true, weight: 1 });
     score += 1;
   } else {
     missing.push("How does this differ from existing tensions or bets on the Chain?");
+    criteria.push({ label: "Differentiated from existing entries", met: false, weight: 2 });
   }
-  if (text.length > 200) {
+  const isSubstantive = text.length > 200;
+  criteria.push({ label: "Substantive description provided", met: isSubstantive, weight: 1 });
+  if (isSubstantive) {
     satisfied.push("Substantive description provided");
     score += 1;
   }
-  return { score: clamp(score, 0, 10), missing, satisfied };
+  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
 }
 function scoreAppetite(ctx) {
   const text = ctx.dimensionTexts.appetite;
   const missing = [];
   const satisfied = [];
+  const criteria = [];
   let score = 0;
   const hasSizeDecl = /small\s*batch|big\s*batch|[1-6]\s*week/i.test(text);
   const hasTimeSignals = countMatches(text, APPETITE_SIGNALS) > 0;
   if (hasSizeDecl) {
     satisfied.push("Size and timeframe declared");
+    criteria.push({ label: "Size and timeframe declared", met: true, weight: 4 });
     score += 4;
   } else if (hasTimeSignals) {
     satisfied.push("Time constraint mentioned");
+    criteria.push({ label: "Size and timeframe declared", met: false, weight: 4 });
+    criteria.push({ label: "Time constraint mentioned", met: true, weight: 2 });
     score += 2;
     missing.push("Declare the batch size explicitly \u2014 Small Batch (1-2 weeks) or Big Batch (6 weeks).");
   } else {
+    criteria.push({ label: "Size and timeframe declared", met: false, weight: 4 });
     missing.push("Set a time constraint \u2014 how long is this bet allowed to take?");
   }
-  if (countMatches(text, SCOPE_SIGNALS) > 0) {
+  const hasTradeoffs = countMatches(text, SCOPE_SIGNALS) > 0;
+  criteria.push({ label: "Scope bounded with trade-offs", met: hasTradeoffs, weight: 2 });
+  if (hasTradeoffs) {
     satisfied.push("Scope bounded with trade-offs");
     score += 2;
   } else {
     missing.push("What trade-offs are you making? What's the 80% cut?");
   }
-  if (/phase\s*[a-c1-3]|phased|milestone/i.test(text)) {
+  const hasPhased = /phase\s*[a-c1-3]|phased|milestone/i.test(text);
+  criteria.push({ label: "Phased delivery strategy", met: hasPhased, weight: 2 });
+  if (hasPhased) {
     satisfied.push("Phased delivery strategy");
     score += 2;
   }
-  if (/gate|validate|dogfood|benchmark|circuit.?breaker/i.test(text)) {
+  const hasGate = /gate|validate|dogfood|benchmark|circuit.?breaker/i.test(text);
+  criteria.push({ label: "Validation gate defined", met: hasGate, weight: 2 });
+  if (hasGate) {
     satisfied.push("Validation gate defined");
     score += 2;
   } else {
     missing.push("How will you know if this bet is working before full commitment?");
   }
-  return { score: clamp(score, 0, 10), missing, satisfied };
+  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
 }
 function scoreElements(ctx) {
   const text = ctx.dimensionTexts.elements;
   const missing = [];
   const satisfied = [];
+  const criteria = [];
   let score = 0;
   const headingCount = (text.match(/###\s*Element\s*\d/gi) ?? []).length;
   const inlineCount = (text.match(/element\s*\d|component\s*\d|piece\s*\d/gi) ?? []).length;
@@ -3098,52 +3197,76 @@ function scoreElements(ctx) {
   const numberedCount = (text.match(/^\s*\d+[.)]\s/gm) ?? []).length;
   const namedCount = (text.match(/\belement\s+\d|[A-Z][a-z]+ (?:Engine|Store|Gate|Manager|Service|Module|Handler|Layer|Registry|Pipeline)\b/g) ?? []).length;
   const textDescribed = Math.max(headingCount, inlineCount, ordinalCount, numberedCount, namedCount);
+  let elemMet = true;
+  let elemWeight = 0;
   if (ctx.elementCount >= 3) {
     satisfied.push(`${ctx.elementCount} elements captured on Chain`);
+    elemWeight = 5;
     score += 5;
   } else if (ctx.elementCount > 0) {
     satisfied.push(`${ctx.elementCount} element(s) captured`);
+    elemWeight = ctx.elementCount * 2;
     score += ctx.elementCount * 2;
     if (ctx.elementCount < 3) {
       missing.push(`Identify ${3 - ctx.elementCount} more solution elements for adequate decomposition.`);
     }
   } else if (textDescribed >= 3) {
     satisfied.push(`${textDescribed} elements described in text`);
+    elemWeight = 4;
     score += 4;
     missing.push("Capture these elements as typed entries on the Chain.");
   } else if (textDescribed > 0) {
     satisfied.push(`${textDescribed} element(s) described in text`);
+    elemWeight = textDescribed * 2;
     score += textDescribed * 2;
     missing.push("Identify more solution elements \u2014 aim for 3+ independently describable pieces.");
   } else {
+    elemMet = false;
+    elemWeight = 5;
     missing.push("Identify solution elements \u2014 breadboard-level pieces, each independently describable.");
   }
+  criteria.push({ label: "Solution elements identified", met: elemMet, weight: elemWeight });
   const totalElements = Math.max(ctx.elementCount, textDescribed);
+  const decompMet = totalElements >= 2;
+  let decompWeight;
   if (totalElements >= 3) {
     satisfied.push("Multiple independently describable pieces");
+    decompWeight = 3;
     score += 3;
   } else if (totalElements >= 2) {
     satisfied.push("Multiple independently describable pieces");
+    decompWeight = 2;
     score += 2;
+  } else {
+    decompWeight = 3;
   }
-  if (ctx.governanceCount > 0) {
+  criteria.push({ label: "Adequate decomposition (3+ pieces)", met: decompMet, weight: decompWeight });
+  const govMet = ctx.governanceCount > 0;
+  criteria.push({ label: "Governance constraints applied", met: govMet, weight: 1 });
+  if (govMet) {
     satisfied.push(`${ctx.governanceCount} governance entries constrain the solution`);
     score += 1;
   }
-  return { score: clamp(score, 0, 10), missing, satisfied };
+  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
 }
 function scoreArchitecture(ctx) {
   const text = ctx.dimensionTexts.architecture;
   const missing = [];
   const satisfied = [];
+  const criteria = [];
   let score = 0;
-  if (ctx.hasArchitectureText) {
+  const hasArchSection = ctx.hasArchitectureText;
+  criteria.push({ label: "Architecture section present", met: hasArchSection, weight: 3 });
+  if (hasArchSection) {
     satisfied.push("Architecture section present in bet");
     score += 3;
   } else {
     missing.push("Where does this live in the architecture? Name each layer and what belongs where.");
   }
   const archSignals = countMatches(text, ARCHITECTURE_SIGNALS);
+  const archVocabMet = archSignals > 0;
+  const archVocabWeight = archSignals >= 3 ? 2 : archSignals > 0 ? 1 : 2;
+  criteria.push({ label: "Architecture vocabulary used", met: archVocabMet, weight: archVocabWeight });
   if (archSignals >= 3) {
     satisfied.push("Architecture vocabulary used");
     score += 2;
@@ -3152,101 +3275,181 @@ function scoreArchitecture(ctx) {
   } else {
     missing.push("Describe the API boundary, modules, and services involved.");
   }
-  if (countMatches(text, ARCH_QUALITY_SIGNALS) > 0) {
+  const hasDependencyDir = countMatches(text, ARCH_QUALITY_SIGNALS) > 0;
+  criteria.push({ label: "Dependency direction specified", met: hasDependencyDir, weight: 2 });
+  if (hasDependencyDir) {
     satisfied.push("Dependency direction / boundaries specified");
     score += 2;
   } else {
     missing.push("What dependencies does this create or remove? Specify direction.");
   }
-  if (/mermaid|diagram|flowchart|graph/i.test(text)) {
+  const hasDiagram = /mermaid|diagram|flowchart|graph/i.test(text);
+  criteria.push({ label: "Visual architecture diagram", met: hasDiagram, weight: 2 });
+  if (hasDiagram) {
     satisfied.push("Visual architecture representation");
     score += 2;
   } else {
     missing.push("Add an architecture diagram (Mermaid) showing layers and data flow.");
   }
-  if (ctx.governanceCount > 0) {
+  const govMet = ctx.governanceCount > 0;
+  criteria.push({ label: "Checked against governance", met: govMet, weight: 1 });
+  if (govMet) {
     satisfied.push("Architecture checked against governance");
     score += 1;
   }
-  return { score: clamp(score, 0, 10), missing, satisfied };
+  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
 }
 function scoreRisks(ctx) {
   const text = ctx.dimensionTexts.risks;
   const missing = [];
   const satisfied = [];
+  const criteria = [];
   let score = 0;
   const riskSignalCount = countMatches(text, RISK_SIGNALS);
   const textRiskCount = (text.match(/rabbit hole|risk:|risk \d|R\d:/gi) ?? []).length;
   const totalRisks = Math.max(ctx.riskCount, textRiskCount, Math.min(riskSignalCount, 3));
+  let riskMet = true;
+  let riskWeight = 0;
   if (ctx.riskCount >= 2) {
     satisfied.push(`${ctx.riskCount} risks captured on Chain`);
+    riskWeight = 4;
     score += 4;
   } else if (totalRisks >= 2) {
     satisfied.push(`${totalRisks} risks identified`);
+    riskWeight = 3;
     score += 3;
     if (ctx.riskCount === 0) missing.push("Capture identified risks as entries on the Chain.");
   } else if (totalRisks > 0 || riskSignalCount > 0) {
     satisfied.push("Risk language present");
+    riskWeight = 2;
     score += 2;
     missing.push("Identify more risks \u2014 aim for 2+ rabbit holes with mitigations.");
   } else {
+    riskMet = false;
+    riskWeight = 4;
     missing.push("Name the rabbit holes \u2014 what could go wrong, what's unknown?");
   }
+  criteria.push({ label: "Risks identified", met: riskMet, weight: riskWeight });
   const mitigationCount = countMatches(text, MITIGATION_SIGNALS);
+  let mitigMet = mitigationCount > 0;
+  let mitigWeight;
   if (mitigationCount >= 2) {
     satisfied.push("Multiple mitigations specified");
+    mitigWeight = 3;
     score += 3;
   } else if (mitigationCount > 0) {
     satisfied.push("Mitigation present");
+    mitigWeight = 2;
     score += 2;
     missing.push("Each risk should have a mitigation or explicit acceptance.");
   } else {
+    mitigMet = false;
+    mitigWeight = 3;
     missing.push("Each risk needs a mitigation or explicit acceptance.");
   }
-  if (/codebase|architecture|coupling|dependency|schema|migration/i.test(text)) {
+  criteria.push({ label: "Mitigations specified", met: mitigMet, weight: mitigWeight });
+  const hasCodebaseRisks = /codebase|architecture|coupling|dependency|schema|migration/i.test(text);
+  criteria.push({ label: "Codebase-level risks identified", met: hasCodebaseRisks, weight: 2 });
+  if (hasCodebaseRisks) {
     satisfied.push("Codebase-level risks identified");
     score += 2;
   } else {
     missing.push("Are there high-risk areas in the codebase? Check architecture and dependencies.");
   }
-  if (totalRisks >= 3) {
+  const thorough = totalRisks >= 3;
+  criteria.push({ label: "Thorough risk coverage", met: thorough, weight: 1 });
+  if (thorough) {
     satisfied.push("Thorough risk coverage");
     score += 1;
   }
-  return { score: clamp(score, 0, 10), missing, satisfied };
+  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
 }
 function scoreBoundaries(ctx) {
   const text = ctx.dimensionTexts.boundaries;
   const missing = [];
   const satisfied = [];
+  const criteria = [];
   let score = 0;
   const textNoGos = Math.max(countMatches(text, NOGO_SIGNALS), (text.match(/\bwon'?t\b|\bwill not\b/gi) ?? []).length);
-  const totalNoGos = Math.min(ctx.noGoCount + textNoGos, 10);
+  const totalNoGos = Math.max(ctx.noGoCount, textNoGos);
+  let nogoMet = totalNoGos > 0;
+  let nogoWeight;
   if (totalNoGos >= 3) {
     satisfied.push(`${totalNoGos} explicit no-gos declared`);
+    nogoWeight = 5;
     score += 5;
   } else if (totalNoGos > 0) {
     satisfied.push(`${totalNoGos} no-go(s) declared`);
+    nogoWeight = totalNoGos * 2;
     score += totalNoGos * 2;
     missing.push("Add more explicit no-gos to prevent scope creep.");
   } else {
+    nogoMet = false;
+    nogoWeight = 5;
     missing.push("Declare what you're NOT building \u2014 explicit no-gos prevent scope creep.");
   }
-  if (/scope creep|prevent|boundary|limit|constrain|excluded/i.test(text)) {
+  criteria.push({ label: "No-gos declared", met: nogoMet, weight: nogoWeight });
+  const hasScopeCreep = /scope creep|prevent|boundary|limit|constrain|excluded/i.test(text);
+  criteria.push({ label: "Scope creep prevention language", met: hasScopeCreep, weight: 2 });
+  if (hasScopeCreep) {
     satisfied.push("Scope creep prevention language");
     score += 2;
   }
-  if (/direction|instead.*will|rather.*than|not.*but/i.test(text)) {
+  const hasDirectional = /direction|instead.*will|rather.*than|not.*but/i.test(text);
+  criteria.push({ label: "Directional no-gos", met: hasDirectional, weight: 2 });
+  if (hasDirectional) {
     satisfied.push("Each no-go prevents scope creep in a specific direction");
     score += 2;
   } else if (totalNoGos > 0) {
     missing.push("Each no-go should prevent scope creep in a specific direction.");
   }
-  if (totalNoGos >= 5) {
+  const comprehensive = totalNoGos >= 5;
+  criteria.push({ label: "Comprehensive boundary specification", met: comprehensive, weight: 1 });
+  if (comprehensive) {
     satisfied.push("Comprehensive boundary specification");
     score += 1;
   }
-  return { score: clamp(score, 0, 10), missing, satisfied };
+  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
+}
+function scoreDoneWhen(ctx) {
+  const text = ctx.dimensionTexts.done_when ?? "";
+  const missing = [];
+  const satisfied = [];
+  const criteria = [];
+  let score = 0;
+  const hasSection = text.trim().length > 0;
+  criteria.push({ label: "Done-when section present", met: hasSection, weight: 3 });
+  if (hasSection) {
+    satisfied.push("Done-when section present");
+    score += 3;
+  } else {
+    missing.push("Define explicit done-when criteria.");
+  }
+  const hasMeasurableTargets = /\b\d+%|\bp\d{2}|\b>=?\s*\d+|\b<=?\s*\d+|target|threshold|SLO|SLA|median/i.test(text);
+  criteria.push({ label: "Measurable targets defined", met: hasMeasurableTargets, weight: 3 });
+  if (hasMeasurableTargets) {
+    satisfied.push("Measurable targets defined");
+    score += 3;
+  } else if (hasSection) {
+    missing.push("Add measurable targets (thresholds, percentages, latency targets, or numeric criteria).");
+  }
+  const hasValidationPlan = /\btest|verify|validation|contract test|rollback|drill|gate/i.test(text);
+  criteria.push({ label: "Validation plan specified", met: hasValidationPlan, weight: 2 });
+  if (hasValidationPlan) {
+    satisfied.push("Validation plan specified");
+    score += 2;
+  } else if (hasSection) {
+    missing.push("Specify how success will be validated (tests, gates, rollback drills).");
+  }
+  const hasSignals = countMatches(text, DONE_WHEN_SIGNALS) >= 3;
+  criteria.push({ label: "Operational signal coverage", met: hasSignals, weight: 2 });
+  if (hasSignals) {
+    satisfied.push("Operational signal coverage");
+    score += 2;
+  } else if (hasSection) {
+    missing.push("Include operational signals (metrics, gates, and release thresholds).");
+  }
+  return { score: clamp(score, 0, 10), missing, satisfied, criteria };
 }
 var SCORERS = {
   problem_clarity: scoreProblemClarity,
@@ -3254,7 +3457,8 @@ var SCORERS = {
   elements: scoreElements,
   architecture: scoreArchitecture,
   risks: scoreRisks,
-  boundaries: scoreBoundaries
+  boundaries: scoreBoundaries,
+  done_when: scoreDoneWhen
 };
 function scoreDimension(dimension, ctx) {
   const raw = SCORERS[dimension](ctx);
@@ -3281,9 +3485,27 @@ function buildScorecard(ctx) {
     elements: results.elements.score,
     architecture: results.architecture.score,
     risks: results.risks.score,
-    boundaries: results.boundaries.score
+    boundaries: results.boundaries.score,
+    done_when: results.done_when.score
   };
 }
+function buildDetailedScorecard(ctx, opts) {
+  const results = scoreAll(ctx);
+  const scorecard = {};
+  const criteria = {};
+  for (const dim of DIMENSIONS) {
+    scorecard[dim] = results[dim].score;
+    criteria[dim] = results[dim].criteria;
+  }
+  if (opts?.isSmallBatch) scorecard.architecture = -1;
+  return { scorecard, criteria };
+}
+function isCaptureReady(scorecard, isSmallBatch) {
+  const completed = completedDimensions(scorecard, 6, isSmallBatch);
+  const dims = activeDimensions(isSmallBatch);
+  const ready = completed.length >= (isSmallBatch ? 5 : 6) && dims.every((d) => scorecard[d] >= 4);
+  return { ready, completed };
+}
 function inferActiveDimension(scorecard, isSmallBatch = false) {
   const order = activeDimensions(isSmallBatch);
   const firstZero = order.find((d) => scorecard[d] === 0);
@@ -3358,45 +3580,51 @@ function extractPhrase(text, maxLen) {
 function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
+function isBalanced(text) {
+  const opens = (text.match(/[("']/g) ?? []).length;
+  const closes = (text.match(/[)"']/g) ?? []).length;
+  return Math.abs(opens - closes) <= 1;
+}
 var PHASE_INVESTIGATIONS = {
-  context: (betName) => ({
+  context: (searchTerm) => ({
     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: `Search for entries related to: ${searchTerm}`, purpose: "Find existing tensions, decisions, and bets that overlap" },
       { target: "chain", query: "List active governance: principles, standards, business-rules", purpose: "Surface constraints the solution must honor" },
-      { target: "codebase", query: `Search for code related to: ${betName}`, purpose: "Understand current implementation and pain points" }
+      { target: "codebase", query: `Search for code related to: ${searchTerm}`, purpose: "Understand current implementation and pain points" }
     ],
     proposalGuidance: "Synthesize findings into a 3-5 line context brief: what the Chain knows, what the codebase reveals, what governance applies.",
     reactionPrompt: "Here's what I found. Does this match what you're seeing, or is the problem different from what the Chain suggests?"
   }),
-  framing: (betName) => ({
+  framing: (searchTerm) => ({
     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" }
+      { target: "codebase", query: `Find workarounds, TODOs, or hacks related to: ${searchTerm}`, purpose: "Surface concrete evidence of the problem" },
+      { target: "chain", query: `Search for tensions related to: ${searchTerm}`, purpose: "Quantify how often this problem occurs" }
     ],
     proposalGuidance: "Propose a problem statement based on codebase evidence. Include who's affected and what the workaround looks like in the code.",
     reactionPrompt: "Based on the codebase, here's a draft problem statement. Does this capture it, or is the real problem different?"
   }),
-  elements: (betName) => ({
+  elements: (searchTerm, _betEntryId, elementNames) => ({
     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: "codebase", query: `Find modules, services, and components that would be affected by: ${searchTerm}`, purpose: "Map the solution to existing architecture" },
+      ...elementNames?.length ? [{ target: "codebase", query: `Locate existing code paths for these elements: ${elementNames.join(", ")}`, purpose: "Ground each proposed element in current implementation" }] : [],
       { target: "architecture", query: "Identify layer boundaries, API contracts, and dependency directions", purpose: "Ground elements in real architecture" },
       { target: "chain", query: "Check DEC-31, STA-3, and other architecture standards", purpose: "Ensure elements respect existing decisions" }
     ],
     proposalGuidance: "Propose 3-5 solution elements at breadboard level. Each element should name the layer it lives in, what it does, and how it connects to existing code.",
     reactionPrompt: "I've mapped out these solution elements based on the codebase. Which feel right? Which need adjustment?"
   }),
-  derisking: (betName) => ({
+  derisking: (searchTerm, _betEntryId, elementNames) => ({
     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: "codebase", query: `Find fragile code, tight coupling, or missing tests near: ${searchTerm}`, purpose: "Surface technical risks from code" },
+      ...elementNames?.length ? [{ target: "codebase", query: `Check implementation complexity for: ${elementNames.join(", ")}`, purpose: "Assess element-specific risks" }] : [{ target: "codebase", query: "Check for performance-sensitive paths, database queries, and external dependencies", purpose: "Identify performance and reliability risks" }],
       { target: "chain", query: "Search for related tensions and past decisions that constrain this solution", purpose: "Surface risks from existing constraints" }
     ],
     proposalGuidance: "Propose rabbit holes with severity and mitigations. Each risk should cite specific code or Chain evidence. Also propose no-gos \u2014 what should be explicitly excluded.",
@@ -3405,9 +3633,10 @@ var PHASE_INVESTIGATIONS = {
   validation: () => null,
   capture: () => null
 };
-function buildInvestigationBrief(phase, betName, betEntryId) {
+function buildInvestigationBrief(phase, betName, betEntryId, betProblem, elementNames) {
+  const searchTerm = betProblem?.slice(0, 200) || betName;
   const builder = PHASE_INVESTIGATIONS[phase];
-  return builder(betName, betEntryId);
+  return builder(searchTerm, betEntryId, elementNames);
 }
 function generateBuildContract(ctx) {
   const lines = ["## Build Contract"];
@@ -3438,7 +3667,65 @@ function generateBuildContract(ctx) {
   return lines.join("\n");
 }
 
+// src/tools/facilitate-validation.ts
+function computeCommitBlockers(opts) {
+  const { betEntryId, relations, betData, sessionDrafts } = opts;
+  const blockers = [];
+  const str = (key) => (betData[key] ?? "").trim();
+  const hasStrategyLink = relations.some((r) => r.type === "commits_to");
+  if (!hasStrategyLink) {
+    blockers.push({
+      entryId: betEntryId,
+      blocker: "Missing strategy link",
+      fix: `relations action=create from=${betEntryId} to=<strategy> type=commits_to`
+    });
+  }
+  const MIN_FIELD_LENGTH = 20;
+  if (str("problem").length < MIN_FIELD_LENGTH) {
+    blockers.push({
+      entryId: betEntryId,
+      blocker: str("problem") ? "Problem statement too short (< 20 chars)" : "Missing problem statement",
+      fix: `update-entry entryId="${betEntryId}" data.problem="<problem description>"`
+    });
+  }
+  if (!str("appetite")) {
+    blockers.push({
+      entryId: betEntryId,
+      blocker: "Missing appetite",
+      fix: `update-entry entryId="${betEntryId}" data.appetite="<appetite declaration>"`
+    });
+  }
+  if (str("elements").length < MIN_FIELD_LENGTH) {
+    blockers.push({
+      entryId: betEntryId,
+      blocker: str("elements") ? "Solution elements too short (< 20 chars)" : "Missing solution elements",
+      fix: `facilitate action=respond betEntryId="${betEntryId}" dimension="elements"`
+    });
+  }
+  const hasFeatures = sessionDrafts.some((d) => d.collection === "features");
+  if (!hasFeatures && str("elements").length >= MIN_FIELD_LENGTH) {
+    blockers.push({
+      entryId: betEntryId,
+      blocker: "Elements described but no feature entries linked in constellation",
+      fix: `facilitate action=respond betEntryId="${betEntryId}" capture={type:"element", name:"...", description:"..."}`
+    });
+  }
+  for (const draft of sessionDrafts) {
+    if (!draft.name || draft.name.trim().length === 0) {
+      blockers.push({
+        entryId: betEntryId,
+        blocker: `Draft constellation entry is missing a name`,
+        fix: `update-entry entryId="<draftId>" name="<name>"`
+      });
+    }
+  }
+  return blockers;
+}
+
 // src/tools/facilitate-format.ts
+function formatCriteriaLine(criteria) {
+  return criteria.map((c) => `${c.met ? "\u2713" : "\u25CB"} ${c.label} (${c.weight}pt)`).join(" \xB7 ");
+}
 function appendElement(existing, element) {
   const existingCount = (existing?.match(/###\s*Element\s*\d/gi) ?? []).length;
   const num = existingCount + 1;
@@ -3470,30 +3757,35 @@ ${line}` : line;
 }
 
 // src/tools/facilitate.ts
-var FACILITATE_ACTIONS = ["start", "respond", "score", "resume"];
+var FACILITATE_ACTIONS = ["start", "respond", "score", "resume", "commit-constellation"];
+var captureItemSchema = z12.object({
+  type: z12.enum(["element", "risk", "noGo", "decision"]).describe("What to capture"),
+  name: z12.string().describe("Entry name"),
+  description: z12.string().describe("Entry description"),
+  theme: z12.string().optional().describe("Risk theme (for risk type)")
+});
 var 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."
+    "'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. 'commit-constellation': atomically commit a bet and all its linked draft entries in one call. Requires betEntryId."
   ),
   sessionType: z12.enum(["shape"]).default("shape").optional().describe("Session type. Only 'shape' in v1."),
-  betEntryId: z12.string().optional().describe("Bet entry ID for resume action."),
+  betEntryId: z12.string().optional().describe("Bet entry ID. Required for resume/score. For respond: omit on first call after start (entry created automatically); required for subsequent calls."),
+  operationId: z12.string().optional().describe("Optional idempotency key for commit-constellation retries."),
   userInput: z12.string().optional().describe("User's input text for respond action."),
   dimension: z12.string().optional().describe("Explicit dimension to score against (e.g. 'problem_clarity'). If omitted, inferred from scorecard."),
   betName: z12.string().optional().describe("Name for the bet (used in start action)."),
   source: z12.enum(["user", "agent_proposal", "user_reaction"]).default("user").optional().describe("ENT-59: Source of the input text. 'user' = typed by user (default, full score weight). 'agent_proposal' = agent-generated proposal (discounted score). 'user_reaction' = user reacting to agent proposal (full weight)."),
-  capture: z12.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.")
+  capture: z12.union([
+    captureItemSchema,
+    z12.array(captureItemSchema).max(15)
+  ]).optional().describe("Entry or entries to capture alongside the respond action. Accepts a single object or an array (max 15) for batch capture.")
 });
 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.",
+      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 7 shaping rubrics (problem, appetite, elements, architecture, risks, boundaries, done-when), searches for overlap, captures to Chain, returns structured coaching response with phase tracking.\n- **score**: Return the current scorecard without advancing the session.\n- **resume**: Reconstruct session state from an existing bet entry on the Chain.\n- **commit-constellation**: Atomically commit a bet and all its linked draft entries (features, tensions, decisions) in one call. Validates strategy link and required fields before committing anything. Replaces 9-13 sequential commit-entry calls.\n\nThe structured response separates judgment (server) from coaching (agent) per DEC-56. Read the phase, scorecard, and coaching fields to determine what to say next. When captureReady is true, buildContract is auto-generated from Chain governance.",
       inputSchema: facilitateSchema,
       annotations: {
         readOnlyHint: false,
@@ -3521,6 +3813,8 @@ function registerFacilitateTools(server) {
             return handleScore(parsed.data);
           case "resume":
             return handleResume(parsed.data);
+          case "commit-constellation":
+            return handleCommitConstellation(parsed.data);
           default:
             return {
               content: [{
@@ -3587,7 +3881,7 @@ function buildDirective(scorecard, phase, betEntryId, captureReady, activeDimens
       `2. **Review** \u2014 show the full pitch first`,
       `3. **Keep as draft** \u2014 not ready yet`,
       ``,
-      `If Commit: call \`commit-entry entryId="${b}"\`.`,
+      `If Commit: call \`facilitate action=commit-constellation betEntryId="${b}"\` to publish the bet and all linked entries in one call.`,
       `If Review: call \`facilitate action=score betEntryId="${b}"\` for the detailed view.`,
       `If Draft: acknowledge and end the session.`
     ].join("\n");
@@ -3614,14 +3908,29 @@ function buildDirective(scorecard, phase, betEntryId, captureReady, activeDimens
   return null;
 }
 function emptyScorecard() {
-  return { problem_clarity: 0, appetite: 0, elements: 0, architecture: 0, risks: 0, boundaries: 0 };
+  return { problem_clarity: 0, appetite: 0, elements: 0, architecture: 0, risks: 0, boundaries: 0, done_when: 0 };
 }
 function detectSmallBatch(appetiteText) {
   if (!appetiteText) return false;
   return /small\s*batch|1[-–]2\s*week|2[-–]week|one.?week|two.?week/i.test(appetiteText);
 }
+function buildCachedScoringContext(betData, constellation) {
+  const cachedOverlapIds = typeof betData._overlapIds === "string" ? betData._overlapIds.split(",").filter((id) => id && id !== "_checked") : [];
+  const cachedGovCount = typeof betData._governanceCount === "number" ? betData._governanceCount : 0;
+  const syntheticChainSurfaced = Array.from({ length: cachedGovCount }, () => ({ collection: "principles" }));
+  return buildScoringContext("", betData, constellation, cachedOverlapIds, syntheticChainSurfaced);
+}
+function extractContentEvidence(ctx) {
+  return {
+    elementCount: ctx.elementCount,
+    riskCount: ctx.riskCount,
+    noGoCount: ctx.noGoCount,
+    hasArchitectureText: ctx.hasArchitectureText
+  };
+}
 function emptyResponse(betEntryId, studioUrl) {
   return {
+    version: 2,
     phase: "context",
     phaseLabel: PHASE_LABELS.context,
     scorecard: emptyScorecard(),
@@ -3632,7 +3941,7 @@ function emptyResponse(betEntryId, studioUrl) {
     sessionDrafts: [],
     coaching: {
       observation: "New shaping session started",
-      missing: ["Problem statement", "Appetite", "Solution elements", "Architecture", "Risks", "Boundaries"],
+      missing: ["Problem statement", "Appetite", "Solution elements", "Architecture", "Risks", "Boundaries", "Done-when criteria"],
       pushback: "",
       suggestedQuestion: "Describe the problem you want to solve. Who's affected? What's the workaround today?",
       captureReady: false,
@@ -3701,7 +4010,8 @@ async function loadSessionDrafts(betEntryId, betInternalId) {
             entryId: entry.entryId,
             name: entry.name,
             collection: RELATION_TO_COLLECTION[rel.type] ?? "unknown",
-            relationType: rel.type
+            relationType: rel.type,
+            status: entry.status ?? "draft"
           });
         }
       } catch {
@@ -3712,7 +4022,7 @@ async function loadSessionDrafts(betEntryId, betInternalId) {
     return [];
   }
 }
-function buildScoringContext(userInput, betData, constellation, overlapIds, chainSurfaced = [], activeDimension, source = "user") {
+function buildScoringContext(userInput, betData, constellation, overlapIds, chainResults = [], activeDimension, source = "user") {
   const str = (key) => betData[key] ?? "";
   const accParts = [
     str("problem"),
@@ -3721,16 +4031,17 @@ function buildScoringContext(userInput, betData, constellation, overlapIds, chai
     str("architecture"),
     str("rabbitHoles"),
     str("noGos"),
+    str("done_when"),
+    str("doneWhen"),
     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 noGoCount = (noGoText.match(/^- \*\*/gm) ?? []).length;
+  const elementsText = str("elements");
+  const elementHeaderCount = (elementsText.match(/###\s*Element\s*\d/gi) ?? []).length;
   const governanceCollections = /* @__PURE__ */ new Set(["principles", "standards", "business-rules"]);
-  const governanceCount = chainSurfaced.filter((e) => governanceCollections.has(e.collection)).length;
+  const governanceCount = chainResults.filter((e) => governanceCollections.has(e.collection)).length;
   const hasArchitectureText = str("architecture").length > 20;
   const join2 = (...parts) => parts.filter(Boolean).join("\n\n");
   const inputFor = (dim) => activeDimension === dim ? userInput : "";
@@ -3740,14 +4051,15 @@ function buildScoringContext(userInput, betData, constellation, overlapIds, chai
     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"))
+    boundaries: join2(str("noGos"), inputFor("boundaries")),
+    done_when: join2(str("done_when"), str("doneWhen"), inputFor("done_when"))
   };
   return {
     userInput,
     accumulatedText: accParts.filter(Boolean).join("\n\n"),
     dimensionTexts,
     existingEntryIds: overlapIds,
-    elementCount: constellation.elementCount,
+    elementCount: Math.max(constellation.elementCount, elementHeaderCount),
     riskCount: constellation.riskCount,
     noGoCount,
     governanceCount,
@@ -3756,34 +4068,19 @@ function buildScoringContext(userInput, betData, constellation, overlapIds, chai
     source
   };
 }
-async function searchOverlap(text) {
-  if (text.length < 20) return [];
-  const query = text.slice(0, 200);
+async function searchChain(text, opts = {}) {
+  const { maxResults = 8, excludeIds = [] } = opts;
+  if (text.length < 10) return [];
+  const query = text.slice(0, 300);
   try {
     const results = await mcpQuery(
       "chain.searchEntries",
       { query }
     );
-    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) => ({
+    const excluded = new Set(excludeIds);
+    return (results ?? []).filter((e) => e.entryId && !excluded.has(e.entryId)).slice(0, maxResults).map((e) => ({
       entryId: e.entryId,
-      relevance: e.name,
+      name: e.name,
       collection: e.collectionSlug ?? "unknown"
     }));
   } catch {
@@ -3817,7 +4114,6 @@ async function findAndLinkExisting(name, collectionSlug, betEntryId, relationTyp
 }
 async function handleStart2(args) {
   requireWriteAccess();
-  const wsCtx = await getWorkspaceContext();
   const betName = args.betName ?? "Untitled Bet (Shaping)";
   let orientContext = "";
   try {
@@ -3834,58 +4130,20 @@ async function handleStart2(args) {
   } 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);
+  const investigationBrief = buildInvestigationBrief("context", betName, "pending");
+  const response = emptyResponse("pending", "");
   if (investigationBrief) {
     response.investigationBrief = investigationBrief;
   }
   const output = [
     `# Shaping Session Started`,
     "",
-    `**Bet:** ${betName} (\`${betEntryId}\`)`,
-    `**Studio:** ${studioUrl}`,
+    `**Bet:** ${betName} (draft entry will be created when you describe the problem)`,
     `**Phase:** ${PHASE_LABELS.context}`,
     "",
     orientContext ? `**Workspace context:** ${orientContext}` : "",
     "",
-    "Session is active. The bet exists as a draft on the Chain.",
+    "No entry created yet \u2014 the bet will be saved to the Chain once you describe the problem.",
     "",
     "---",
     "## Agent Directive",
@@ -3894,7 +4152,8 @@ async function handleStart2(args) {
     "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.`
+    `After the user responds, call \`facilitate action=respond betName="${betName}" dimension="problem_clarity"\` with their answer as userInput.`,
+    `Note: pass betName (not betEntryId) \u2014 the entry will be created on the first respond call.`
   ].filter(Boolean).join("\n");
   return {
     content: [{ type: "text", text: output }],
@@ -3903,163 +4162,212 @@ async function handleStart2(args) {
 }
 async function handleRespond(args) {
   requireWriteAccess();
-  const { userInput, betEntryId: argBetId, dimension: argDimension, capture: captureArg, source: argSource } = args;
+  const { userInput, betEntryId: argBetId, dimension: argDimension, capture: rawCapture, source: argSource, betName: argBetName } = args;
   const source = argSource ?? "user";
+  const captureItems = rawCapture ? Array.isArray(rawCapture) ? rawCapture : [rawCapture] : [];
   if (!userInput) {
     return {
       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)
+  let betId = argBetId;
+  if (!betId) {
+    const betName2 = argBetName ?? "Untitled Bet (Shaping)";
+    const agentId = getAgentSessionId();
+    try {
+      const result = await mcpMutation(
+        "chain.createEntry",
+        {
+          collectionSlug: "bets",
+          name: betName2,
+          status: "draft",
+          data: {
+            problem: userInput,
+            appetite: "",
+            elements: "",
+            rabbitHoles: "",
+            noGos: "",
+            architecture: "",
+            buildContract: "",
+            description: `Shaping session for: ${betName2}`,
+            status: "shaping",
+            shapingSessionActive: true
+          },
+          createdBy: agentId ? `agent:${agentId}` : "facilitate",
+          sessionId: agentId ?? void 0
+        }
+      );
+      betId = result.entryId;
+      await recordSessionActivity({ entryCreated: result.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 [betEntry, constellation, chainSurfaced] = await Promise.all([
+    loadBetEntry(betId),
+    loadConstellationState(betId),
+    searchChain(userInput, { maxResults: 8 })
   ]);
   if (!betEntry) {
     return {
-      content: [{ type: "text", text: `Bet \`${argBetId}\` not found. Use start to create a session.` }]
+      content: [{ type: "text", text: `Bet \`${betId}\` not found. Use start to create a session.` }]
     };
   }
   const betData = betEntry.data ?? {};
-  if (captureArg) {
+  if (captureItems.length > 0) {
     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;
+    let runningBetData = { ...betData };
+    for (const item of captureItems) {
+      if (item.type === "noGo") {
+        const updatedNoGos = appendNoGo(
+          runningBetData.noGos,
+          { title: item.name, explanation: item.description }
+        );
+        runningBetData.noGos = updatedNoGos;
         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
-            }
+          await mcpMutation("chain.updateEntry", {
+            entryId: betId,
+            data: { noGos: updatedNoGos },
+            changeNote: `Added no-go: ${item.name}`
+          });
+          await recordSessionActivity({ entryModified: betEntry._id });
+        } catch (updErr) {
+          captureErrors.push({
+            operation: "update",
+            detail: `noGos field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
+          });
+        }
+        continue;
+      }
+      const mapping = collectionMap[item.type];
+      if (!mapping) continue;
+      let capturedEntryId = null;
+      try {
+        const result = await mcpMutation(
+          "chain.createEntry",
+          {
+            collectionSlug: mapping.slug,
+            name: item.name,
+            status: "draft",
+            data: { [mapping.dataField]: item.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(
+            item.name,
+            mapping.slug,
+            betId,
+            mapping.relationType
           );
-          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}` });
-            }
+          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}` });
+            captureErrors.push({ operation: "capture", detail: `${item.type}: ${msg}` });
           }
+        } else {
+          captureErrors.push({ operation: "capture", detail: `${item.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)}`
-              });
-            }
-          }
+      }
+      if (!capturedEntryId) continue;
+      try {
+        await mcpMutation("chain.createEntryRelation", {
+          fromEntryId: capturedEntryId,
+          toEntryId: betId,
+          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 ${betId}: ${msg}`
+          });
+        }
+      }
+      if (item.type === "element") {
+        const updatedElements = appendElement(
+          runningBetData.elements,
+          { name: item.name, description: item.description, entryId: capturedEntryId }
+        );
+        runningBetData.elements = updatedElements;
+        try {
+          await mcpMutation("chain.updateEntry", {
+            entryId: betId,
+            data: { elements: updatedElements },
+            changeNote: `Added element: ${item.name}`
+          });
+          await recordSessionActivity({ entryModified: betEntry._id });
+        } catch (updErr) {
+          captureErrors.push({
+            operation: "update",
+            detail: `elements field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
+          });
+        }
+      } else if (item.type === "risk") {
+        const updatedRisks = appendRabbitHole(
+          runningBetData.rabbitHoles,
+          { name: item.name, description: item.description, theme: item.theme, entryId: capturedEntryId }
+        );
+        runningBetData.rabbitHoles = updatedRisks;
+        try {
+          await mcpMutation("chain.updateEntry", {
+            entryId: betId,
+            data: { rabbitHoles: updatedRisks },
+            changeNote: `Added risk: ${item.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 refreshedBet = await loadBetEntry(betId);
   const refreshedData = refreshedBet?.data ?? betData;
-  const refreshedConstellation = captureArg ? await loadConstellationState(argBetId, refreshedBet?._id ?? betEntry._id) : constellation;
+  const refreshedConstellation = captureItems.length > 0 ? await loadConstellationState(betId, refreshedBet?._id ?? betEntry._id) : constellation;
+  const sessionDrafts = await loadSessionDrafts(betId, refreshedBet?._id ?? betEntry._id);
+  const constellationEntryIds = sessionDrafts.map((d) => d.entryId);
+  const alreadyCheckedOverlap = typeof refreshedData._overlapIds === "string";
+  let overlap = [];
+  if (!alreadyCheckedOverlap && captureItems.length === 0) {
+    const problemText = refreshedData.problem ?? userInput;
+    const overlapResults = await searchChain(problemText, { maxResults: 5, excludeIds: [betId, ...constellationEntryIds] });
+    overlap = overlapResults.map((r) => ({
+      entryId: r.entryId,
+      similarity: "text_match",
+      summary: `${r.name} [${r.collection}]`
+    }));
+  }
   const overlapIds = overlap.map((o) => o.entryId);
   const appetiteText = refreshedData.appetite ?? "";
   const isSmallBatch = detectSmallBatch(
@@ -4082,11 +4390,9 @@ async function handleRespond(args) {
     source
   );
   const dimensionResult = scoreDimension(activeDimension, scoringCtx);
-  const scorecard = buildScorecard(scoringCtx);
-  if (isSmallBatch) scorecard.architecture = -1;
-  const completed = completedDimensions(scorecard, 6, isSmallBatch);
+  const { scorecard, criteria: scorecardCriteria } = buildDetailedScorecard(scoringCtx, { isSmallBatch });
   const nextDimension = inferActiveDimension(scorecard, isSmallBatch);
-  const phase = inferPhase(scorecard, isSmallBatch);
+  const phase = inferPhase(scorecard, isSmallBatch, extractContentEvidence(scoringCtx));
   try {
     const fieldUpdates = {};
     const persist = (dim, field, minLen) => {
@@ -4097,8 +4403,8 @@ async function handleRespond(args) {
     persist("problem_clarity", "problem", 50);
     persist("appetite", "appetite", 20);
     persist("architecture", "architecture", 50);
-    if (overlapIds.length > 0 && !refreshedData._overlapIds) {
-      fieldUpdates._overlapIds = overlapIds.join(",");
+    if (!refreshedData._overlapIds) {
+      fieldUpdates._overlapIds = overlapIds.length > 0 ? overlapIds.join(",") : "_checked";
     }
     const govCount = chainSurfaced.filter(
       (e) => ["principles", "standards", "business-rules"].includes(e.collection)
@@ -4108,7 +4414,7 @@ async function handleRespond(args) {
     }
     if (Object.keys(fieldUpdates).length > 0) {
       await mcpMutation("chain.updateEntry", {
-        entryId: argBetId,
+        entryId: betId,
         data: fieldUpdates,
         changeNote: `Updated ${Object.keys(fieldUpdates).join(", ")} from shaping session`
       });
@@ -4122,39 +4428,50 @@ async function handleRespond(args) {
   }
   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}]` });
+  for (const result of chainSurfaced) {
+    if (governanceCollections.has(result.collection)) {
+      alignment.push({ entryId: result.entryId, relationship: `governs [${result.collection}]` });
     }
   }
-  const dims = activeDimensions(isSmallBatch);
-  const captureReady = completed.length >= (isSmallBatch ? 3 : 4) && dims.every((d) => scorecard[d] > 0);
+  const { ready: captureReady, completed } = isCaptureReady(scorecard, isSmallBatch);
   const observation = dimensionResult.satisfied.length > 0 ? `${DIMENSION_LABELS[activeDimension]}: ${dimensionResult.satisfied.join("; ")}` : `${DIMENSION_LABELS[activeDimension]}: needs more detail`;
-  const pushback = !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 pushback = captureItems.length === 0 && overlap.length > 0 ? `${overlap[0].summary} already exists on the Chain. How does your bet differ?` : dimensionResult.missing.length > 0 ? dimensionResult.missing[0] : "";
   const suggestedQuestion = dimensionResult.missing.length > 1 ? dimensionResult.missing[1] : dimensionResult.missing.length > 0 ? dimensionResult.missing[0] : `${DIMENSION_LABELS[nextDimension]} is next \u2014 ready to move on?`;
   const wsCtx = await getWorkspaceContext();
-  const studioUrl = buildStudioUrl(wsCtx.workspaceSlug, argBetId);
+  const studioUrl = buildStudioUrl(wsCtx.workspaceSlug, betId);
   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 }))
+      betEntryId: betId,
+      governanceEntries: chainSurfaced.filter((e) => ["principles", "standards", "business-rules"].includes(e.collection)).map((e) => ({ entryId: e.entryId, name: e.name, collection: e.collection })),
+      relatedDecisions: chainSurfaced.filter((e) => e.collection === "decisions").map((e) => ({ entryId: e.entryId, name: e.name })),
+      relatedTensions: chainSurfaced.filter((e) => e.collection === "tensions").map((e) => ({ entryId: e.entryId, name: e.name }))
     };
     buildContract = generateBuildContract(contractCtx);
   }
+  let commitBlockers;
+  if (captureReady) {
+    commitBlockers = computeCommitBlockers({
+      betEntryId: betId,
+      relations: refreshedConstellation.relations,
+      betData: refreshedData,
+      sessionDrafts
+    });
+    if (commitBlockers.length === 0) commitBlockers = void 0;
+  }
   const suggested = suggestCaptures(scoringCtx, activeDimension);
-  const sessionDrafts = await loadSessionDrafts(argBetId, refreshedBet?._id ?? betEntry._id);
+  const betProblem = refreshedData.problem ?? "";
   const betName = refreshedData.description ?? betEntry.name;
-  const investigationBrief = buildInvestigationBrief(phase, betName, argBetId) ?? void 0;
+  const elementNames = (refreshedData.elements ?? "").match(/###\s*Element\s*\d+:\s*(.+)/gi)?.map((h) => h.replace(/###\s*Element\s*\d+:\s*/i, "").trim()) ?? [];
+  const investigationBrief = buildInvestigationBrief(phase, betName, betId, betProblem, elementNames) ?? void 0;
   const response = {
+    version: 2,
     phase,
     phaseLabel: PHASE_LABELS[phase],
     scorecard,
     overlap,
     alignment,
-    chainSurfaced,
+    chainSurfaced: chainSurfaced.map((r) => ({ entryId: r.entryId, relevance: r.name, collection: r.collection })),
     suggestedCaptures: suggested,
     sessionDrafts,
     coaching: {
@@ -4166,7 +4483,7 @@ async function handleRespond(args) {
       nextDimension
     },
     captured: {
-      betEntryId: argBetId,
+      betEntryId: betId,
       studioUrl,
       entriesCreated,
       relationsCreated
@@ -4175,10 +4492,12 @@ async function handleRespond(args) {
     navigation: {
       completedDimensions: completed,
       activeDimension,
-      suggestedOrder: dims
+      suggestedOrder: activeDimensions(isSmallBatch)
     },
     buildContract,
-    investigationBrief
+    investigationBrief,
+    commitBlockers,
+    scorecardCriteria
   };
   const STRUCTURED_DIMS = {
     elements: "element",
@@ -4186,17 +4505,20 @@ async function handleRespond(args) {
     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 dataLossWarning = expectedCaptureType && captureItems.length === 0 ? `**WARNING:** You discussed ${activeDimension} but did not use the \`capture\` parameter \u2014 nothing was saved to the bet. Re-send with \`capture={type:"${expectedCaptureType}", name:"...", description:"..."}\` to persist this.` : "";
+  const directive = buildDirective(scorecard, phase, betId, captureReady, activeDimension, nextDimension);
   const summaryParts = [
     `# ${PHASE_LABELS[phase]} \u2014 ${DIMENSION_LABELS[activeDimension]}`,
     "",
     dataLossWarning,
-    `**Score:** ${scorecard[activeDimension]}/10 | **Phase:** ${PHASE_LABELS[phase]}`,
+    `**Score:** ${DIMENSION_LABELS[activeDimension]}: ${scorecard[activeDimension]}/10 \u2014 ${formatCriteriaLine(dimensionResult.criteria)}`,
+    `**Phase:** ${PHASE_LABELS[phase]}`,
     observation,
     pushback ? `**Pushback:** ${pushback}` : "",
     `**Next:** ${suggestedQuestion}`,
     captureReady ? "\n**Capture ready** \u2014 the bet has enough shape to finalize." : "",
+    commitBlockers?.length ? `
+\u26A0 **Commit blockers (${commitBlockers.length}):** ${commitBlockers.map((b) => `${b.blocker} \u2192 \`${b.fix}\``).join("; ")}` : "",
     entriesCreated.length > 0 ? `**Captured:** ${entriesCreated.join(", ")}` : "",
     suggested.length > 0 ? `**Suggest capturing:** ${suggested.map((s) => `${s.type}: "${s.name}"`).join("; ")}` : "",
     sessionDrafts.length > 0 ? `**Session drafts (${sessionDrafts.length}):** ${sessionDrafts.map((d) => `\`${d.entryId}\` ${d.name}`).join(", ")}` : "",
@@ -4233,16 +4555,12 @@ async function handleScore(args) {
   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 scoringCtx = buildCachedScoringContext(betData, constellation);
+  const { scorecard, criteria: scorecardCriteria } = buildDetailedScorecard(scoringCtx, { isSmallBatch });
   const dims = activeDimensions(isSmallBatch);
-  const completed = completedDimensions(scorecard, 6, isSmallBatch);
+  const { ready: captureReady, completed } = isCaptureReady(scorecard, isSmallBatch);
   const active = inferActiveDimension(scorecard, isSmallBatch);
-  const phase = inferPhase(scorecard, isSmallBatch);
+  const phase = inferPhase(scorecard, isSmallBatch, extractContentEvidence(scoringCtx));
   const lines = [
     `# Scorecard \u2014 ${betEntry.name}`,
     `**Phase:** ${PHASE_LABELS[phase]}`,
@@ -4258,16 +4576,60 @@ async function handleScore(args) {
     lines.push(`| ${label} | ${score}/10 | ${status}${marker} |`);
   }
   lines.push("");
+  lines.push("### Criteria Detail");
+  for (const dim of dims) {
+    const label = DIMENSION_LABELS[dim];
+    lines.push(`**${label} (${scorecard[dim]}/10):** ${formatCriteriaLine(scorecardCriteria[dim])}`);
+  }
+  lines.push("");
   lines.push(`Completed: ${completed.length}/${dims.length}`);
   lines.push(`Next dimension: ${DIMENSION_LABELS[active]}`);
   const sessionDrafts = await loadSessionDrafts(betId, betEntry._id);
+  const constellationDrafts = sessionDrafts.filter((d) => d.collection !== "unknown");
   if (sessionDrafts.length > 0) {
     lines.push("");
     lines.push(`**Session drafts (${sessionDrafts.length}):** ${sessionDrafts.map((d) => `\`${d.entryId}\` ${d.name}`).join(", ")}`);
   }
+  const commitBlockers = computeCommitBlockers({
+    betEntryId: betId,
+    relations: constellation.relations,
+    betData,
+    sessionDrafts
+  });
+  if (captureReady) {
+    lines.push("");
+    lines.push("**Capture ready** \u2014 the bet has enough shape to finalize.");
+    if (constellationDrafts.length > 0) {
+      lines.push("");
+      lines.push(`**Constellation entries to commit alongside the bet:**`);
+      for (const draft of constellationDrafts) {
+        lines.push(`- \`${draft.entryId}\` ${draft.name} [${draft.collection}]`);
+      }
+      lines.push("");
+      lines.push("When committing, also commit these constellation entries to keep the graph consistent.");
+    }
+  }
+  if (commitBlockers.length > 0) {
+    lines.push("");
+    lines.push(`\u26A0 **Commit blockers (${commitBlockers.length}):**`);
+    for (const b of commitBlockers) {
+      lines.push(`- ${b.blocker} \u2192 \`${b.fix}\``);
+    }
+  }
   return {
     content: [{ type: "text", text: lines.join("\n") }],
-    structuredContent: { scorecard, phase, phaseLabel: PHASE_LABELS[phase], completedDimensions: completed, nextDimension: active, sessionDrafts }
+    structuredContent: {
+      scorecard,
+      phase,
+      phaseLabel: PHASE_LABELS[phase],
+      completedDimensions: completed,
+      nextDimension: active,
+      sessionDrafts,
+      captureReady,
+      constellationDrafts,
+      commitBlockers: commitBlockers.length > 0 ? commitBlockers : void 0,
+      scorecardCriteria
+    }
   };
 }
 async function handleResume(args) {
@@ -4286,25 +4648,21 @@ async function handleResume(args) {
   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 scoringCtx = buildCachedScoringContext(betData, constellation);
+  const { scorecard, criteria: scorecardCriteria } = buildDetailedScorecard(scoringCtx, { isSmallBatch });
   const dims = activeDimensions(isSmallBatch);
-  const completed = completedDimensions(scorecard, 6, isSmallBatch);
+  const { ready: captureReady, completed } = isCaptureReady(scorecard, isSmallBatch);
   const active = inferActiveDimension(scorecard, isSmallBatch);
-  const phase = inferPhase(scorecard, isSmallBatch);
+  const phase = inferPhase(scorecard, isSmallBatch, extractContentEvidence(scoringCtx));
   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 = {
+    version: 2,
     phase,
     phaseLabel: PHASE_LABELS[phase],
     scorecard,
@@ -4332,7 +4690,8 @@ async function handleResume(args) {
       completedDimensions: completed,
       activeDimension: active,
       suggestedOrder: dims
-    }
+    },
+    scorecardCriteria
   };
   const directive = buildDirective(scorecard, phase, betId, captureReady, active, active);
   const scorecardLines = dims.map((dim) => {
@@ -4341,6 +4700,9 @@ async function handleResume(args) {
     const arrow = dim === active ? " \u25C0 next" : "";
     return `| ${DIMENSION_LABELS[dim]} | ${bar} ${s}/10${arrow} |`;
   });
+  const criteriaDetail = dims.map(
+    (dim) => `**${DIMENSION_LABELS[dim]} (${scorecard[dim]}/10):** ${formatCriteriaLine(scorecardCriteria[dim])}`
+  );
   const output = [
     `# Session Resumed \u2014 ${betEntry.name}`,
     "",
@@ -4356,6 +4718,9 @@ async function handleResume(args) {
     "|---|---|",
     ...scorecardLines,
     "",
+    "### Criteria Detail",
+    ...criteriaDetail,
+    "",
     `Continue with ${DIMENSION_LABELS[active]}?`,
     directive ? `
 ---
@@ -4367,6 +4732,139 @@ ${directive}` : ""
     structuredContent: response
   };
 }
+async function handleCommitConstellation(args) {
+  requireWriteAccess();
+  const betId = args.betEntryId;
+  const operationId = args.operationId ?? `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+  if (!betId) {
+    return {
+      content: [{ type: "text", text: "`betEntryId` is required for commit-constellation action." }]
+    };
+  }
+  const betEntry = await loadBetEntry(betId);
+  if (!betEntry) {
+    return {
+      content: [{ type: "text", text: `Bet \`${betId}\` not found.` }]
+    };
+  }
+  const betData = betEntry.data ?? {};
+  const relations = await mcpQuery("chain.listEntryRelations", {
+    entryId: betId
+  });
+  const sessionDrafts = await loadSessionDrafts(betId, betEntry._id);
+  const commitBlockerItems = computeCommitBlockers({
+    betEntryId: betId,
+    relations,
+    betData,
+    sessionDrafts
+  });
+  if (commitBlockerItems.length > 0) {
+    return {
+      content: [{
+        type: "text",
+        text: [
+          `# Cannot commit constellation`,
+          "",
+          `**${commitBlockerItems.length} blocker(s) found** \u2014 fix these before committing:`,
+          ...commitBlockerItems.map((b) => `- ${b.blocker} \u2192 \`${b.fix}\``),
+          "",
+          "No entries were committed."
+        ].join("\n")
+      }],
+      structuredContent: {
+        operationId,
+        blockers: commitBlockerItems,
+        committedIds: [],
+        alreadyCommittedIds: [],
+        failedIds: [],
+        conflictIds: [],
+        totalRelations: relations.length
+      }
+    };
+  }
+  let contradictionWarnings = [];
+  try {
+    const { runContradictionCheck } = await import("./smart-capture-GH4CXVVX.js");
+    const descField = betData.problem ?? betData.description ?? "";
+    contradictionWarnings = await runContradictionCheck(
+      betEntry.name ?? betId,
+      descField
+    );
+    if (contradictionWarnings.length > 0) {
+      await recordSessionActivity({ contradictionWarning: true });
+    }
+  } catch {
+  }
+  const author = getAgentSessionId() ? `agent:${getAgentSessionId()}` : void 0;
+  const sessionId = getAgentSessionId() ?? void 0;
+  let result;
+  try {
+    result = await mcpMutation("chain.batchCommitConstellation", {
+      betEntryId: betId,
+      author,
+      sessionId,
+      operationId
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{
+        type: "text",
+        text: `# Bet commit failed
+
+\`${betId}\` could not be committed: ${msg}
+
+No constellation entries were committed.`
+      }],
+      isError: true
+    };
+  }
+  for (const entryId of result.committedIds) {
+    await recordSessionActivity({ entryModified: entryId });
+  }
+  const lines = [];
+  if (result.proposalCreated) {
+    const linkedCount = result.committedIds.filter((id) => id !== betId).length;
+    lines.push(
+      `# Proposal created`,
+      "",
+      `Workspace uses consent-based governance. \`${betId}\` was submitted as a proposal \u2014 it will be committed when approved.`,
+      `**${linkedCount} linked entries** were committed directly (proposals apply to the bet only).`
+    );
+  } else {
+    lines.push(
+      `# Published`,
+      "",
+      `**${result.committedIds.length} entries** committed to the Chain, **${result.totalRelations} connections** preserved.`,
+      `\`${betId}\` and its full constellation are now source of truth.`
+    );
+  }
+  if (contradictionWarnings.length > 0) {
+    lines.push("", `\u26A0 **Contradiction warnings** (advisory):`, ...contradictionWarnings.map((w) => `- ${w}`));
+  }
+  if (result.committedIds.length > 0) {
+    lines.push("", `**Committed:** ${result.committedIds.join(", ")}`);
+  }
+  if (result.alreadyCommittedIds.length > 0) {
+    lines.push("", `**Already committed:** ${result.alreadyCommittedIds.join(", ")}`);
+  }
+  if (result.conflictIds.length > 0) {
+    lines.push("", `**${result.conflictIds.length} conflicts:**`);
+    for (const c of result.conflictIds) {
+      lines.push(`- \`${c.entryId}\` ${c.name}: ${c.reason}`);
+    }
+  }
+  if (result.failedIds.length > 0) {
+    lines.push("", `**${result.failedIds.length} failed:**`);
+    for (const f of result.failedIds) {
+      lines.push(`- \`${f.entryId}\` ${f.name}: ${f.error}`);
+    }
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: { ...result, contradictionWarnings }
+  };
+}
 
 // src/tools/verify.ts
 import { existsSync, readFileSync } from "fs";
@@ -5120,7 +5618,7 @@ function registerStartTools(server) {
     "start",
     {
       title: "Start Product Brain",
-      description: "The zero-friction entry point. Say 'start PB' to begin.\n\n- **Fresh workspace**: asks what you're building, seeds tailored collections, and gets you ready to capture knowledge immediately.\n- **Existing workspace**: returns readiness score, recent activity, open tensions, and suggested next actions (same as orient).\n\nUse this as your first call. Replaces the need to call orient or health separately.",
+      description: "The zero-friction entry point. Say 'start PB' to begin.\n\n- **Fresh workspace (blank)**: scans your codebase and seeds knowledge from what it finds.\n- **Early workspace (seeded)**: picks up where you left off with the top gaps to fill.\n- **Active workspace (grounded/connected)**: standup briefing with recent activity and open items.\n\nUse this as your first call. Replaces the need to call orient or health separately.",
       inputSchema: startSchema,
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
     },
@@ -5143,45 +5641,107 @@ function registerStartTools(server) {
           ]
         };
       }
-      const isFresh = await detectFreshWorkspace();
-      if (isFresh && !preset) {
-        return { content: [{ type: "text", text: buildPresetMenu(wsCtx) }] };
+      let stage = null;
+      let readiness = null;
+      try {
+        readiness = await mcpQuery("chain.workspaceReadiness");
+        stage = readiness?.stage ?? "blank";
+      } catch {
+        errors.push("Readiness check unavailable \u2014 showing workspace summary.");
       }
-      if (isFresh && preset) {
+      if (stage === "blank" && preset) {
         return { content: [{ type: "text", text: await seedPreset(wsCtx, preset, agentSessionId) }] };
       }
+      if (stage === "blank") {
+        return { content: [{ type: "text", text: buildProjectScanResponse(wsCtx) }] };
+      }
+      if (stage === "seeded") {
+        const text = await buildSeededResponse(wsCtx, readiness, agentSessionId);
+        void mcpMutation("chain.setOnboardingCompleted", {}).catch(() => {
+        });
+        return { content: [{ type: "text", text }] };
+      }
+      if (stage === "grounded" || stage === "connected") {
+        void mcpMutation("chain.setOnboardingCompleted", {}).catch(() => {
+        });
+      }
       return { content: [{ type: "text", text: await buildOrientResponse(wsCtx, agentSessionId, errors) }] };
     }
   );
 }
-async function detectFreshWorkspace() {
-  try {
-    const entries = await mcpQuery("chain.listEntries", {});
-    const nonSystem = (entries ?? []).filter((e) => e.stratum !== "system");
-    return nonSystem.length === 0;
-  } catch {
-    return false;
-  }
-}
-function buildPresetMenu(wsCtx) {
-  const presets = listPresets();
-  const lines = [
+function buildProjectScanResponse(wsCtx) {
+  return [
     `# Welcome to ${wsCtx.workspaceName}`,
     "",
-    "Your workspace is fresh \u2014 let's get it set up together.",
+    "Your workspace is fresh. Let me get oriented in your codebase.",
     "",
-    "**Tell me: what are you building?** Describe it in a sentence or two and I'll help you pick the right structure. Or choose a preset to start from:",
+    "**Please read these files and tell me what you find:**",
+    "1. `README.md` (or equivalent \u2014 top-level docs)",
+    "2. `package.json` / `pyproject.toml` / `Cargo.toml` (project manifest)",
+    "3. Top-level source directories and their purpose",
+    "",
+    "From those, infer 5\u20138 product knowledge entries \u2014 things like:",
+    "- **Product name and what it does** (1\u20132 sentences)",
+    "- **Key technical decisions** already made (framework, DB, architecture)",
+    "- **Core features** the codebase reveals",
+    "- **Conventions** you notice (naming, patterns, standards)",
+    "",
+    "Present them as a numbered list:",
+    "```",
+    "1. [Entry name]: [1-sentence description]",
+    "2. ...",
+    "```",
+    "",
+    `Then ask: **"Which of these are accurate? Reply with numbers to skip (e.g. 'skip 2, 4') or say 'all good' to capture everything."**`,
+    "",
+    "Once confirmed, call `capture` for each entry with `autoCommit: false` \u2014 the user will review before anything hits the Chain.",
+    "",
+    '**If the codebase is sparse** (no README, empty project, monorepo root): say so and ask "Tell me about your product in a sentence \u2014 what does it do and who is it for?" instead.',
+    "",
+    "_Prefer 5 specific entries over 8 generic ones. Skip anything that would apply to any codebase._"
+  ].join("\n");
+}
+async function buildSeededResponse(wsCtx, readiness, agentSessionId) {
+  const lines = [
+    `# ${wsCtx.workspaceName}`,
+    "_Picking up where you left off._",
     ""
   ];
-  for (const p of presets) {
-    lines.push(`- **${p.name}** (\`${p.id}\`) \u2014 ${p.description} (${p.collectionCount} collections)`);
+  const stage = readiness?.stage ?? "seeded";
+  const score = readiness?.score;
+  if (score !== void 0) {
+    lines.push(`**Brain stage: ${stage}.** Readiness score: ${score}/100.`);
+    lines.push("");
+  }
+  const gaps = readiness?.gaps ?? [];
+  if (gaps.length > 0) {
+    lines.push("## Top gaps to fill");
+    for (const gap of gaps.slice(0, 3)) {
+      const cta = gap.capabilityGuidance ?? gap.guidance ?? `Capture ${gap.label.toLowerCase()} to unlock this.`;
+      lines.push(`**${gap.label}** \u2014 ${cta}`);
+    }
+    lines.push("");
+    if (gaps.length > 3) {
+      lines.push(`_${gaps.length - 3} more gap${gaps.length - 3 === 1 ? "" : "s"} \u2014 use \`health action=status\` for the full list._`);
+      lines.push("");
+    }
+  } else {
+    lines.push("No gaps detected \u2014 workspace is filling up nicely.");
+    lines.push("");
+  }
+  lines.push("What would you like to work on?");
+  lines.push("");
+  if (agentSessionId) {
+    try {
+      await mcpCall("agent.markOriented", { sessionId: agentSessionId });
+      setSessionOriented(true);
+      lines.push("---");
+      lines.push("Orientation complete. Write tools available.");
+    } catch {
+      lines.push("---");
+      lines.push("_Warning: Could not mark session as oriented._");
+    }
   }
-  lines.push(
-    "",
-    'Call `start` again with your choice, e.g.: `start preset="software-product"`',
-    "",
-    "_These are starting points. You can add, remove, or customize collections at any time using `collections action=create` and `collections action=update`._"
-  );
   return lines.join("\n");
 }
 async function seedPreset(wsCtx, presetId, agentSessionId) {
@@ -5419,7 +5979,7 @@ async function buildOrientResponse(wsCtx, agentSessionId, errors) {
     try {
       const allEntries = await mcpQuery("chain.listEntries", {});
       const committed = (allEntries ?? []).filter(
-        (e) => e.status === "active"
+        (e) => e.status === "active" && !e.seededByPlatform
       );
       const committedCollections = new Set(committed.map((e) => e.collectionId ?? e.collection));
       if (committed.length >= 10 && committedCollections.size >= 3) {
@@ -5437,10 +5997,8 @@ async function buildOrientResponse(wsCtx, agentSessionId, errors) {
           lines.push(`**View in Studio:** \`/w/${wsCtx.workspaceSlug}/studio\``);
           lines.push("");
         }
-        if (committed.length >= 10 && committedCollections.size >= 3) {
-          lines.push(`_Tip: Connect entries with \`graph action=suggest\` to unlock deeper context._`);
-          lines.push("");
-        }
+        lines.push(`_Tip: Connect entries with \`graph action=suggest\` to unlock deeper context._`);
+        lines.push("");
       }
     } catch {
     }
@@ -7902,7 +8460,64 @@ Browse: \`entries action=list collection=tracking-events\`.`
   );
   return sections.join("\n\n---\n\n");
 }
+var AGENT_CHEATSHEET = `# Product Brain \u2014 Agent Cheatsheet
+
+## Core Tools
+| Tool | Purpose | Key params |
+|---|---|---|
+| \`orient\` | Workspace context, governance, active bets | \u2014 (call at session start) |
+| \`capture\` | Create entry (draft) | \`collection\`, \`name\`, \`description\`, optional \`data\` |
+| \`entries\` | List / get / batch / search entries | \`action\` + \`entryId\` / \`query\` / \`collection\` |
+| \`update-entry\` | Update fields on an entry | \`entryId\`, optional \`name\`, \`status\`, \`workflowStatus\`, \`data\`, \`changeNote\` |
+| \`commit-entry\` | Promote draft \u2192 SSOT | \`entryId\` |
+| \`graph\` | Suggest / find relations | \`action\` + \`entryId\` |
+| \`relations\` | Create / batch-create / delete links | \`from\`, \`to\`, \`type\` |
+| \`context\` | Gather related knowledge | \`entryId\` or \`task\` |
+| \`collections\` | List / create / update collections | \`action\` |
+| \`labels\` | List / create / apply / remove labels | \`action\` |
+| \`quality\` | Score an entry | \`entryId\` |
+| \`session\` | Start / close agent session | \`action\` |
+| \`health\` | Check / audit / whoami | \`action\` |
+| \`facilitate\` | Shaping workflows | \`action\`: start, respond, status |
+
+## Collection Prefixes
+GLO (glossary), BR (business-rules), PRI (principles), STD (standards),
+DEC (decisions), STR (strategy), TEN (tensions), FEAT (features),
+BET (bets), INS (insights), ARCH (architecture), CIR (circles),
+ROL (roles), MAP (maps), MTRC (tracking-events), ST (semantic-types)
+
+## Valid Relation Types (21)
+informs, governs, surfaces_tension_in, defines_term_for, belongs_to,
+references, related_to, fills_slot, commits_to, informed_by, depends_on,
+conflicts_with, confused_with, replaces, part_of, constrains,
+governed_by, alternative_to, has_proposal, requests_promotion_of, resolves
+
+## Lifecycle Status
+All entries: \`draft\` | \`active\` | \`deprecated\` | \`archived\`
+
+## Workflow Status (per collection)
+- **tensions:** open \u2192 processing \u2192 decided \u2192 closed
+- **decisions:** pending \u2192 decided
+- **bets:** shaped \u2192 bet \u2192 building \u2192 shipped
+- **business-rules:** active | conflict | review
+
+## Key Patterns
+- **Capture flow:** \`capture\` \u2192 \`graph action=suggest\` \u2192 \`relations action=batch-create\` \u2192 \`commit-entry\`
+- Use \`workflowStatus\` (not \`status\`) for domain workflow state
+- \`data\` param is merged (not replaced) \u2014 safe for partial updates
+`;
 function registerResources(server) {
+  server.resource(
+    "agent-cheatsheet",
+    "productbrain://agent-cheatsheet",
+    async (uri) => ({
+      contents: [{
+        uri: uri.href,
+        text: AGENT_CHEATSHEET,
+        mimeType: "text/markdown"
+      }]
+    })
+  );
   server.resource(
     "chain-orientation",
     "productbrain://orientation",
@@ -9056,4 +9671,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-XCKGFYDP.js.map
+//# sourceMappingURL=chunk-6WVRGNJU.js.map