@productbrain/mcp 0.0.1-beta.33 → 0.0.1-beta.35

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

@@ -2316,23 +2316,40 @@ var SHAPE_WORKFLOW = {
   name: "Shape a Bet",
   shortDescription: "Coached shaping session \u2014 problem \u2192 appetite \u2192 elements \u2192 architecture \u2192 de-risk \u2192 pitch. Uses the `facilitate` tool for scoring and Chain capture.",
   icon: "\u25C6",
-  facilitatorPreamble: `You are now in **Shaping Mode**. You are a coached shaping facilitator powered by the \`facilitate\` tool.
+  facilitatorPreamble: `You are now in **Shaping Mode**. You are an **investigating** shaping facilitator powered by the \`facilitate\` tool and Cursor sub-agents.
 
 ## Your Behavior
 
-1. **Start with \`facilitate action=start\`.** This creates a draft bet on the Chain and returns the Studio URL + initial coaching.
-2. **Use \`facilitate action=respond\` for every user input.** Pass the user's text, the betEntryId, and the current dimension. The server scores, captures, and returns coaching.
-3. **Read the structured response carefully.** The coaching object tells you what to say next. The scorecard tells you what's missing. The overlap tells you what already exists.
-4. **One dimension at a time.** Follow the round progression below. Don't dump all dimensions at once.
-5. **Push back on vagueness.** "Who's affected?" and "What's the workaround?" are always valid questions.
-6. **Weave Chain context into coaching.** When chainSurfaced returns related entries, mention them: "The Chain has DEC-34 about this \u2014 does your solution align?"
+1. **Start with \`facilitate action=start\`.** This creates a draft bet on the Chain and returns the Studio URL, initial coaching, and an investigationBrief.
+2. **Investigate before asking.** At each phase transition, read the \`investigationBrief\` in the structured response. Spawn sub-agents to search the codebase and Chain. Synthesize findings into proposals. Present proposals for user reaction.
+3. **Use \`facilitate action=respond\` for every input.** Pass the user's text, betEntryId, dimension, and the \`source\` field:
+   - \`source="user"\` \u2014 user typed this directly (default, full score weight)
+   - \`source="agent_proposal"\` \u2014 you generated this proposal text (discounted score)
+   - \`source="user_reaction"\` \u2014 user reacting to your proposal (full score weight)
+4. **Read the structured response carefully.** The coaching object tells you what to say next. The scorecard tells you what's missing. The investigationBrief tells you what to investigate for the next phase.
+5. **One dimension at a time.** Follow the round progression below. Don't dump all dimensions at once.
+6. **Push back with evidence.** Don't just ask "Who's affected?" \u2014 search the codebase for evidence and say "I found 3 workarounds in the codebase related to this. Here's what they suggest about the problem."
 7. **Capture elements and risks inline** using the \`capture\` parameter on respond calls. Each becomes a Chain entry with a relation to the bet.
-8. **When captureReady is true, offer to finalize** \u2014 but don't force it. The user decides when the shape is complete.
+8. **CRITICAL: Elements, rabbit holes, and no-gos MUST use the \`capture\` parameter.** Never pass them as plain \`userInput\` without \`capture\`. Without \`capture\`, nothing is saved to the bet \u2014 the data is silently lost. Always include \`capture={type:"element"|"risk"|"noGo", name:"...", description:"..."}\` for every structured item. Each element, risk, and no-go needs its own \`respond\` call with \`capture\`.
+9. **When captureReady is true, offer to finalize** \u2014 but don't force it. The user decides when the shape is complete.
+
+## Investigation Pattern (ENT-59)
+
+At phase transitions, follow this pattern:
+1. Read the \`investigationBrief\` from the structured response
+2. Spawn sub-agents in parallel (max 2, 30s budget each):
+   - \`explore\` sub-agent: codebase searches (files, patterns, architecture)
+   - \`generalPurpose\` sub-agent: Chain searches (entries, governance, context)
+3. Synthesize findings into a concrete proposal (cite files and entry IDs)
+4. Present the proposal for user reaction \u2014 "Based on the codebase, I'd suggest..."
+5. Score the user's reaction with \`source="user_reaction"\` (full weight)
+
+If investigation fails or times out, continue with the conversation \u2014 the user's knowledge is always the primary input.
 
 ## DEC-56 Boundary
 
-The **server judges** \u2014 it scores input against 6 rubric dimensions, detects overlap, checks governance alignment.
-**You coach** \u2014 you interpret the structured response, synthesize naturally, follow up on weak areas, push back when shaping isn't sharp.
+The **server judges** \u2014 it scores input against 6 rubric dimensions, detects overlap, checks governance alignment. Agent-generated text is scored at ${0.6}x weight to prevent keyword inflation (RH1).
+**You coach** \u2014 you interpret the structured response, synthesize naturally, investigate proactively, propose grounded solutions, and push back when shaping isn't sharp.
 The \`coaching.suggestedQuestion\` is a suggestion, not a script \u2014 rephrase or skip based on conversation flow.
 
 ## Error Recovery
@@ -2349,7 +2366,8 @@ If any facilitate call fails:
 - Keep chat messages to 5 lines or fewer \u2014 heavy context degrades performance
 - Use AskQuestion for structured choices (appetite, gates)
 - Synthesize between phases \u2014 reflect what was decided before moving on
-- If the user seems stuck, offer prompts from the coaching.suggestedQuestion`,
+- When proposing, cite evidence: "I found X in the codebase" or "The Chain has DEC-Y about this"
+- If the user seems stuck, investigate and propose rather than just asking`,
   rounds: [
     {
       id: "context",
@@ -2357,7 +2375,7 @@ If any facilitate call fails:
       label: "Gather Context",
       type: "open",
       instruction: "Before shaping, let's see what the Chain already knows. Search for related entries, business rules, and existing decisions.",
-      facilitatorGuidance: "Call `orient` to load workspace context. Use `entries action=search` with keywords from the user's idea. Surface related tensions, active bets, and applicable business rules. Present a 3-5 line summary: related entries (with IDs), applicable rules, existing decisions. Then transition: 'Here's what's relevant on the Chain. Now tell me more about the problem.'",
+      facilitatorGuidance: "**Investigate proactively.** Spawn sub-agents in parallel: (1) `explore` agent to search the codebase for code related to the bet topic \u2014 find modules, patterns, and pain points. (2) `generalPurpose` agent to search the Chain: call `orient`, use `entries action=search` with keywords, surface related tensions, active bets, and applicable business rules. Synthesize both into a 3-5 line context brief: what the codebase reveals, what the Chain knows, what governance applies. Present with IDs and file paths. Then transition: 'Here's what I found. Does this match the problem you're seeing?'",
       outputSchema: {
         field: "context",
         description: "Chain context: related entries, governance, existing decisions",
@@ -2371,7 +2389,7 @@ If any facilitate call fails:
       label: "Frame the Problem",
       type: "open",
       instruction: "What's the problem? Who's affected? What's the workaround today? How much time is this worth?",
-      facilitatorGuidance: "This round covers problem_clarity AND appetite. Call `facilitate action=respond` with dimension='problem_clarity' for the problem input, then dimension='appetite' for the time budget. Push for a specific story: 'Tell me about the last time someone hit this.' Use AskQuestion for appetite: Small Batch (1-2 weeks) or Big Batch (6 weeks). When both dimensions score 6+, present the frame and ask for Frame Go confirmation. If new terms surfaced, capture them to the glossary via `capture`. If tensions surfaced, capture them too.",
+      facilitatorGuidance: "This round covers problem_clarity AND appetite. If the investigationBrief has framing tasks, search the codebase for workarounds, TODOs, and hacks related to the problem \u2014 cite what you find as evidence. Call `facilitate action=respond` with dimension='problem_clarity' for the problem input, then dimension='appetite' for the time budget. Push with evidence: 'I found 3 workaround patterns in the codebase \u2014 this suggests the problem is bigger than it looks.' Use AskQuestion for appetite: Small Batch (1-2 weeks) or Big Batch (6 weeks). When both dimensions score 6+, present the frame and ask for Frame Go confirmation. If new terms surfaced, capture them to the glossary via `capture`. If tensions surfaced, capture them too.",
       questions: [
         {
           id: "appetite",
@@ -2404,7 +2422,7 @@ If any facilitate call fails:
       label: "Find the Elements",
       type: "open",
       instruction: "What are the solution elements? Think breadboard level \u2014 places, affordances, connections. What's the architecture?",
-      facilitatorGuidance: "Walk through the solution at breadboard level. For each element the user describes, capture it inline: `facilitate action=respond ... capture={type:'element', name:'...', description:'...'}`. Each becomes a features entry linked to the bet. For Big Batch: also cover architecture \u2014 call respond with dimension='architecture' for architecture input. Check business rules: do any elements conflict with governance surfaced in Round 1? Capture new glossary terms and decisions as they surface. Aim for 3-5 elements. When elements score 6+ (and architecture for Big Batch), present for confirmation.",
+      facilitatorGuidance: "**Investigate first.** Read the investigationBrief. Spawn sub-agents to search the codebase for affected modules, existing architecture patterns, and API boundaries. Synthesize findings into 3-5 proposed solution elements at breadboard level, citing specific files and modules. Present proposals for user reaction: 'Based on the codebase, here are the elements I'd suggest.' For each confirmed element, capture with its own respond call: `facilitate action=respond betEntryId='...' dimension='elements' source='user_reaction' userInput='...' capture={type:'element', name:'Element Name', description:'What it does'}`. Without the `capture` parameter, the element is NOT saved to the bet \u2014 you will get a WARNING if you forget. Each captured element becomes a features entry linked to the bet via part_of. For Big Batch: also investigate architecture \u2014 search for layer boundaries and dependency directions, then propose architecture. Call respond with dimension='architecture' for architecture input (no capture needed \u2014 free-form text). Check business rules: do any elements conflict with governance surfaced in Round 1? Capture new glossary terms and decisions as they surface. Aim for 3-5 elements. When elements score 6+ (and architecture for Big Batch), present for confirmation.",
       outputSchema: {
         field: "elements",
         description: "Core solution elements and architecture",
@@ -2419,7 +2437,7 @@ If any facilitate call fails:
       label: "De-risk \u2014 Rabbit Holes & No-Gos",
       type: "open",
       instruction: "What could go wrong? What are we NOT building? Walk through the solution slowly and find the risks.",
-      facilitatorGuidance: "Hunt rabbit holes: 'Does this require new technical work?' 'Are we assuming a design solution exists?' For each risk, capture it inline: `facilitate action=respond ... capture={type:'risk', name:'...', description:'...', theme:'implementation'}`. Each becomes a tensions entry linked to the bet. Push for mitigations \u2014 every risk needs a patch or explicit acceptance. Then declare no-gos: 'What are we explicitly NOT building?' Update the bet with no-gos via `capture={type:'noGo', ...}`. When risks score 6+ and boundaries score 4+, present Shape Go gate: 'Is this buildable within the appetite?'",
+      facilitatorGuidance: "**Investigate first.** Read the investigationBrief. Spawn sub-agents to search the codebase for fragile code, tight coupling, missing tests, performance-sensitive paths, and external dependencies near the affected modules. Propose risks with evidence: 'I found that X module has no tests and is tightly coupled to Y \u2014 this is a rabbit hole.' Every confirmed risk MUST be captured with its own respond call: `facilitate action=respond betEntryId='...' dimension='risks' source='user_reaction' userInput='...' capture={type:'risk', name:'Risk Name', description:'What could go wrong', theme:'implementation'}`. Each becomes a tensions entry linked to the bet via constrains. Push for mitigations \u2014 every risk needs a patch or explicit acceptance. Then declare no-gos: 'Based on what I've seen, I'd suggest these no-gos.' Every no-go MUST use capture: `facilitate action=respond betEntryId='...' dimension='boundaries' source='user_reaction' userInput='...' capture={type:'noGo', name:'No-Go Title', description:'Why we are not doing this'}`. Without the `capture` parameter on each call, the item is NOT saved \u2014 you will get a WARNING. When risks score 6+ and boundaries score 4+, present Shape Go gate: 'Is this buildable within the appetite?'",
       questions: [
         {
           id: "shape-go",
@@ -2676,6 +2694,7 @@ This checkpoint was NOT saved. The conversation context is preserved \u2014 cont
 import { z as z12 } from "zod";
 
 // src/tools/facilitate-rubrics.ts
+var AGENT_DISCOUNT_FACTOR = 0.6;
 var DIMENSIONS = [
   "problem_clarity",
   "appetite",
@@ -3118,12 +3137,19 @@ var SCORERS = {
   boundaries: scoreBoundaries
 };
 function scoreDimension(dimension, ctx) {
-  return SCORERS[dimension](ctx);
+  const raw = SCORERS[dimension](ctx);
+  if (ctx.source === "agent_proposal") {
+    return {
+      ...raw,
+      score: clamp(Math.round(raw.score * AGENT_DISCOUNT_FACTOR), 0, 10)
+    };
+  }
+  return raw;
 }
 function scoreAll(ctx) {
   const results = {};
   for (const dim of DIMENSIONS) {
-    results[dim] = SCORERS[dim](ctx);
+    results[dim] = scoreDimension(dim, ctx);
   }
   return results;
 }
@@ -3212,6 +3238,57 @@ function extractPhrase(text, maxLen) {
 function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
+var PHASE_INVESTIGATIONS = {
+  context: (betName) => ({
+    phase: "context",
+    dimension: "problem_clarity",
+    tasks: [
+      { target: "chain", query: `Search for entries related to: ${betName}`, purpose: "Find existing tensions, decisions, and bets that overlap" },
+      { target: "chain", query: "List active governance: principles, standards, business-rules", purpose: "Surface constraints the solution must honor" },
+      { target: "codebase", query: `Search for code related to: ${betName}`, purpose: "Understand current implementation and pain points" }
+    ],
+    proposalGuidance: "Synthesize findings into a 3-5 line context brief: what the Chain knows, what the codebase reveals, what governance applies.",
+    reactionPrompt: "Here's what I found. Does this match what you're seeing, or is the problem different from what the Chain suggests?"
+  }),
+  framing: (betName) => ({
+    phase: "framing",
+    dimension: "problem_clarity",
+    tasks: [
+      { target: "codebase", query: `Find workarounds, TODOs, or hacks related to: ${betName}`, purpose: "Surface concrete evidence of the problem" },
+      { target: "chain", query: "Search for related tensions and user complaints", purpose: "Quantify how often this problem occurs" }
+    ],
+    proposalGuidance: "Propose a problem statement based on codebase evidence. Include who's affected and what the workaround looks like in the code.",
+    reactionPrompt: "Based on the codebase, here's a draft problem statement. Does this capture it, or is the real problem different?"
+  }),
+  elements: (betName) => ({
+    phase: "elements",
+    dimension: "elements",
+    tasks: [
+      { target: "codebase", query: `Find modules, services, and components that would be affected by: ${betName}`, purpose: "Map the solution to existing architecture" },
+      { target: "architecture", query: "Identify layer boundaries, API contracts, and dependency directions", purpose: "Ground elements in real architecture" },
+      { target: "chain", query: "Check DEC-31, STA-3, and other architecture standards", purpose: "Ensure elements respect existing decisions" }
+    ],
+    proposalGuidance: "Propose 3-5 solution elements at breadboard level. Each element should name the layer it lives in, what it does, and how it connects to existing code.",
+    reactionPrompt: "I've mapped out these solution elements based on the codebase. Which feel right? Which need adjustment?"
+  }),
+  derisking: (betName) => ({
+    phase: "derisking",
+    dimension: "risks",
+    tasks: [
+      { target: "codebase", query: `Find fragile code, tight coupling, or missing tests near: ${betName}`, purpose: "Surface technical risks from code" },
+      { target: "codebase", query: "Check for performance-sensitive paths, database queries, and external dependencies", purpose: "Identify performance and reliability risks" },
+      { target: "chain", query: "Search for related tensions and past decisions that constrain this solution", purpose: "Surface risks from existing constraints" }
+    ],
+    proposalGuidance: "Propose rabbit holes with severity and mitigations. Each risk should cite specific code or Chain evidence. Also propose no-gos \u2014 what should be explicitly excluded.",
+    reactionPrompt: "These are the risks I found in the codebase. Are these real concerns? What am I missing?"
+  }),
+  validation: () => null,
+  capture: () => null
+};
+function buildInvestigationBrief(phase, betName, betEntryId) {
+  const builder = PHASE_INVESTIGATIONS[phase];
+  return builder(betName, betEntryId);
+}
 function generateBuildContract(ctx) {
   const lines = ["## Build Contract"];
   const consult = [
@@ -3283,6 +3360,7 @@ var facilitateSchema = z12.object({
   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"),
@@ -3359,8 +3437,11 @@ function buildDirective(scorecard, phase, betEntryId, captureReady, activeDimens
       `1. **Go** \u2014 move to solution elements`,
       `2. **Refine** \u2014 something's not right, let's adjust`,
       ``,
-      `If Go: ask "What are the solution pieces? Think breadboard \u2014 places, affordances, connections."`,
-      `Then call \`facilitate action=respond betEntryId="${b}" dimension="elements"\` with their answer.`,
+      `If Go: **investigate first** \u2014 use the investigationBrief in the structured response to search the codebase and Chain.`,
+      `Spawn sub-agents to explore the codebase for affected modules, existing architecture, and related patterns.`,
+      `Then propose 3-5 solution elements grounded in what you found.`,
+      `Present proposals for user reaction: "Based on the codebase, here are the elements I'd suggest. Which feel right?"`,
+      `For each confirmed element, call \`facilitate action=respond betEntryId="${b}" dimension="elements" source="user_reaction"\` with the user's reaction.`,
       `If Refine: ask what needs adjusting, then call respond with dimension="problem_clarity" or "appetite".`
     ].join("\n");
   }
@@ -3392,6 +3473,17 @@ function buildDirective(scorecard, phase, betEntryId, captureReady, activeDimens
   }
   if (nextDimension && nextDimension !== activeDimension) {
     const nextLabel = DIMENSION_LABELS[nextDimension];
+    const investigationPhases = ["elements", "architecture", "risks", "boundaries"];
+    const shouldInvestigate = investigationPhases.includes(nextDimension);
+    if (shouldInvestigate) {
+      return [
+        `Briefly synthesize what was just covered (2 lines max), then move to **${nextLabel}**.`,
+        `**Investigate first:** Use the investigationBrief to search the codebase and Chain before asking the user.`,
+        `Spawn sub-agents to gather evidence, then propose findings for user reaction.`,
+        `After the user reacts, call \`facilitate action=respond betEntryId="${b}" dimension="${nextDimension}" source="user_reaction"\` with their reaction.`,
+        `If the user provides their own input instead, call with source="user".`
+      ].join("\n");
+    }
     return [
       `Briefly synthesize what was just covered (2 lines max), then move to **${nextLabel}**.`,
       `Ask ONE open question about ${nextLabel.toLowerCase()}. Keep it to 3 lines.`,
@@ -3499,7 +3591,7 @@ async function loadSessionDrafts(betEntryId, betInternalId) {
     return [];
   }
 }
-function buildScoringContext(userInput, betData, constellation, overlapIds, chainSurfaced = [], activeDimension) {
+function buildScoringContext(userInput, betData, constellation, overlapIds, chainSurfaced = [], activeDimension, source = "user") {
   const str = (key) => betData[key] ?? "";
   const accParts = [
     str("problem"),
@@ -3539,7 +3631,8 @@ function buildScoringContext(userInput, betData, constellation, overlapIds, chai
     noGoCount,
     governanceCount,
     decisionCount: constellation.decisionCount,
-    hasArchitectureText
+    hasArchitectureText,
+    source
   };
 }
 async function searchOverlap(text) {
@@ -3632,6 +3725,12 @@ async function handleStart2(args) {
         status: "draft",
         data: {
           problem: "",
+          appetite: "",
+          elements: "",
+          rabbitHoles: "",
+          noGos: "",
+          architecture: "",
+          buildContract: "",
           description: `Shaping session for: ${betName}`,
           status: "shaping",
           shapingSessionActive: true
@@ -3652,6 +3751,10 @@ async function handleStart2(args) {
   }
   const studioUrl = buildStudioUrl(wsCtx.workspaceSlug, betEntryId);
   const response = emptyResponse(betEntryId, studioUrl);
+  const investigationBrief = buildInvestigationBrief("context", betName, betEntryId);
+  if (investigationBrief) {
+    response.investigationBrief = investigationBrief;
+  }
   const output = [
     `# Shaping Session Started`,
     "",
@@ -3665,9 +3768,10 @@ async function handleStart2(args) {
     "",
     "---",
     "## Agent Directive",
-    "Present the workspace context above, then ask the user ONE open question at a time.",
-    "Start with: **What's not working well? Describe the problem \u2014 who's affected, and what's the workaround today?**",
-    "Do NOT list multiple questions as bullets. Ask ONE question, wait for the answer.",
+    "**Investigate first** \u2014 before asking the user, use the investigationBrief to search the codebase and Chain for context related to this bet.",
+    "Spawn sub-agents: one `explore` agent to search the codebase, one `generalPurpose` agent to search the Chain.",
+    "Synthesize findings into a 3-5 line context brief, then present to the user.",
+    "After presenting context, ask: **What's not working well? Describe the problem \u2014 who's affected, and what's the workaround today?**",
     "Keep your message to 5 lines or fewer. Heavy context degrades the shaping experience.",
     `After the user responds, call \`facilitate action=respond betEntryId="${betEntryId}" dimension="problem_clarity"\` with their answer as userInput.`
   ].filter(Boolean).join("\n");
@@ -3678,7 +3782,8 @@ async function handleStart2(args) {
 }
 async function handleRespond(args) {
   requireWriteAccess();
-  const { userInput, betEntryId: argBetId, dimension: argDimension, capture: captureArg } = args;
+  const { userInput, betEntryId: argBetId, dimension: argDimension, capture: captureArg, source: argSource } = args;
+  const source = argSource ?? "user";
   if (!userInput) {
     return {
       content: [{ type: "text", text: "`userInput` is required for respond action." }]
@@ -3695,7 +3800,7 @@ async function handleRespond(args) {
   const [betEntry, constellation, overlap, chainSurfaced] = await Promise.all([
     loadBetEntry(argBetId),
     loadConstellationState(argBetId),
-    searchOverlap(userInput),
+    captureArg ? Promise.resolve([]) : searchOverlap(userInput),
     gatherChainContext(userInput)
   ]);
   if (!betEntry) {
@@ -3843,7 +3948,7 @@ async function handleRespond(args) {
   if (argDimension && DIMENSIONS.includes(argDimension)) {
     activeDimension = argDimension;
   } else {
-    const prelim = buildScoringContext(userInput, refreshedData, refreshedConstellation, overlapIds, chainSurfaced);
+    const prelim = buildScoringContext(userInput, refreshedData, refreshedConstellation, overlapIds, chainSurfaced, void 0, source);
     activeDimension = inferActiveDimension(buildScorecard(prelim), isSmallBatch);
   }
   const scoringCtx = buildScoringContext(
@@ -3852,7 +3957,8 @@ async function handleRespond(args) {
     refreshedConstellation,
     overlapIds,
     chainSurfaced,
-    activeDimension
+    activeDimension,
+    source
   );
   const dimensionResult = scoreDimension(activeDimension, scoringCtx);
   const scorecard = buildScorecard(scoringCtx);
@@ -3869,10 +3975,7 @@ async function handleRespond(args) {
     };
     persist("problem_clarity", "problem", 50);
     persist("appetite", "appetite", 20);
-    persist("elements", "elements", 50);
     persist("architecture", "architecture", 50);
-    persist("risks", "rabbitHoles", 50);
-    persist("boundaries", "noGos", 20);
     if (overlapIds.length > 0 && !refreshedData._overlapIds) {
       fieldUpdates._overlapIds = overlapIds.join(",");
     }
@@ -3906,7 +4009,7 @@ async function handleRespond(args) {
   const dims = activeDimensions(isSmallBatch);
   const captureReady = completed.length >= (isSmallBatch ? 3 : 4) && dims.every((d) => scorecard[d] > 0);
   const observation = dimensionResult.satisfied.length > 0 ? `${DIMENSION_LABELS[activeDimension]}: ${dimensionResult.satisfied.join("; ")}` : `${DIMENSION_LABELS[activeDimension]}: needs more detail`;
-  const pushback = 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 = !captureArg && overlap.length > 0 ? `${overlap[0].summary} already exists on the Chain. How does your bet differ?` : dimensionResult.missing.length > 0 ? dimensionResult.missing[0] : "";
   const suggestedQuestion = dimensionResult.missing.length > 1 ? dimensionResult.missing[1] : dimensionResult.missing.length > 0 ? dimensionResult.missing[0] : `${DIMENSION_LABELS[nextDimension]} is next \u2014 ready to move on?`;
   const wsCtx = await getWorkspaceContext();
   const studioUrl = buildStudioUrl(wsCtx.workspaceSlug, argBetId);
@@ -3922,6 +4025,8 @@ async function handleRespond(args) {
   }
   const suggested = suggestCaptures(scoringCtx, activeDimension);
   const sessionDrafts = await loadSessionDrafts(argBetId, refreshedBet?._id ?? betEntry._id);
+  const betName = refreshedData.description ?? betEntry.name;
+  const investigationBrief = buildInvestigationBrief(phase, betName, argBetId) ?? void 0;
   const response = {
     phase,
     phaseLabel: PHASE_LABELS[phase],
@@ -3951,12 +4056,21 @@ async function handleRespond(args) {
       activeDimension,
       suggestedOrder: dims
     },
-    buildContract
+    buildContract,
+    investigationBrief
+  };
+  const STRUCTURED_DIMS = {
+    elements: "element",
+    risks: "risk",
+    boundaries: "noGo"
   };
+  const expectedCaptureType = STRUCTURED_DIMS[activeDimension];
+  const dataLossWarning = expectedCaptureType && !captureArg ? `**WARNING:** You discussed ${activeDimension} but did not use the \`capture\` parameter \u2014 nothing was saved to the bet. Re-send with \`capture={type:"${expectedCaptureType}", name:"...", description:"..."}\` to persist this.` : "";
   const directive = buildDirective(scorecard, phase, argBetId, captureReady, activeDimension, nextDimension);
   const summaryParts = [
     `# ${PHASE_LABELS[phase]} \u2014 ${DIMENSION_LABELS[activeDimension]}`,
     "",
+    dataLossWarning,
     `**Score:** ${scorecard[activeDimension]}/10 | **Phase:** ${PHASE_LABELS[phase]}`,
     observation,
     pushback ? `**Pushback:** ${pushback}` : "",
@@ -3969,7 +4083,13 @@ async function handleRespond(args) {
     directive ? `
 ---
 ## Agent Directive
-${directive}` : ""
+${directive}` : "",
+    investigationBrief ? `
+## Investigation Brief
+${investigationBrief.tasks.map((t) => `- **${t.target}:** ${t.query} \u2014 ${t.purpose}`).join("\n")}
+
+**Proposal guidance:** ${investigationBrief.proposalGuidance}
+**Reaction prompt:** ${investigationBrief.reactionPrompt}` : ""
   ];
   return {
     content: [{ type: "text", text: summaryParts.filter(Boolean).join("\n") }],
@@ -6983,6 +7103,12 @@ function registerHealthTools(server) {
     async ({ mode = "full", task } = {}) => {
       const errors = [];
       const agentSessionId = getAgentSessionId();
+      if (isSessionOriented() && mode === "brief" && !task) {
+        return {
+          content: [{ type: "text", text: "Already oriented. Session active, writes unlocked. Use `orient mode='full'` or `orient task='...'` for full context." }],
+          structuredContent: { alreadyOriented: true, sessionId: agentSessionId }
+        };
+      }
       let wsCtx = null;
       try {
         wsCtx = await getWorkspaceContext();
@@ -8082,8 +8208,13 @@ Each scored 0-10 by the server:
 
 2. **Respond (repeat):** \`facilitate action=respond betEntryId="..." userInput="<user's input>"\`
    Optionally add \`dimension="problem_clarity"\` to target a specific dimension.
-   Optionally add \`capture={type:"element", name:"...", description:"..."}\` to capture inline.
-   The server scores, searches for overlap, captures to Chain, and returns coaching.
+
+   **CRITICAL \u2014 Capture is REQUIRED for structured items:**
+   Elements, risks, and no-gos MUST include the \`capture\` parameter. Without it, nothing is saved to the bet \u2014 the data is silently lost and you will receive a WARNING.
+   - Elements: \`capture={type:"element", name:"...", description:"..."}\`
+   - Risks: \`capture={type:"risk", name:"...", description:"...", theme:"implementation"}\`
+   - No-gos: \`capture={type:"noGo", name:"...", description:"..."}\`
+   Each element, risk, and no-go needs its own \`respond\` call with \`capture\`.
 
 3. **Score (anytime):** \`facilitate action=score betEntryId="..."\`
    Check the scorecard without advancing.
@@ -8345,7 +8476,7 @@ If ready, ask the user to confirm. If not, suggest specific improvements.
 }
 
 // src/server.ts
-var SERVER_VERSION = "0.7.1";
+var SERVER_VERSION = "0.7.2";
 var INSTRUCTIONS = [
   "Product Brain \u2014 the single source of truth for product knowledge.",
   "Terminology, standards, and core data all live here \u2014 no need to check external docs.",
@@ -8456,4 +8587,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-CWNAQXZX.js.map
+//# sourceMappingURL=chunk-HTL6Y2AO.js.map