@productbrain/mcp 0.0.1-beta.43 → 0.0.1-beta.45

package/dist/{chunk-AWDD44CN.js → chunk-ADLZPAEI.js}

@@ -25,11 +25,11 @@ import {
   startAgentSession,
   trackWriteTool,
   translateStaleToolNames
-} from "./chunk-PQP27A3R.js";
+} from "./chunk-CYECJTRI.js";
 import {
   trackQualityCheck,
   trackQualityVerdict
-} from "./chunk-BIDMZOLE.js";
+} from "./chunk-MRIO53BY.js";
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -59,7 +59,10 @@ var WORKFLOW_STATUS_VALUES = [
   "untested",
   "testing",
   "validated",
-  "invalidated"
+  "invalidated",
+  // Insights lifecycle
+  "hypothesis",
+  "evidenced"
 ];
 var LEGACY_WORKFLOW_STATUSES = new Set(WORKFLOW_STATUS_VALUES);
 var updateEntrySchema = z.object({
@@ -203,7 +206,7 @@ ${formatted}` }]
     },
     async ({ entryId }) => {
       requireWriteAccess();
-      const { runContradictionCheck } = await import("./smart-capture-W2IALMJ5.js");
+      const { runContradictionCheck } = await import("./smart-capture-XBOUPHFI.js");
       const entry = await mcpQuery("chain.getEntry", { entryId });
       if (!entry) {
         return {
@@ -3724,10 +3727,11 @@ function computeCommitBlockers(opts) {
   }
   for (const draft of sessionDrafts) {
     if (!draft.name || draft.name.trim().length === 0) {
+      const draftRef = draft.entryId && draft.entryId.trim().length > 0 ? draft.entryId : "<draftId>";
       blockers.push({
         entryId: betEntryId,
         blocker: `Draft constellation entry is missing a name`,
-        fix: `update-entry entryId="<draftId>" name="<name>"`
+        fix: `update-entry entryId="${draftRef}" name="<name>"`
       });
     }
   }
@@ -3778,7 +3782,7 @@ var captureItemSchema = z12.object({
 });
 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. 'commit-constellation': atomically commit a bet and all its linked draft entries in one call. Requires betEntryId."
+    "'start': begin shaping session context (entry created on first respond). 'respond': process user input, score, capture, return coaching. 'score': return current scorecard without advancing. 'resume': reconstruct session from existing bet entry. 'commit-constellation': atomically commit a bet and all its linked draft entries in one call. Requires betEntryId."
   ),
   sessionType: z12.enum(["shape"]).default("shape").optional().describe("Session type. Only 'shape' in v1."),
   betEntryId: z12.string().optional().describe("Bet entry ID. Required for resume/score. For respond: omit on first call after start (entry created automatically); required for subsequent calls."),
@@ -3797,7 +3801,7 @@ function registerFacilitateTools(server) {
     "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 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.",
+      description: "Server-controlled coached shaping session with real-time Chain capture.\n\n- **start**: Begin a coached session context only. No bet entry is created yet.\n- **first respond**: Call respond with `betName` to create the draft bet and capture initial problem context.\n- **respond**: Process user input \u2014 scores against 7 shaping rubrics (problem, appetite, elements, architecture, risks, boundaries, done-when), searches for overlap, captures to Chain, returns structured coaching response with phase tracking.\n- **score**: Return the current scorecard without advancing the session.\n- **resume**: Reconstruct session state from an existing bet entry on the Chain.\n- **commit-constellation**: Atomically commit a bet and all its linked draft entries (features, tensions, decisions) in one call. Validates strategy link and required fields before committing anything. Replaces 9-13 sequential commit-entry calls.\n\nThe structured response separates judgment (server) from coaching (agent) per DEC-56. Read the phase, scorecard, and coaching fields to determine what to say next. When captureReady is true, buildContract is auto-generated from Chain governance.",
       inputSchema: facilitateSchema,
       annotations: {
         readOnlyHint: false,
@@ -3989,8 +3993,12 @@ async function loadConstellationState(betEntryId, betInternalId) {
     const elementCount = relations.filter(
       (r) => r.type === "part_of" && r.toId === internalId
     ).length;
-    const riskCount = relations.filter((r) => r.type === "constrains").length;
-    const decisionCount = relations.filter((r) => r.type === "informs").length;
+    const riskCount = relations.filter(
+      (r) => r.type === "constrains" && r.toId === internalId
+    ).length;
+    const decisionCount = relations.filter(
+      (r) => r.type === "informs" && r.toId === internalId
+    ).length;
     return { relations, elementCount, riskCount, decisionCount };
   } catch {
     return { relations: [], elementCount: 0, riskCount: 0, decisionCount: 0 };
@@ -4173,208 +4181,166 @@ async function handleStart2(args) {
     structuredContent: response
   };
 }
-async function handleRespond(args) {
-  requireWriteAccess();
-  const { userInput, betEntryId: argBetId, dimension: argDimension, capture: rawCapture, source: argSource, betName: argBetName } = args;
-  const source = argSource ?? "user";
-  const captureItems = rawCapture ? Array.isArray(rawCapture) ? rawCapture : [rawCapture] : [];
-  if (!userInput) {
-    return {
-      content: [{ type: "text", text: "`userInput` is required for respond action." }]
-    };
-  }
+async function processCaptures(opts) {
+  const { captureItems, betEntryId, betDocId, betData } = opts;
   const captureErrors = [];
   const entriesCreated = [];
   let relationsCreated = 0;
-  let betId = argBetId;
-  if (!betId) {
-    const betName2 = argBetName ?? "Untitled Bet (Shaping)";
-    const agentId = getAgentSessionId();
+  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" }
+  };
+  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 {
+        await mcpMutation("chain.updateEntry", {
+          entryId: betEntryId,
+          data: { noGos: updatedNoGos },
+          changeNote: `Added no-go: ${item.name}`
+        });
+        await recordSessionActivity({ entryModified: betDocId });
+      } catch (updErr) {
+        captureErrors.push({
+          operation: "update",
+          detail: `noGos field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
+        });
+      }
+      continue;
+    }
+    const mapping = collectionMap[item.type];
+    if (!mapping) continue;
+    let capturedEntryId = null;
     try {
       const result = await mcpMutation(
         "chain.createEntry",
         {
-          collectionSlug: "bets",
-          name: betName2,
+          collectionSlug: mapping.slug,
+          name: item.name,
           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
+          data: { [mapping.dataField]: item.description },
+          createdBy: capAgentId ? `agent:${capAgentId}` : "facilitate",
+          sessionId: capAgentId ?? void 0
         }
       );
-      betId = result.entryId;
+      capturedEntryId = result.entryId;
+      entriesCreated.push(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 \`${betId}\` not found. Use start to create a session.` }]
-    };
-  }
-  const betData = betEntry.data ?? {};
-  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" }
-    };
-    let runningBetData = { ...betData };
-    for (const item of captureItems) {
-      if (item.type === "noGo") {
-        const updatedNoGos = appendNoGo(
-          runningBetData.noGos,
-          { title: item.name, explanation: item.description }
+    } 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,
+          betEntryId,
+          mapping.relationType
         );
-        runningBetData.noGos = updatedNoGos;
-        try {
-          await mcpMutation("chain.updateEntry", {
-            entryId: betId,
-            data: { noGos: updatedNoGos },
-            changeNote: `Added no-go: ${item.name}`
-          });
-          await recordSessionActivity({ entryModified: betEntry._id });
-        } catch (updErr) {
+        if (fallback) {
+          capturedEntryId = fallback.entryId;
+          entriesCreated.push(fallback.entryId);
+          if (fallback.linked) relationsCreated++;
           captureErrors.push({
-            operation: "update",
-            detail: `noGos field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
+            operation: "info",
+            detail: `Linked existing ${mapping.slug} entry \`${fallback.entryId}\` instead of creating duplicate.`
           });
-        }
-        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
-          );
-          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: `${item.type}: ${msg}` });
-          }
         } else {
           captureErrors.push({ operation: "capture", detail: `${item.type}: ${msg}` });
         }
+      } else {
+        captureErrors.push({ operation: "capture", detail: `${item.type}: ${msg}` });
+      }
+    }
+    if (!capturedEntryId) continue;
+    try {
+      await mcpMutation("chain.createEntryRelation", {
+        fromEntryId: capturedEntryId,
+        toEntryId: betEntryId,
+        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 ${betEntryId}: ${msg}`
+        });
       }
-      if (!capturedEntryId) continue;
+    }
+    if (item.type === "element") {
+      const updatedElements = appendElement(
+        runningBetData.elements,
+        { name: item.name, description: item.description, entryId: capturedEntryId }
+      );
+      runningBetData.elements = updatedElements;
       try {
-        await mcpMutation("chain.createEntryRelation", {
-          fromEntryId: capturedEntryId,
-          toEntryId: betId,
-          type: mapping.relationType
+        await mcpMutation("chain.updateEntry", {
+          entryId: betEntryId,
+          data: { elements: updatedElements },
+          changeNote: `Added element: ${item.name}`
+        });
+        await recordSessionActivity({ entryModified: betDocId });
+      } catch (updErr) {
+        captureErrors.push({
+          operation: "update",
+          detail: `elements field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
         });
-        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)}`
-          });
-        }
+    } 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: betEntryId,
+          data: { rabbitHoles: updatedRisks },
+          changeNote: `Added risk: ${item.name}`
+        });
+        await recordSessionActivity({ entryModified: betDocId });
+      } catch (updErr) {
+        captureErrors.push({
+          operation: "update",
+          detail: `rabbitHoles field: ${updErr instanceof Error ? updErr.message : String(updErr)}`
+        });
       }
     }
   }
-  const refreshedBet = await loadBetEntry(betId);
+  return { entriesCreated, relationsCreated, captureErrors };
+}
+async function computeAndUpdateScores(opts) {
+  const {
+    betEntryId,
+    betDocId,
+    betData,
+    betEntry,
+    userInput,
+    argDimension,
+    source,
+    captureItems,
+    chainSurfaced,
+    constellation
+  } = opts;
+  const captureErrors = [];
+  const refreshedBet = await loadBetEntry(betEntryId);
   const refreshedData = refreshedBet?.data ?? betData;
-  const refreshedConstellation = captureItems.length > 0 ? await loadConstellationState(betId, refreshedBet?._id ?? betEntry._id) : constellation;
-  const sessionDrafts = await loadSessionDrafts(betId, refreshedBet?._id ?? betEntry._id);
+  const refreshedConstellation = captureItems.length > 0 ? await loadConstellationState(betEntryId, refreshedBet?._id ?? betEntry._id) : constellation;
+  const sessionDrafts = await loadSessionDrafts(betEntryId, refreshedBet?._id ?? betEntry._id);
   const constellationEntryIds = sessionDrafts.map((d) => d.entryId);
   const alreadyCheckedOverlap = typeof refreshedData._overlapIds === "string";
   let overlap = [];
   if (!alreadyCheckedOverlap && captureItems.length === 0) {
     const problemText = refreshedData.problem ?? userInput;
-    const overlapResults = await searchChain(problemText, { maxResults: 5, excludeIds: [betId, ...constellationEntryIds] });
+    const overlapResults = await searchChain(problemText, { maxResults: 5, excludeIds: [betEntryId, ...constellationEntryIds] });
     overlap = overlapResults.map((r) => ({
       entryId: r.entryId,
       similarity: "text_match",
@@ -4428,7 +4394,7 @@ async function handleRespond(args) {
     }
     if (Object.keys(fieldUpdates).length > 0) {
       await mcpMutation("chain.updateEntry", {
-        entryId: betId,
+        entryId: betEntryId,
         data: fieldUpdates,
         changeNote: `Updated ${Object.keys(fieldUpdates).join(", ")} from shaping session`
       });
@@ -4451,12 +4417,10 @@ async function handleRespond(args) {
   const observation = dimensionResult.satisfied.length > 0 ? `${DIMENSION_LABELS[activeDimension]}: ${dimensionResult.satisfied.join("; ")}` : `${DIMENSION_LABELS[activeDimension]}: needs more detail`;
   const pushback = captureItems.length === 0 && overlap.length > 0 ? `${overlap[0].summary} already exists on the Chain. How does your bet differ?` : dimensionResult.missing.length > 0 ? dimensionResult.missing[0] : "";
   const suggestedQuestion = dimensionResult.missing.length > 1 ? dimensionResult.missing[1] : dimensionResult.missing.length > 0 ? dimensionResult.missing[0] : `${DIMENSION_LABELS[nextDimension]} is next \u2014 ready to move on?`;
-  const wsCtx = await getWorkspaceContext();
-  const studioUrl = buildStudioUrl(wsCtx.workspaceSlug, betId);
   let buildContract;
   if (captureReady) {
     const contractCtx = {
-      betEntryId: betId,
+      betEntryId,
       governanceEntries: chainSurfaced.filter((e) => ["principles", "standards", "business-rules"].includes(e.collection)).map((e) => ({ entryId: e.entryId, name: e.name, collection: e.collection })),
       relatedDecisions: chainSurfaced.filter((e) => e.collection === "decisions").map((e) => ({ entryId: e.entryId, name: e.name })),
       relatedTensions: chainSurfaced.filter((e) => e.collection === "tensions").map((e) => ({ entryId: e.entryId, name: e.name }))
@@ -4465,7 +4429,7 @@ async function handleRespond(args) {
     if (refreshedData.buildContract !== buildContract) {
       try {
         await mcpMutation("chain.updateEntry", {
-          entryId: betId,
+          entryId: betEntryId,
           data: { buildContract },
           changeNote: "Updated build contract from shaping session"
         });
@@ -4481,7 +4445,7 @@ async function handleRespond(args) {
   let commitBlockers;
   if (captureReady) {
     commitBlockers = computeCommitBlockers({
-      betEntryId: betId,
+      betEntryId,
       betDocId: refreshedBet?._id ?? betEntry._id,
       relations: refreshedConstellation.relations,
       betData: refreshedData,
@@ -4489,11 +4453,59 @@ async function handleRespond(args) {
     });
     if (commitBlockers.length === 0) commitBlockers = void 0;
   }
+  return {
+    scorecard,
+    scorecardCriteria,
+    phase,
+    activeDimension,
+    nextDimension,
+    dimensionResult,
+    overlap,
+    sessionDrafts,
+    alignment,
+    coaching: { observation, pushback, suggestedQuestion, captureReady },
+    completed,
+    isSmallBatch,
+    refreshedData,
+    scoringCtx,
+    captureErrors,
+    buildContract,
+    commitBlockers
+  };
+}
+function assembleResponse(opts) {
+  const {
+    betEntryId,
+    betName,
+    workspaceSlug,
+    scorecard,
+    scorecardCriteria,
+    phase,
+    activeDimension,
+    nextDimension,
+    dimensionResult,
+    coaching,
+    overlap,
+    sessionDrafts,
+    alignment,
+    chainSurfaced,
+    scoringCtx,
+    isSmallBatch,
+    completed,
+    refreshedData,
+    buildContract,
+    commitBlockers,
+    entriesCreated,
+    relationsCreated,
+    captureErrors,
+    captureItems
+  } = opts;
+  const studioUrl = buildStudioUrl(workspaceSlug, betEntryId);
   const suggested = suggestCaptures(scoringCtx, activeDimension);
   const betProblem = refreshedData.problem ?? "";
-  const betName = refreshedData.description ?? betEntry.name;
+  const responseBetName = refreshedData.description ?? betName;
   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 investigationBrief = buildInvestigationBrief(phase, responseBetName, betEntryId, betProblem, elementNames) ?? void 0;
   const response = {
     version: 2,
     phase,
@@ -4505,15 +4517,15 @@ async function handleRespond(args) {
     suggestedCaptures: suggested,
     sessionDrafts,
     coaching: {
-      observation,
+      observation: coaching.observation,
       missing: dimensionResult.missing,
-      pushback,
-      suggestedQuestion,
-      captureReady,
+      pushback: coaching.pushback,
+      suggestedQuestion: coaching.suggestedQuestion,
+      captureReady: coaching.captureReady,
       nextDimension
     },
     captured: {
-      betEntryId: betId,
+      betEntryId,
       studioUrl,
       entriesCreated,
       relationsCreated
@@ -4525,6 +4537,7 @@ async function handleRespond(args) {
       suggestedOrder: activeDimensions(isSmallBatch)
     },
     buildContract,
+    directive: buildDirective(scorecard, phase, betEntryId, coaching.captureReady, activeDimension, nextDimension) || void 0,
     investigationBrief,
     commitBlockers,
     scorecardCriteria
@@ -4536,39 +4549,141 @@ async function handleRespond(args) {
   };
   const expectedCaptureType = STRUCTURED_DIMS[activeDimension];
   const dataLossWarning = expectedCaptureType && captureItems.length === 0 ? `**WARNING:** You discussed ${activeDimension} but did not use the \`capture\` parameter \u2014 nothing was saved to the bet. Re-send with \`capture={type:"${expectedCaptureType}", name:"...", description:"..."}\` to persist this.` : "";
-  const directive = buildDirective(scorecard, phase, betId, captureReady, activeDimension, nextDimension);
   const summaryParts = [
     `# ${PHASE_LABELS[phase]} \u2014 ${DIMENSION_LABELS[activeDimension]}`,
     "",
     dataLossWarning,
     `**Score:** ${DIMENSION_LABELS[activeDimension]}: ${scorecard[activeDimension]}/10 \u2014 ${formatCriteriaLine(dimensionResult.criteria)}`,
     `**Phase:** ${PHASE_LABELS[phase]}`,
-    observation,
-    pushback ? `**Pushback:** ${pushback}` : "",
-    `**Next:** ${suggestedQuestion}`,
-    captureReady ? "\n**Capture ready** \u2014 the bet has enough shape to finalize." : "",
+    coaching.observation,
+    coaching.pushback ? `**Pushback:** ${coaching.pushback}` : "",
+    `**Next:** ${coaching.suggestedQuestion}`,
+    coaching.captureReady ? "\n**Capture ready** \u2014 the bet has enough shape to finalize." : "",
     commitBlockers?.length ? `
 \u26A0 **Commit blockers (${commitBlockers.length}):** ${commitBlockers.map((b) => `${b.blocker} \u2192 \`${b.fix}\``).join("; ")}` : "",
     entriesCreated.length > 0 ? `**Captured:** ${entriesCreated.join(", ")}` : "",
     suggested.length > 0 ? `**Suggest capturing:** ${suggested.map((s) => `${s.type}: "${s.name}"`).join("; ")}` : "",
     sessionDrafts.length > 0 ? `**Session drafts (${sessionDrafts.length}):** ${sessionDrafts.map((d) => `\`${d.entryId}\` ${d.name}`).join(", ")}` : "",
-    captureErrors.length > 0 ? `**Warnings:** ${captureErrors.map((e) => e.detail).join("; ")}` : "",
-    directive ? `
----
-## Agent Directive
-${directive}` : "",
-    investigationBrief ? `
-## Investigation Brief
-${investigationBrief.tasks.map((t) => `- **${t.target}:** ${t.query} \u2014 ${t.purpose}`).join("\n")}
-
-**Proposal guidance:** ${investigationBrief.proposalGuidance}
-**Reaction prompt:** ${investigationBrief.reactionPrompt}` : ""
+    captureErrors.length > 0 ? `**Warnings:** ${captureErrors.map((e) => e.detail).join("; ")}` : ""
   ];
   return {
     content: [{ type: "text", text: summaryParts.filter(Boolean).join("\n") }],
     structuredContent: response
   };
 }
+async function handleRespond(args) {
+  requireWriteAccess();
+  const { userInput, betEntryId: argBetId, dimension: argDimension, capture: rawCapture, source: argSource, betName: argBetName } = args;
+  const source = argSource ?? "user";
+  const captureItems = rawCapture ? Array.isArray(rawCapture) ? rawCapture : [rawCapture] : [];
+  if (!userInput) {
+    return {
+      content: [{ type: "text", text: "`userInput` is required for respond action." }]
+    };
+  }
+  let betId = argBetId;
+  if (!betId) {
+    const betName = argBetName ?? "Untitled Bet (Shaping)";
+    const agentId = getAgentSessionId();
+    try {
+      const result = await mcpMutation(
+        "chain.createEntry",
+        {
+          collectionSlug: "bets",
+          name: betName,
+          status: "draft",
+          data: {
+            problem: userInput,
+            appetite: "",
+            elements: "",
+            rabbitHoles: "",
+            noGos: "",
+            architecture: "",
+            buildContract: "",
+            description: `Shaping session for: ${betName}`,
+            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 \`${betId}\` not found. Use start to create a session.` }]
+    };
+  }
+  const betData = betEntry.data ?? {};
+  let entriesCreated = [];
+  let relationsCreated = 0;
+  const captureErrors = [];
+  if (captureItems.length > 0) {
+    const capResult = await processCaptures({
+      captureItems,
+      betEntryId: betId,
+      betDocId: betEntry._id,
+      betData
+    });
+    entriesCreated = capResult.entriesCreated;
+    relationsCreated = capResult.relationsCreated;
+    captureErrors.push(...capResult.captureErrors);
+  }
+  const scoreResult = await computeAndUpdateScores({
+    betEntryId: betId,
+    betDocId: betEntry._id,
+    betData,
+    betEntry,
+    userInput,
+    argDimension,
+    source,
+    captureItems,
+    chainSurfaced,
+    constellation
+  });
+  captureErrors.push(...scoreResult.captureErrors);
+  const wsCtx = await getWorkspaceContext();
+  return assembleResponse({
+    betEntryId: betId,
+    betName: betEntry.name,
+    workspaceSlug: wsCtx.workspaceSlug,
+    scorecard: scoreResult.scorecard,
+    scorecardCriteria: scoreResult.scorecardCriteria,
+    phase: scoreResult.phase,
+    activeDimension: scoreResult.activeDimension,
+    nextDimension: scoreResult.nextDimension,
+    dimensionResult: scoreResult.dimensionResult,
+    coaching: scoreResult.coaching,
+    overlap: scoreResult.overlap,
+    sessionDrafts: scoreResult.sessionDrafts,
+    alignment: scoreResult.alignment,
+    chainSurfaced,
+    scoringCtx: scoreResult.scoringCtx,
+    isSmallBatch: scoreResult.isSmallBatch,
+    completed: scoreResult.completed,
+    refreshedData: scoreResult.refreshedData,
+    buildContract: scoreResult.buildContract,
+    commitBlockers: scoreResult.commitBlockers,
+    entriesCreated,
+    relationsCreated,
+    captureErrors,
+    captureItems
+  });
+}
 async function handleScore(args) {
   const betId = args.betEntryId;
   if (!betId) {
@@ -4833,7 +4948,7 @@ async function handleCommitConstellation(args) {
   }
   let contradictionWarnings = [];
   try {
-    const { runContradictionCheck } = await import("./smart-capture-W2IALMJ5.js");
+    const { runContradictionCheck } = await import("./smart-capture-XBOUPHFI.js");
     const descField = betData.problem ?? betData.description ?? "";
     contradictionWarnings = await runContradictionCheck(
       betEntry.name ?? betId,
@@ -5676,6 +5791,16 @@ function buildInterviewResponse(workspaceName) {
 }
 
 // src/tools/start.ts
+async function tryMarkOriented(agentSessionId) {
+  if (!agentSessionId) return { oriented: false, orientationStatus: "no_session" };
+  try {
+    await mcpCall("agent.markOriented", { sessionId: agentSessionId });
+    setSessionOriented(true);
+    return { oriented: true, orientationStatus: "complete" };
+  } catch {
+    return { oriented: false, orientationStatus: "failed" };
+  }
+}
 var startSchema = z15.object({
   preset: z15.string().optional().describe(
     "Collection preset ID to seed (e.g. 'software-product', 'content-business', 'agency', 'saas-api', 'general'). Only used for fresh workspaces. If omitted on a fresh workspace, returns the preset menu."
@@ -5725,10 +5850,16 @@ function registerStartTools(server) {
         };
       }
       if (stage === "blank") {
-        const scanResult = buildProjectScanResponse(wsCtx);
+        const { oriented, orientationStatus } = await tryMarkOriented(agentSessionId);
+        const blankResult = buildBlankResponse(wsCtx);
         return {
-          content: [{ type: "text", text: scanResult.text }],
-          structuredContent: scanResult.structuredContent
+          content: [{ type: "text", text: blankResult.text }],
+          structuredContent: {
+            ...blankResult.structuredContent,
+            oriented,
+            orientationStatus,
+            ...agentSessionId ? { sessionId: agentSessionId } : {}
+          }
         };
       }
       if (stage === "seeded") {
@@ -5752,44 +5883,71 @@ function registerStartTools(server) {
     }
   );
 }
-function buildProjectScanResponse(wsCtx) {
+function buildBlankResponse(wsCtx) {
+  const instructions = getInterviewInstructions(wsCtx.workspaceName);
   const text = [
     `# Welcome to ${wsCtx.workspaceName}`,
     "",
-    "Your workspace is fresh. Let me get oriented in your codebase.",
+    "Your workspace is fresh. Let's set it up.",
+    "",
+    "## How would you like to start?",
+    "",
+    "Present these options to the user:",
+    "",
+    "**1. Tell me about your product** _(recommended)_",
+    "Ask the user:",
+    `> ${instructions.question1}`,
+    "",
+    "_A sentence or two is enough. This becomes the foundation \u2014 vision and audience \u2014 that makes everything else more relevant._",
+    "",
+    "**2. Scan my codebase**",
+    "Skip the questions and jump straight to reading the project files.",
+    "",
+    "**3. Use a preset**",
+    `Seed collections for a domain. Available: software-product, content-business, agency, saas-api, general.`,
+    "",
+    "---",
+    "",
+    "## Path 1: Interview first (default if user just starts talking)",
+    "",
+    instructions.systemPrompt,
+    "",
+    "After the user answers Q1, extract:",
+    instructions.extractionGuidance,
+    "",
+    instructions.captureInstructions,
+    "Use `autoCommit: false` for all captures \u2014 user confirms before anything is committed.",
+    "",
+    "**Then offer the codebase scan with context:**",
+    `"Now that I know what you're building, I can scan your project files and find technical decisions, features, and conventions that are relevant to **your** product. Want me to?"`,
+    "",
+    "If they say yes, scan README.md, package.json/pyproject.toml/Cargo.toml, and top-level source dirs.",
+    "Infer entries WITH the product context you now have. Present as a numbered list for confirmation.",
+    "Capture confirmed entries with `autoCommit: false`.",
+    "",
+    "## Path 2: Scan first",
     "",
-    "**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)",
+    "Read these files:",
+    "1. README.md (or equivalent 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)",
+    "Infer 5\u20138 product knowledge entries (product name, tech decisions, features, conventions).",
+    "Present as a numbered list. Ask which to keep. Capture confirmed entries with `autoCommit: false`.",
     "",
-    "Present them as a numbered list:",
-    "```",
-    "1. [Entry name]: [1-sentence description]",
-    "2. ...",
-    "```",
+    "**If the codebase is sparse** (no README, empty project): fall back to Path 1 (ask the user about their product).",
     "",
-    `Then ask: **"Which of these are accurate? Reply with numbers to skip (e.g. 'skip 2, 4') or say 'all good' to capture everything."**`,
+    "_Prefer 5 specific entries over 8 generic ones. Skip anything that would apply to any codebase._",
     "",
-    "Once confirmed, call `capture` for each entry with `autoCommit: false` \u2014 the user will review before anything hits the Chain.",
+    "## Path 3: Preset",
     "",
-    '**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.',
+    "If the user picks a preset, call `start` again with `preset: '<chosen-preset>'`.",
     "",
-    "_Prefer 5 specific entries over 8 generic ones. Skip anything that would apply to any codebase._"
+    instructions.qualityNote
   ].join("\n");
   return {
     text,
-    structuredContent: {
-      stage: "blank",
-      oriented: false,
-      orientationStatus: "no_session"
-    }
+    structuredContent: { stage: "blank" }
   };
 }
 async function buildSeededResponse(wsCtx, readiness, agentSessionId) {
@@ -5815,18 +5973,7 @@ async function buildSeededResponse(wsCtx, readiness, agentSessionId) {
   } else {
     lines.push("No gaps detected \u2014 your workspace is filling up nicely. What would you like to work on?");
   }
-  let oriented = false;
-  let orientationStatus = "no_session";
-  if (agentSessionId) {
-    try {
-      await mcpCall("agent.markOriented", { sessionId: agentSessionId });
-      setSessionOriented(true);
-      oriented = true;
-      orientationStatus = "complete";
-    } catch {
-      orientationStatus = "failed";
-    }
-  }
+  const { oriented, orientationStatus } = await tryMarkOriented(agentSessionId);
   return {
     text: lines.join("\n"),
     structuredContent: {
@@ -5868,18 +6015,7 @@ Available presets: ${listPresets().map((p) => `\`${p.id}\``).join(", ")}`,
       skipped.push(`${col.name} (already exists)`);
     }
   }
-  let oriented = false;
-  let orientationStatus = "no_session";
-  if (agentSessionId) {
-    try {
-      await mcpCall("agent.markOriented", { sessionId: agentSessionId });
-      setSessionOriented(true);
-      oriented = true;
-      orientationStatus = "complete";
-    } catch {
-      orientationStatus = "failed";
-    }
-  }
+  const { oriented, orientationStatus } = await tryMarkOriented(agentSessionId);
   const lines = [
     `# ${wsCtx.workspaceName} is ready`,
     "",
@@ -6118,18 +6254,7 @@ async function buildOrientResponse(wsCtx, agentSessionId, errors) {
     for (const err of errors) lines.push(`- ${err}`);
     lines.push("");
   }
-  let oriented = false;
-  let orientationStatus = "no_session";
-  if (agentSessionId) {
-    try {
-      await mcpCall("agent.markOriented", { sessionId: agentSessionId });
-      setSessionOriented(true);
-      oriented = true;
-      orientationStatus = "complete";
-    } catch {
-      orientationStatus = "failed";
-    }
-  }
+  const { oriented, orientationStatus } = await tryMarkOriented(agentSessionId);
   return {
     text: lines.join("\n"),
     structuredContent: {
@@ -8167,15 +8292,20 @@ function registerHealthTools(server) {
           "Your workspace is fresh \u2014 let's set it up.",
           "",
           "**Recommended:** call the `start` tool instead of `orient` for the best first-run experience.",
-          "It will guide you through scanning your codebase and capturing initial knowledge.",
+          "It will guide you through setting up your workspace \u2014 you can tell me about your product, scan your codebase, or use a preset.",
           "",
           "Or tell me about your product and I'll start capturing knowledge directly."
         ];
+        let oriented = false;
+        let orientationStatus = "no_session";
         if (agentSessionId) {
           try {
             await mcpCall("agent.markOriented", { sessionId: agentSessionId });
             setSessionOriented(true);
+            oriented = true;
+            orientationStatus = "complete";
           } catch {
+            orientationStatus = "failed";
           }
         }
         return {
@@ -8183,7 +8313,8 @@ function registerHealthTools(server) {
           structuredContent: {
             stage: "blank",
             readinessScore: readiness?.score ?? 0,
-            oriented: true,
+            oriented,
+            orientationStatus,
             redirectHint: "Use the `start` tool for the full guided setup experience."
           }
         };
@@ -9320,9 +9451,14 @@ Each scored 0-10 by the server:
 
 ### Session Flow
 1. **Start:** \`facilitate action=start betName="${idea}"\`
-   Creates a draft bet on the Chain. Returns Studio URL and initial coaching prompt.
+   Starts shaping context only (no entry is created yet).
+
+2. **First respond:** \`facilitate action=respond betName="${idea}" userInput="<user's input>"\`
+   This creates the draft bet and captures the initial problem context.
+
+   Save \`captured.betEntryId\` from the response and reuse it for every subsequent call.
 
-2. **Respond (repeat):** \`facilitate action=respond betEntryId="..." userInput="<user's input>"\`
+3. **Respond (repeat):** \`facilitate action=respond betEntryId="..." userInput="<user's input>"\`
    Optionally add \`dimension="problem_clarity"\` to target a specific dimension.
 
    **CRITICAL \u2014 Capture is REQUIRED for structured items:**
@@ -9332,10 +9468,10 @@ Each scored 0-10 by the server:
    - No-gos: \`capture={type:"noGo", name:"...", description:"..."}\`
    Each element, risk, and no-go needs its own \`respond\` call with \`capture\`.
 
-3. **Score (anytime):** \`facilitate action=score betEntryId="..."\`
+4. **Score (anytime):** \`facilitate action=score betEntryId="..."\`
    Check the scorecard without advancing.
 
-4. **Resume:** \`facilitate action=resume betEntryId="..."\`
+5. **Resume:** \`facilitate action=resume betEntryId="..."\`
    Reconstruct session from Chain state if returning to an existing bet.
 
 ### Reading the Response
@@ -9819,4 +9955,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-AWDD44CN.js.map
+//# sourceMappingURL=chunk-ADLZPAEI.js.map