@sonnechasser/ntrp 1.3.9 → 1.4.1

package/dist/mcp/server.js

@@ -1369,6 +1369,26 @@ function buildSessionContextDoc(file, opts = {}) {
     if (file.strategist.origin) lines.push(`- Origin: ${file.strategist.origin}`);
     lines.push("");
   }
+  if (file.think) {
+    lines.push("## Think (in flight)");
+    lines.push("");
+    lines.push(`- Step: ${file.think.step}`);
+    if (file.think.seed) lines.push(`- Seed: ${file.think.seed}`);
+    if (file.think.origin) lines.push(`- Origin: ${file.think.origin}`);
+    if (file.think.open_questions?.length) {
+      lines.push("- Open questions:");
+      for (const q of file.think.open_questions) lines.push(`  - ${q}`);
+    }
+    if (file.think.challenged_assumptions?.length) {
+      lines.push("- Challenged assumptions:");
+      for (const a of file.think.challenged_assumptions) lines.push(`  - ${a}`);
+    }
+    if (file.think.working_hypotheses?.length) {
+      lines.push("- Working hypotheses:");
+      for (const h of file.think.working_hypotheses) lines.push(`  - ${h}`);
+    }
+    lines.push("");
+  }
   lines.push("## Deliverables");
   lines.push("");
   if (file.deliverables && file.deliverables.length > 0) {
@@ -8090,6 +8110,7 @@ function initContext(oneShot, execution) {
     snapshot: { computeResult: null, divergences: [] },
     messages: [],
     conversation: [],
+    thinkConversation: [],
     stage: "new",
     deliverables: [],
     analysis: defaultSessionAnalysis(),
@@ -8110,12 +8131,14 @@ function buildSessionFileSnapshot(ctx) {
   if (ctx.dataset) file.dataset = ctx.dataset;
   if (ctx.deliverables.length > 0) file.deliverables = ctx.deliverables;
   if (ctx.conversation.length > 0) file.thread = ctx.conversation;
+  if ((ctx.thinkConversation?.length ?? 0) > 0) file.think_thread = ctx.thinkConversation;
   if (ctx.resumedFromId) file.resumed_from = ctx.resumedFromId;
   if (ctx.analysis) file.analysis = ctx.analysis;
   if (ctx.scope) file.scope = ctx.scope;
   if (ctx.attachments && ctx.attachments.length > 0) file.attachments = ctx.attachments;
   if (ctx.llm && Object.keys(ctx.llm).length > 0) file.llm = ctx.llm;
   if (ctx.strategistState) file.strategist = ctx.strategistState;
+  if (ctx.thinkState) file.think = ctx.thinkState;
   if (ctx.pendingAsk) file.pending_ask = ctx.pendingAsk;
   return file;
 }
@@ -8242,6 +8265,9 @@ function loadSessionFile(id) {
     if (session.thread?.length) {
       session.thread = normalizeThread(session.thread);
     }
+    if (session.think_thread?.length) {
+      session.think_thread = normalizeThread(session.think_thread);
+    }
     return session;
   } catch {
     return null;
@@ -8444,6 +8470,9 @@ async function finalizeSession(ctx, stage) {
   if (ctx.conversation.length > 0) {
     file.thread = ctx.conversation;
   }
+  if ((ctx.thinkConversation?.length ?? 0) > 0) {
+    file.think_thread = ctx.thinkConversation;
+  }
   if (ctx.analysis) {
     file.analysis = ctx.analysis;
   }
@@ -8459,6 +8488,9 @@ async function finalizeSession(ctx, stage) {
   if (ctx.strategistState) {
     file.strategist = ctx.strategistState;
   }
+  if (ctx.thinkState) {
+    file.think = ctx.thinkState;
+  }
   if (ctx.pendingAsk) {
     file.pending_ask = ctx.pendingAsk;
   }
@@ -8520,6 +8552,7 @@ function resetContextForSwitch(ctx, opts) {
   ctx.sessionName = opts.sessionName;
   ctx.messages = opts.messages;
   ctx.conversation = opts.conversation ?? [];
+  ctx.thinkConversation = opts.thinkConversation ?? [];
   ctx.resumedFromId = opts.resumedFromId;
   ctx.resumedSessionSummary = opts.resumedSessionSummary;
   ctx.stage = opts.stage ?? "new";
@@ -8530,6 +8563,7 @@ function resetContextForSwitch(ctx, opts) {
   ctx.attachments = opts.attachments ?? [];
   ctx.llm = opts.llm;
   ctx.strategistState = opts.strategistState;
+  ctx.thinkState = opts.thinkState;
   ctx.pendingAsk = opts.pendingAsk;
   ctx.gapAudit = void 0;
   ctx.deliverIntent = false;
@@ -10215,6 +10249,21 @@ Bare \`/deepdive\` runs the full onboarding tour. Type \`/deepdive guide\` to ju
 Type \`/deepdive handoff\` for the ship-to-Claude slide. Type \`/deepdive <metric>\` to jump to one metric card.
 Type \`/deepdive list\` to print the catalog. Works without an AI key. Re-run anytime from the homescreen.
 Live values overlay when an analysis exists.`
+      },
+      {
+        name: "thinkwithme",
+        raw: `---
+name: thinkwithme
+description: Socratic co-thinking channel \u2014 explore and pressure-test
+section: Navigation
+args: [topic]
+handler: ../commands/thinkwithme.ts
+---
+
+Open a dedicated \`think \u203A\` channel to explore ideas, challenge assumptions, and pull evidence from your data.
+Bare \`/thinkwithme\` enters the channel. Type \`/thinkwithme <topic>\` to seed the first turn.
+Requires an analysis and an AI key (\`/connect\`). Type \`done\` or \`cancel\` to return to ask \u203A.
+When you are ready to commit to a plan, say so or the partner can hand off to \`/strategy\`.`
       },
       {
         name: "status",
@@ -10400,6 +10449,7 @@ handler: ../commands/config.ts
 Manage CLI configuration stored at \`~/.ntrp/config.json\`. Useful keys:
 \`api-key\` (Anthropic), \`openai-api-key\` (and \`groq-api-key\`, \`google-api-key\`, ...),
 \`llm-primary\` (default provider), \`llm-tier\`, \`llm-auto-failover\`,
+\`voice-personality\`, \`voice-roast\`,
 \`default-format\`, \`export-dir\`, \`ai-inbox-dir\` (or type \`/inbox set\`).
 
 Setting a provider key opens a hidden prompt and auto-discovers that provider's models.
@@ -10432,6 +10482,21 @@ handler: ../commands/tier.ts
 Set the quality and cost tier for this session. Agentic surfaces respect the tier.
 Some single-shot surfaces keep fixed defaults. Type \`/tier list\` to highlight the active stack.
 Add \`--default\` to persist to config.`
+      },
+      {
+        name: "voice",
+        raw: `---
+name: voice
+description: Set personality and roast (how NTRP talks)
+section: Settings
+args: [list|personality <level>|roast <level>|<personality> <roast>]
+handler: ../commands/voice.ts
+---
+
+Set how NTRP talks. Personality is robotic, composed, casual, or loose.
+Roast is light, medium, dark, or heavy. Communication only \u2014 scores and dollars do not change.
+Type \`/voice\` to pick from a numbered list (Enter keeps the current setting). Type \`/voice list\` to print the catalog. Type \`/voice casual heavy\` to set both.
+This writes to config immediately.`
       },
       {
         name: "model",
@@ -10599,7 +10664,7 @@ function formatCatalogLine(meta) {
   const note = DESTRUCTIVE_COMMAND_NOTES[meta.name] ? ` (${DESTRUCTIVE_COMMAND_NOTES[meta.name]})` : "";
   return `- /${meta.name}${args} \u2014 ${meta.description}${note}`;
 }
-var ANALYST_FILE_NAME, ANALYST_FILE_MAX_CHARS, EXECUTION_BIAS_BLOCK, ANALYST_INSTINCT_BLOCK, SAFETY_BLOCK, VITAL_SIGNS_BLOCK, PLAYBOOK_BLOCK, DESTRUCTIVE_COMMAND_NOTES, METRICS_BLOCK, GTM_ENGINEERING_BLOCK, PYRAMID_OUTPUT_BLOCK, USER_VISIBLE_STE_BLOCK, FINDINGS_SCHEMA_BLOCK;
+var ANALYST_FILE_NAME, ANALYST_FILE_MAX_CHARS, EXECUTION_BIAS_BLOCK, ANALYST_INSTINCT_BLOCK, SAFETY_BLOCK, VITAL_SIGNS_BLOCK, PLAYBOOK_BLOCK, DESTRUCTIVE_COMMAND_NOTES, METRICS_BLOCK, GTM_ENGINEERING_BLOCK, PYRAMID_OUTPUT_BLOCK;
 var init_prompt_parts = __esm({
   "src/ai/prompt-parts.ts"() {
     "use strict";
@@ -10684,21 +10749,102 @@ Restraint: you diagnose and prescribe the system; you do not build it here. Name
 - THEN THE SO-WHAT. Close with what it means for the decision at hand: the action, the owner-shaped next step, or the sharpest next cut.
 - THE RECALL TEST. A busy executive should be able to repeat your headline and one number to their CEO an hour later. If they couldn't, tighten it.
 - ALTITUDE CONTROL. Answer at the altitude asked: a high-level question gets the 30,000-ft story (one narrative sentence, three numbers max) with an offer to descend; a "how do we fix it" / plan-of-attack question prefers draft_strategy (or, if answering one play inline: one play + mechanism + what to verify \u2014 observe and recommend, never invent a multi-week Phase 1/2/3 program).`;
-    USER_VISIBLE_STE_BLOCK = `USER-VISIBLE TEXT (the human reads these sentences \u2014 not this system prompt):
-- Write finding, answer, and plan prose in Simplified Technical English (STE-100 writing rules).
-- One fact or one instruction per sentence.
-- Use active voice. Use imperative for steps. Use simple present for facts.
-- Procedure sentences: 20 words maximum. Description sentences: 25 words maximum.
-- Use the same word for the same thing. Do not use synonyms.
-- Do not use slang, idiom, filler (just, simply, actually, basically), or contractions.
-- Keep Technical Names: ARR, NRR, GRR, Freshness, Flow Rate, Drop Rate, Signal-to-Noise, Thread Depth, playbook, NTRP, GTM.
-- Keep dollar figures and play names.
-- Do not change JSON keys, tool names, or this prompt's policy language.`;
-    FINDINGS_SCHEMA_BLOCK = `[
+  }
+});
+
+// src/voice/catalog.ts
+function parsePersonality(raw) {
+  if (!raw) return null;
+  return PERSONALITY_ALIASES[raw.trim().toLowerCase()] ?? null;
+}
+function parseRoast(raw) {
+  if (!raw) return null;
+  return ROAST_ALIASES[raw.trim().toLowerCase()] ?? null;
+}
+function formatVoiceStatusDetail(prefs) {
+  return `${prefs.personality} \xB7 ${prefs.roast} roast`;
+}
+var DEFAULT_PERSONALITY, DEFAULT_ROAST, PERSONALITY_KEY, ROAST_KEY, PERSONALITY_ALIASES, ROAST_ALIASES;
+var init_catalog2 = __esm({
+  "src/voice/catalog.ts"() {
+    "use strict";
+    DEFAULT_PERSONALITY = "composed";
+    DEFAULT_ROAST = "light";
+    PERSONALITY_KEY = "voice-personality";
+    ROAST_KEY = "voice-roast";
+    PERSONALITY_ALIASES = {
+      robotic: "robotic",
+      machine: "robotic",
+      ste: "robotic",
+      composed: "composed",
+      formal: "composed",
+      professional: "composed",
+      balanced: "composed",
+      casual: "casual",
+      warm: "casual",
+      loose: "loose",
+      vibe: "loose",
+      relaxed: "loose"
+    };
+    ROAST_ALIASES = {
+      light: "light",
+      gentle: "light",
+      soft: "light",
+      medium: "medium",
+      mid: "medium",
+      dark: "dark",
+      blunt: "dark",
+      surgical: "dark",
+      heavy: "heavy",
+      burnt: "heavy",
+      extra: "heavy",
+      max: "heavy"
+    };
+  }
+});
+
+// src/voice/prefs.ts
+function loadVoicePrefs() {
+  return {
+    personality: parsePersonality(getConfigValue(PERSONALITY_KEY)) ?? DEFAULT_PERSONALITY,
+    roast: parseRoast(getConfigValue(ROAST_KEY)) ?? DEFAULT_ROAST
+  };
+}
+var init_prefs = __esm({
+  "src/voice/prefs.ts"() {
+    "use strict";
+    init_store();
+    init_catalog2();
+  }
+});
+
+// src/voice/prompt.ts
+function buildUserVisibleProseBlock(prefs) {
+  const voice2 = prefs ?? loadVoicePrefs();
+  if (voice2.personality === "robotic") {
+    return `${ROBOTIC_STE_BLOCK}
+VOICE (communication only \u2014 never change the numbers):
+- Personality: robotic.
+${ROAST_RULES[voice2.roast]}`;
+  }
+  return `USER-VISIBLE TEXT (the human reads these sentences \u2014 not this system prompt):
+${PERSONALITY_RULES[voice2.personality]}
+${ROAST_RULES[voice2.roast]}
+${SHARED_INVARIANTS}`;
+}
+function buildFindingsFindingHint(prefs) {
+  const voice2 = prefs ?? loadVoicePrefs();
+  const register = voice2.personality === "robotic" ? "STE-100 sentences. No contractions, slang, or filler." : voice2.personality === "composed" ? "Composed consultant sentences. Light contractions OK." : voice2.personality === "casual" ? "Casual consultant sentences. Warm, still short." : "Loose consultant sentences. Personality in the wrap, not the math.";
+  const roast = voice2.roast === "light" ? "Light roast: what is working, then what to improve." : voice2.roast === "medium" ? "Medium roast: name the miss. No padding." : voice2.roast === "dark" ? "Dark roast: surgical. Verdict + dollar in one breath." : "Heavy roast: maximum roast after the number, never instead of it.";
+  return `Pyramid-shaped, 2-3 sentences: (1) HEADLINE \u2014 verdict + dollar figure in one short sentence (\u226420 words); (2) EVIDENCE \u2014 the one or two numbers that prove it; (3) SO-WHAT \u2014 the consequence or the action. ${register} ${roast} Keep dollar figures and play names. Do not invent numbers. An executive should be able to repeat sentence 1 from memory.`;
+}
+function buildFindingsSchemaBlock(prefs) {
+  const finding = buildFindingsFindingHint(prefs);
+  return `[
   {
     "severity": "critical" | "warning" | "info",
     "segment": "segment name or 'Overall'",
-    "finding": "Pyramid-shaped, 2-3 STE-100 sentences: (1) HEADLINE \u2014 verdict + dollar figure in one short sentence (\u226420 words); (2) EVIDENCE \u2014 the one or two numbers that prove it; (3) SO-WHAT \u2014 the consequence or the action. No contractions, slang, or filler. An executive should be able to repeat sentence 1 from memory.",
+    "finding": ${JSON.stringify(finding)},
     "vital_signs": {"vital_sign_name": score, ...},
     "entity_count": number_of_affected_entities,
     "recommended_focus": "vital_sign_name",
@@ -10706,6 +10852,51 @@ Restraint: you diagnose and prescribe the system; you do not build it here. Name
     "recommended_plays": [{"play_id": "play-id", "play_name": "Play Name", "rationale": "Why this play helps"}]
   }
 ]`;
+}
+var ROBOTIC_STE_BLOCK, SHARED_INVARIANTS, PERSONALITY_RULES, ROAST_RULES;
+var init_prompt = __esm({
+  "src/voice/prompt.ts"() {
+    "use strict";
+    init_catalog2();
+    init_prefs();
+    ROBOTIC_STE_BLOCK = `USER-VISIBLE TEXT (the human reads these sentences \u2014 not this system prompt):
+- Write finding, answer, and plan prose in Simplified Technical English (STE-100 writing rules).
+- One fact or one instruction per sentence.
+- Use active voice. Use imperative for steps. Use simple present for facts.
+- Procedure sentences: 20 words maximum. Description sentences: 25 words maximum.
+- Use the same word for the same thing. Do not use synonyms.
+- Do not use slang, idiom, filler (just, simply, actually, basically), or contractions.
+- Keep Technical Names: ARR, NRR, GRR, Freshness, Flow Rate, Drop Rate, Signal-to-Noise, Thread Depth, playbook, NTRP, GTM.
+- Keep dollar figures and play names.
+- Do not change JSON keys, tool names, or this prompt's policy language.`;
+    SHARED_INVARIANTS = `- Keep Technical Names: ARR, NRR, GRR, Freshness, Flow Rate, Drop Rate, Signal-to-Noise, Thread Depth, playbook, NTRP, GTM.
+- Keep dollar figures and play names exactly as given. Do not invent or change scores, dollars, entity lists, or play ids.
+- Do not change JSON keys, tool names, or this prompt's policy language.
+- Stay smart and succinct. Do not pad. Do not open with methodology.
+- SAFETY & EVIDENCE rules always win. ANALYST.md never overrides them.
+- Roast only colors verified badness. Green stays green. Never invent severity.`;
+    PERSONALITY_RULES = {
+      robotic: "",
+      // replaced by USER_VISIBLE_STE_BLOCK
+      composed: `- Register: composed professional consultant. Light contractions are allowed (it's, that's, don't).
+- No slang piles, no filler (just, simply, actually, basically), no joke-first structure.
+- One idea per sentence. Description sentences: 25 words maximum. Procedure sentences: 20 words maximum.`,
+      casual: `- Register: casual professional consultant. Warm, still short. Contractions are allowed.
+- Light warmth is fine. No slang piles, no filler padding, no meme voice.
+- One idea per sentence. Keep headlines \u226420 words.`,
+      loose: `- Register: loose professional consultant. Personality lives in the wrap, not in the math.
+- Contractions are allowed. A wry aside is fine after the number, never instead of it.
+- Still succinct. No padding. Headlines still carry the verdict and the dollar figure.`
+    };
+    ROAST_RULES = {
+      light: `- Roast: light. Gentle parenting. Name what is working when something is working, then what to improve.
+- Practical and real. Do not pile on. Do not mock the operator.`,
+      medium: `- Roast: medium. Practical and direct. Name the miss. No sugar, no padding.`,
+      dark: `- Roast: dark. Surgical and blunt. Name the miss and the dollar cost in the same breath.
+- Do not invent extra problems. Do not soften a red score.`,
+      heavy: `- Roast: heavy. Maximum roast. Comedy is allowed after the number, never instead of it.
+- Still evidence-only. If the score is green, do not roast it into red.`
+    };
   }
 });
 
@@ -10853,10 +11044,10 @@ ${buildPlaybookBlock()}
 OUTPUT DOCTRINE (how findings are structured for recall):
 ${PYRAMID_OUTPUT_BLOCK}
 
-${USER_VISIBLE_STE_BLOCK}
+${buildUserVisibleProseBlock()}
 
 Respond with JSON only \u2014 an array of finding objects:
-${FINDINGS_SCHEMA_BLOCK}
+${buildFindingsSchemaBlock()}
 
 Rules:
 - Maximum 8 findings
@@ -10960,6 +11151,7 @@ var init_findings = __esm({
     init_repl_api();
     init_failover();
     init_prompt_parts();
+    init_prompt();
     init_json_response();
     init_json_stream();
     init_playbook();
@@ -11041,13 +11233,21 @@ function buildFreshNlTools() {
   if (isWebRetrievalEnabled()) tools2.push(WEB_SEARCH_TOOL);
   return tools2;
 }
+function buildThinkTools() {
+  const tools2 = [
+    ...AGENTIC_TOOLS,
+    ...THINK_CHANNEL_TOOLS
+  ];
+  if (isWebRetrievalEnabled()) tools2.push(WEB_SEARCH_TOOL);
+  return tools2;
+}
 function allRegisteredToolSchemas() {
-  return [...AGENTIC_TOOLS, ...CONVERSATION_TOOLS, WEB_SEARCH_TOOL];
+  return [...AGENTIC_TOOLS, ...CONVERSATION_TOOLS, ...THINK_CHANNEL_TOOLS, WEB_SEARCH_TOOL];
 }
 function getToolSchema(name) {
   return allRegisteredToolSchemas().find((t) => t.name === name);
 }
-var WEB_SEARCH_TOOL, CONVERSATION_TOOLS, AGENTIC_TOOLS;
+var WEB_SEARCH_TOOL, CONVERSATION_TOOLS, THINK_CHANNEL_TOOLS, AGENTIC_TOOLS;
 var init_tool_schemas = __esm({
   "src/ai/tool-schemas.ts"() {
     "use strict";
@@ -11124,6 +11324,64 @@ var init_tool_schemas = __esm({
         }
       }
     ];
+    THINK_CHANNEL_TOOLS = [
+      {
+        name: "draft_handoff",
+        description: "Draft a handoff prompt combining analysis numbers and conversation thread.",
+        parameters: {
+          type: "object",
+          properties: {
+            target: {
+              type: "string",
+              enum: ["deck", "asana", "clay", "plan"],
+              description: "Deliverable type. Defaults to plan."
+            }
+          }
+        }
+      },
+      {
+        name: "draft_strategy",
+        description: "Hand off to the strategist brain from the think channel when the user is ready to commit to a plan. Do not improvise a multi-week roadmap inline \u2014 call this instead.",
+        parameters: {
+          type: "object",
+          properties: {
+            objective: {
+              type: "string",
+              maxLength: 2e3,
+              description: "The measurable objective to plan toward, in the user's terms."
+            }
+          },
+          required: ["objective"]
+        }
+      },
+      {
+        name: "update_think_scratch",
+        description: "Update the think-channel working scratch: open questions, challenged assumptions, and working hypotheses. Pass only the arrays you want to replace; omitted fields stay unchanged. Call when the conversation advances a question, surfaces a challenged assumption, or forms a hypothesis.",
+        parameters: {
+          type: "object",
+          properties: {
+            open_questions: {
+              type: "array",
+              items: { type: "string", maxLength: 500 },
+              maxItems: 12,
+              description: "Current open questions (replaces the list when provided)."
+            },
+            challenged_assumptions: {
+              type: "array",
+              items: { type: "string", maxLength: 500 },
+              maxItems: 12,
+              description: "Assumptions that have been pressure-tested (replaces when provided)."
+            },
+            working_hypotheses: {
+              type: "array",
+              items: { type: "string", maxLength: 500 },
+              maxItems: 12,
+              description: "Working hypotheses under consideration (replaces when provided)."
+            }
+          }
+        }
+      }
+    ];
     AGENTIC_TOOLS = [
       {
         name: "get_health_summary",
@@ -12892,6 +13150,15 @@ var init_layout = __esm({
   }
 });
 
+// src/whimsy/home-taglines.ts
+var HOME_TAGLINE_WHIMSY_CHANCE;
+var init_home_taglines = __esm({
+  "src/whimsy/home-taglines.ts"() {
+    "use strict";
+    HOME_TAGLINE_WHIMSY_CHANCE = 1 / 8;
+  }
+});
+
 // src/ui/banner.ts
 import chalk4 from "chalk";
 var init_banner = __esm({
@@ -12899,6 +13166,8 @@ var init_banner = __esm({
     "use strict";
     init_theme();
     init_layout();
+    init_home_taglines();
+    init_home_taglines();
   }
 });
 
@@ -13241,8 +13510,8 @@ function resolveAskMultiInput(raw, options) {
 function resolveChooseInput(raw, choices, defaultValue) {
   if (choices.length === 0) return null;
   const defaultIdx = resolveChooseDefaultIndex(choices, defaultValue);
-  const pick2 = raw.trim() || String(defaultIdx + 1);
-  const n = Number(pick2);
+  const pick3 = raw.trim() || String(defaultIdx + 1);
+  const n = Number(pick3);
   if (Number.isInteger(n) && n >= 1 && n <= choices.length) {
     return choices[n - 1].value;
   }
@@ -13515,6 +13784,8 @@ function resolveRecommendedAction(ctx) {
       return { submit: "yes", hint: "yes" };
     case "strategize":
       return ctx.strategistState?.step === "objective_confirm" ? { submit: "yes", hint: "yes" } : null;
+    case "think":
+      return null;
     default:
       return null;
   }
@@ -13549,6 +13820,9 @@ function resolveConversationPhase(ctx) {
   if (ctx.strategistState && ctx.strategistState.step !== "awaiting_analysis" && ctx.strategistState.step !== "awaiting_connect") {
     return "strategize";
   }
+  if (ctx.thinkState?.step === "active") {
+    return "think";
+  }
   if (isAnalysisReady(ctx)) return "explore";
   const scope = ctx.scope;
   if (scope?.confirmed_at) {
@@ -13573,6 +13847,8 @@ function formatPhaseLabel(phase) {
       return "setup";
     case "explore":
       return "ready to ask";
+    case "think":
+      return "thinking together";
     default:
       return phase.replace(/_/g, " ");
   }
@@ -13591,8 +13867,14 @@ function buildConversationPrompt(ctx) {
     const modeTag = mode === "brief" ? "brief" : "deep";
     const stack = canUseReplAi(ctx) ? formatActiveStackShort(ctx) : "no engine";
     const strategyWait = ctx.strategistState?.step === "awaiting_connect" ? chalk8.dim(" \xB7 strategy after /connect") : "";
+    const thinkWait = ctx.thinkState?.step === "awaiting_connect" ? chalk8.dim(" \xB7 think after /connect") : "";
     const enterHint2 = action ? chalk8.dim(` \xB7 \u23CE ${action.hint}`) : "";
-    return paint("accent", `ask${scope} \u203A `) + chalk8.dim(`${modeTag} \xB7 ${stack}`) + strategyWait + enterHint2 + " ";
+    return paint("accent", `ask${scope} \u203A `) + chalk8.dim(`${modeTag} \xB7 ${stack}`) + strategyWait + thinkWait + enterHint2 + " ";
+  }
+  if (phase === "think") {
+    const stack = canUseReplAi(ctx) ? formatActiveStackShort(ctx) : "no engine";
+    const enterHint2 = action ? chalk8.dim(` \xB7 \u23CE ${action.hint}`) : "";
+    return paint("accent", `think${scope} \u203A `) + chalk8.dim(stack) + enterHint2 + " ";
   }
   const enterHint = action ? chalk8.dim(`\u23CE ${action.hint} `) : "";
   return paint("accent", `${label.replace(" \u203A", "")}${scope} \u203A `) + enterHint;
@@ -13633,6 +13915,7 @@ var init_phase = __esm({
       awaiting_data: "data \u203A",
       compute: "\u2026",
       explore: "ask \u203A",
+      think: "think \u203A",
       strategize: "strategy \u203A",
       deliver: "ship \u203A"
     };
@@ -13985,14 +14268,14 @@ ${ANALYST_INSTINCT_BLOCK}
 OUTPUT DOCTRINE (how findings are structured for recall):
 ${PYRAMID_OUTPUT_BLOCK}
 
-${USER_VISIBLE_STE_BLOCK}
+${buildUserVisibleProseBlock()}
 
 Respond with JSON only \u2014 an array of finding objects:
 [
   {
     "severity": "critical" | "warning" | "info",
     "segment": "Overall",
-    "finding": "Pyramid-shaped, 2-3 STE-100 sentences: (1) HEADLINE \u2014 verdict + number (\u226420 words); (2) EVIDENCE \u2014 the figures that prove it, citing confidence when below 80; (3) SO-WHAT \u2014 the consequence or action. No contractions, slang, or filler.",
+    "finding": ${JSON.stringify(buildFindingsFindingHint())},
     "vital_signs": {},
     "entity_count": 0,
     "recommended_focus": "nrr",
@@ -14070,6 +14353,7 @@ var init_metrics_findings = __esm({
     init_repl_api();
     init_failover();
     init_prompt_parts();
+    init_prompt();
     init_playbook();
     init_metrics_benchmarks();
     init_profile();
@@ -14437,6 +14721,158 @@ var init_slides = __esm({
   }
 });
 
+// src/voice/copy.ts
+function voice(prefs) {
+  return prefs ?? loadVoicePrefs();
+}
+function voiceKeylessHeadline(input, prefs) {
+  const v = voice(prefs);
+  const { label, dollarBit, score, status } = input;
+  if (dollarBit) {
+    return pick2(v, {
+      robotic: `${label} \u2014 ${dollarBit} \u2014 is the most expensive problem to solve right now.`,
+      composed: `${label} is the most expensive problem right now: ${dollarBit}.`,
+      casual: `${label} is the expensive one \u2014 ${dollarBit}.`,
+      loose: {
+        light: `${label} is the expensive problem: ${dollarBit}.`,
+        medium: `${label} is eating ${dollarBit}. Fix that first.`,
+        dark: `${label} is eating ${dollarBit}. That is the miss.`,
+        heavy: `${label} is eating ${dollarBit}. That is the fire.`
+      }
+    });
+  }
+  return pick2(v, {
+    robotic: `${label} (score ${Math.round(score)}, ${status}) is the problem to fix first.`,
+    composed: `${label} (score ${Math.round(score)}) is the problem to fix first.`,
+    casual: `Start with ${label} \u2014 score ${Math.round(score)}, ${status}.`,
+    loose: {
+      light: `Start with ${label} (score ${Math.round(score)}).`,
+      medium: `${label} at ${Math.round(score)} is the one to fix first.`,
+      dark: `${label} at ${Math.round(score)} is the miss.`,
+      heavy: `${label} at ${Math.round(score)} is the joke, and not the funny kind.`
+    }
+  });
+}
+function voiceKeylessGating(_label, _score, prefs) {
+  const v = voice(prefs);
+  return pick2(v, {
+    robotic: `it bounds what you can trust downstream.`,
+    composed: `it bounds what you can trust downstream.`,
+    casual: `nothing downstream is trustworthy until this moves.`,
+    loose: {
+      light: `it caps what you can trust downstream.`,
+      medium: `fix this before you trust anything downstream.`,
+      dark: `everything downstream is a story until this moves.`,
+      heavy: `everything downstream is fan fiction until this moves.`
+    }
+  });
+}
+function voiceKeylessGatingWrap(label, score, prefs) {
+  const clause = voiceKeylessGating(label, score, prefs);
+  return `(score ${Math.round(score)}) \u2014 ${clause}`;
+}
+function voiceKeylessAlsoLabel(prefs) {
+  const v = voice(prefs);
+  return pick2(v, {
+    robotic: "Also on the board:",
+    composed: "Also on the board:",
+    casual: "Also in play:",
+    loose: {
+      light: "Also in play:",
+      medium: "Also costing you:",
+      dark: "Also on fire:",
+      heavy: "Also embarrassing:"
+    }
+  });
+}
+function voiceKeylessNextLabel(prefs) {
+  const v = voice(prefs);
+  return pick2(v, {
+    robotic: "Next after that: ",
+    composed: "Next after that: ",
+    casual: "Then: ",
+    loose: "Then: "
+  });
+}
+function voiceKeylessConnectCta(prefs) {
+  const v = voice(prefs);
+  return pick2(v, {
+    robotic: `Press \u23CE to connect a key (/connect) for the why and the plan. NTRP will finish this question after you connect.`,
+    composed: `Press \u23CE to connect a key (/connect) for the why and the plan. NTRP will finish this question after you connect.`,
+    casual: `Press \u23CE or type /connect for the why and the plan. NTRP will finish this question after you connect.`,
+    loose: `Press \u23CE or type /connect when you want the why. NTRP will finish this question after you connect.`
+  });
+}
+function voiceGapReadyCta(prefs) {
+  const v = voice(prefs);
+  return pick2(v, {
+    robotic: `Ready to compute. Press \u23CE or type "go ahead"`,
+    composed: `Ready to compute. Press \u23CE or type "go ahead"`,
+    casual: `Ready. Press \u23CE or type "go ahead"`,
+    loose: `Ready. Press \u23CE or type "go ahead"`
+  });
+}
+function voiceGapLoadCta(prefs) {
+  const v = voice(prefs);
+  return pick2(v, {
+    robotic: `Load data. Paste a CSV path, or press \u23CE to use demo data`,
+    composed: `Load data. Paste a CSV path, or press \u23CE to use demo data`,
+    casual: `Load data \u2014 paste a CSV, or press \u23CE to use demo data`,
+    loose: `No data yet. Paste a CSV, or press \u23CE to use demo data`
+  });
+}
+function voiceHealthGloss(status, prefs) {
+  const v = voice(prefs);
+  if (status === "green") {
+    return v.personality === "robotic" ? null : "holding";
+  }
+  if (status === "yellow") {
+    return pick2(v, {
+      robotic: "watch this",
+      composed: "watch this",
+      casual: "soft",
+      loose: {
+        light: "watch this",
+        medium: "soft",
+        dark: "thin ice",
+        heavy: "limping"
+      }
+    });
+  }
+  return pick2(v, {
+    robotic: "needs attention",
+    composed: "needs attention",
+    casual: "the leak",
+    loose: {
+      light: "needs attention",
+      medium: "the leak",
+      dark: "the miss",
+      heavy: "this is the fire"
+    }
+  });
+}
+function voiceHandoffAddendum(prefs) {
+  const v = voice(prefs);
+  return [
+    `Write in this voice: personality=${v.personality}, roast=${v.roast} (${formatVoiceStatusDetail(v)}).`,
+    "Ground every recommendation in the specific numbers provided. Do not invent data.",
+    v.personality === "robotic" ? "STE-100 for the prose you produce. No contractions." : "Stay smart and succinct. Personality in the wrap, not in the math.",
+    v.roast === "light" ? "Light roast: name what is working, then what to improve." : v.roast === "medium" ? "Medium roast: name the miss. No padding." : v.roast === "dark" ? "Dark roast: surgical. Verdict and dollar in the same breath." : "Heavy roast: maximum roast after the number, never instead of it. Green stays green."
+  ].join(" ");
+}
+function pick2(prefs, map) {
+  const entry = map[prefs.personality];
+  if (typeof entry === "string") return entry;
+  return entry[prefs.roast];
+}
+var init_copy = __esm({
+  "src/voice/copy.ts"() {
+    "use strict";
+    init_catalog2();
+    init_prefs();
+  }
+});
+
 // src/output/terminal.ts
 import chalk13 from "chalk";
 import Table2 from "cli-table3";
@@ -14484,9 +14920,10 @@ function printVitalSignRow(vs) {
 function printHealthSummary(result, _pipelineMetrics) {
   const scoreStr = `${chalk13.bold(String(Math.round(result.overall_score)))}${chalk13.dim("/100")}`;
   const impact = result.total_value_at_risk != null && result.total_value_at_risk > 0 ? `${paint("success", formatCurrency(result.total_value_at_risk))} ${chalk13.dim("total at risk")}` : chalk13.dim("No dollar-weighted risk detected");
+  const gloss = voiceHealthGloss(result.overall_status);
   const next = result.overall_status === "red" ? actionHint("Next:", "/playbook", "review recommended plays") : result.overall_status === "yellow" ? actionHint("Next:", "/diagnose --deep", "investigate the weak signal") : actionHint("Next:", "/report", "export the clean snapshot");
   printResultCard("Overall Health", [
-    `${chalk13.dim("Score")}          ${scoreStr}  ${statusBadge(result.overall_status)}`,
+    `${chalk13.dim("Score")}          ${scoreStr}  ${statusBadge(result.overall_status)}${gloss ? chalk13.dim(`  ${gloss}`) : ""}`,
     `${chalk13.dim("Held back by")}   ${paint("accent", VITAL_SIGN_LABELS[result.gating_vital_sign])}`,
     `${chalk13.dim("Revenue")}        ${impact}`,
     next
@@ -14498,8 +14935,9 @@ function printHealthSummary(result, _pipelineMetrics) {
 }
 function printHealthLine(result) {
   const score = `${chalk13.bold(String(Math.round(result.overall_score)))}${chalk13.dim("/100")}`;
+  const gloss = voiceHealthGloss(result.overall_status);
   const parts = [
-    `${chalk13.dim("Health")} ${score} ${statusBadge(result.overall_status)}`,
+    `${chalk13.dim("Health")} ${score} ${statusBadge(result.overall_status)}${gloss ? chalk13.dim(` ${gloss}`) : ""}`,
     `${chalk13.dim("held back by")} ${paint("accent", VITAL_SIGN_LABELS[result.gating_vital_sign])}`
   ];
   if (result.total_value_at_risk != null && result.total_value_at_risk > 0) {
@@ -14840,6 +15278,7 @@ var init_terminal = __esm({
     init_layout();
     init_llm_attribution();
     init_slides();
+    init_copy();
   }
 });
 
@@ -16514,6 +16953,8 @@ function wrapForTarget(target, analysisBlock, conversationBlock, openQuestions,
     "",
     "Ground every recommendation in the specific numbers provided. Do not invent data.",
     "",
+    voiceHandoffAddendum(),
+    "",
     "---",
     "",
     analysisBlock,
@@ -16572,6 +17013,7 @@ var init_handoff_draft = __esm({
     init_profile();
     init_session_analysis();
     init_metric_explainers();
+    init_copy();
     QUESTION_LEAD_RE = /^\s*(what|why|how|when|where|who|which|is|are|was|were|do|does|did|explain|tell me|help me understand)\b/i;
     SHIP_INTENT_RE = /\b(ship|export|deliver|write[- ]?up|board memo|action plan|turn (this|it|that) into|(draft|create|make|build|prepare|generate|send)\s+(me\s+)?(a\s+|the\s+)?hand[- ]?off|hand[- ]?off\s+(prompt|doc|document|plan))\b/i;
   }
@@ -16901,7 +17343,7 @@ ALTITUDE CONTRACT (the plan must work at every altitude a client reads it at):
 - 10,000 FT: each workstream's title + problem line is a delegation unit \u2014 a one-liner an owner could receive in Slack and know what they own, why it's theirs, and what number they move.
 - GROUND LEVEL: actions are Monday-morning prescriptive. You have built this before \u2014 read the linked play's full detail with get_play_detail and prescribe its known-good sequence adapted to THIS company's numbers and constraints. The first action of every workstream must be startable within 48 hours with no new tooling.
 
-${USER_VISIBLE_STE_BLOCK}
+${buildUserVisibleProseBlock()}
 
 GTM ENGINEERING (plans install systems, not heroics):
 ${GTM_ENGINEERING_BLOCK}
@@ -16991,6 +17433,7 @@ var init_strategist_prompt = __esm({
   "src/ai/strategist-prompt.ts"() {
     "use strict";
     init_prompt_parts();
+    init_prompt();
     STRATEGIST_PLAN_SCHEMA_BLOCK = `{
   "title": "Short plan name, e.g. 'Q4 Pipeline Recovery'",
   "objective": "The measurable destination, restated precisely",
@@ -18304,45 +18747,372 @@ var init_strategist_flow = __esm({
   }
 });
 
-// src/conversation/gap-card.ts
+// src/services/think.ts
+var think_exports = {};
+__export(think_exports, {
+  runThinkTurn: () => runThinkTurn
+});
 import chalk18 from "chalk";
+async function runThinkTurn(input, ctx) {
+  assertReplAi(ctx);
+  let snapshot = ctx.snapshot.computeResult;
+  if (!snapshot) {
+    const metricsFirst = prefersMetricsFirstContext(ctx);
+    const spinner2 = makeSpinner(metricsFirst ? "Loading session context\u2026" : "Computing vital signs\u2026");
+    try {
+      snapshot = await computeFullHealth();
+      ctx.snapshot.computeResult = snapshot;
+      const divInput = snapshot.segments.map((s) => ({
+        segmentId: s.segment.id,
+        segmentName: s.segment.name,
+        result: s.result
+      }));
+      ctx.snapshot.divergences = detectDivergences(snapshot.aggregate, divInput).divergences;
+      spinner2.succeed(metricsFirst ? "Session context ready" : "Health snapshot ready");
+    } catch (err) {
+      spinner2.fail("Could not compute health snapshot");
+      console.error("  " + chalk18.red(String(err.message ?? err)));
+      console.log("  " + chalk18.dim("Run ") + paint("accent", "/new") + chalk18.dim(" \u2192 pick Demo to load sample data."));
+      console.log();
+      return;
+    }
+  }
+  console.log();
+  const memoryBlock = await buildMemoryBlock(input).catch(() => "");
+  const spinner = makeSpinner("Thinking with you\u2026");
+  let lastAnswer = "";
+  let rawHistory = [];
+  const toolsUsed = [];
+  setAgentContext(ctx);
+  try {
+    const analysisBlock = buildAnalysisBlock(ctx);
+    const conversationBlock = getConversationPhaseBlock(ctx);
+    const bundle = await loadSessionAnalysisBundle();
+    const sessionArtifact = hasAnyAnalysis(bundle) ? buildExploreContextBlock(bundle, ctx) : "";
+    for await (const event of agenticFindings(snapshot, ctx.snapshot.divergences, {
+      mode: "think",
+      userQuestion: input,
+      sessionContext: ctx.resumedSessionSummary,
+      includeMetrics: true,
+      analysisBlock,
+      conversationBlock,
+      sessionArtifact,
+      priorMessages: ctx.thinkConversation,
+      memoryBlock,
+      ctx
+    })) {
+      switch (event.type) {
+        case "tool_call":
+          toolsUsed.push(event.name);
+          spinner.text = `Querying ${event.name}\u2026`;
+          break;
+        case "thinking":
+          spinner.stop();
+          console.log("  " + chalk18.dim.italic(event.text));
+          spinner.start("Thinking with you\u2026");
+          break;
+        case "answer":
+          spinner.stop();
+          lastAnswer = event.text;
+          printMarkdown(event.text, { indent: 2 });
+          break;
+        case "finding":
+          spinner.stop();
+          printFindingInline(event.finding);
+          break;
+        case "done":
+          spinner.stop();
+          rawHistory = event.conversation_history;
+          break;
+      }
+    }
+  } catch (err) {
+    spinner.fail("Error while thinking");
+    console.error("  " + chalk18.red(String(err.message ?? err)));
+    console.log();
+    return;
+  } finally {
+    setAgentContext(null);
+  }
+  if (rawHistory.length > 0) {
+    ctx.thinkConversation = distillThread(rawHistory);
+  }
+  if (!lastAnswer) {
+    console.log("  " + chalk18.dim("(no answer returned)"));
+  } else {
+    recordMessage(ctx, "agent", lastAnswer);
+    saveSessionState(ctx);
+    creditNlAnswer(ctx, Math.floor(ctx.messages.length / 2));
+    recordAnalysis({
+      question: `[think] ${input}`,
+      answer: lastAnswer,
+      tools: toolsUsed,
+      session_id: ctx.sessionId
+    });
+    ctx.lastExchange = { question: input, answer: lastAnswer };
+  }
+  console.log();
+  return lastAnswer ? extractSummary(lastAnswer) : void 0;
+}
+function extractSummary(text) {
+  const plain = text.replace(/#{1,6}\s+/g, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^[-*]\s+/gm, "").trim();
+  const sentenceMatch = plain.match(/^(.+?[.!?])(?:\s|$)/);
+  const sentence = sentenceMatch ? sentenceMatch[1] : plain.split("\n")[0];
+  if (sentence.length <= 60) return sentence;
+  return sentence.slice(0, 60).replace(/\s+\S*$/, "") + "\u2026";
+}
+function printFindingInline(finding) {
+  const sev = finding.severity;
+  console.log();
+  console.log(
+    "  " + severityPaint(sev)(sev.toUpperCase()) + "  " + (finding.finding ?? "").slice(0, 120)
+  );
+}
+var init_think = __esm({
+  "src/services/think.ts"() {
+    "use strict";
+    init_spinner();
+    init_context2();
+    init_phase();
+    init_agent_context();
+    init_agentic_loop();
+    init_thread();
+    init_store2();
+    init_health_score();
+    init_divergence();
+    init_repl_api();
+    init_theme();
+    init_markdown();
+    init_session_analysis();
+    init_time_bank();
+  }
+});
+
+// src/conversation/think-flow.ts
+var think_flow_exports = {};
+__export(think_flow_exports, {
+  clearThinkFlow: () => clearThinkFlow,
+  extractThinkSeed: () => extractThinkSeed,
+  handleThinkFlow: () => handleThinkFlow,
+  isThinkIntent: () => isThinkIntent,
+  queueThinkForAnalysis: () => queueThinkForAnalysis,
+  resumeThinkAfterCompute: () => resumeThinkAfterCompute,
+  resumeThinkAfterConnect: () => resumeThinkAfterConnect,
+  startThinkFlow: () => startThinkFlow
+});
+import chalk19 from "chalk";
+function isThinkIntent(input) {
+  const line = input.trim();
+  if (!line) return false;
+  if (isShipIntent(line)) return false;
+  if (isStrategistIntent(line)) return false;
+  return THINK_INTENT_RE.test(line);
+}
+function extractThinkSeed(input) {
+  const cleaned = input.trim().replace(/^(hey|ok|okay|please|can you|could you|help me|let'?s|i want to|i'?d like to)\s+/i, "").replace(/^(think\s+with\s+me|pressure[- ]?test|dig\s+into|think\s+through)\s*(about|on|around|this|:)?\s*/i, "").replace(/^(what\s+am\s+i\s+missing\s*(about|on|with|here)?)\s*/i, "").trim();
+  return cleaned.length >= 4 ? cleaned : input.trim();
+}
+function queueThinkForAnalysis(ctx, opts) {
+  ctx.thinkState = {
+    step: "awaiting_analysis",
+    seed: opts.seed,
+    origin: opts.origin,
+    started_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveSessionState(ctx);
+  console.log();
+  console.log(
+    "  " + chalk19.dim("Think session queued. NTRP opens the channel after analysis.")
+  );
+  if (opts.origin !== "nl") {
+    console.log(
+      "  " + chalk19.dim("Type what to look at. Paste a CSV path. Or type ") + chalk19.cyan("use demo data") + chalk19.dim(".")
+    );
+  }
+  console.log();
+}
+function printChannelIntro(seed) {
+  console.log();
+  console.log("  " + paint("accent", "Think with me"));
+  console.log(
+    "  " + chalk19.dim(
+      "Socratic channel \u2014 explore, challenge assumptions, pull evidence. Type "
+    ) + chalk19.cyan("done") + chalk19.dim(" or ") + chalk19.cyan("cancel") + chalk19.dim(" to return to ask \u203A.")
+  );
+  if (seed) {
+    console.log("  " + chalk19.dim("Seed: ") + seed);
+  }
+  console.log();
+}
+function armKeylessThink(ctx, opts) {
+  ctx.thinkState = {
+    step: "awaiting_connect",
+    seed: opts.seed,
+    origin: opts.origin,
+    started_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveSessionState(ctx);
+  console.log();
+  console.log("  " + chalk19.dim("Think channel needs an AI key."));
+  console.log(
+    "  " + chalk19.dim("Type ") + paint("accent", "/connect") + chalk19.dim(" and paste a key. Seed kept \u2014 the channel opens after connect.")
+  );
+  console.log();
+}
+async function startThinkFlow(ctx, opts) {
+  if (!isAnalysisReady(ctx)) {
+    queueThinkForAnalysis(ctx, opts);
+    return "Think queued";
+  }
+  if (!canUseReplAi(ctx)) {
+    armKeylessThink(ctx, opts);
+    return "Think awaiting connect";
+  }
+  const seed = opts.seed?.trim() || void 0;
+  ctx.thinkState = {
+    step: "active",
+    seed,
+    origin: opts.origin,
+    started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    open_questions: [],
+    challenged_assumptions: [],
+    working_hypotheses: []
+  };
+  if (ctx.thinkConversation.length === 0 && seed) {
+  }
+  saveSessionState(ctx);
+  printChannelIntro(seed);
+  recordMessage(ctx, "agent", seed ? `Think channel opened: ${seed}` : "Think channel opened");
+  if (seed) {
+    recordMessage(ctx, "user", seed);
+    const { runThinkTurn: runThinkTurn2 } = await Promise.resolve().then(() => (init_think(), think_exports));
+    await runThinkTurn2(seed, ctx);
+  }
+  return "Think channel open";
+}
+async function resumeThinkAfterCompute(ctx) {
+  const state2 = ctx.thinkState;
+  if (!state2 || state2.step !== "awaiting_analysis") return;
+  if (ctx.strategistState && ctx.strategistState.step !== "awaiting_analysis" && ctx.strategistState.step !== "awaiting_connect") {
+    return;
+  }
+  if (ctx.strategistState?.step === "awaiting_analysis") return;
+  console.log();
+  console.log("  " + paint("accent", "Analysis is ready. The think channel continues."));
+  await startThinkFlow(ctx, {
+    seed: state2.seed,
+    origin: state2.origin ?? "nl"
+  });
+}
+async function resumeThinkAfterConnect(ctx) {
+  const state2 = ctx.thinkState;
+  if (!state2 || state2.step !== "awaiting_connect") return false;
+  if (!canUseReplAi(ctx)) return false;
+  console.log();
+  console.log("  " + paint("accent", "Key connected. Opening the think channel."));
+  await startThinkFlow(ctx, {
+    seed: state2.seed,
+    origin: state2.origin ?? "nl"
+  });
+  return true;
+}
+function clearThinkFlow(ctx, reason) {
+  ctx.thinkState = void 0;
+  saveSessionState(ctx);
+  if (reason === "handoff") return;
+  console.log();
+  console.log(
+    "  " + chalk19.dim(
+      reason === "done" ? "Think channel closed. Back to ask \u203A." : "Think session cancelled. Continue exploration."
+    )
+  );
+  console.log();
+}
+async function handleThinkFlow(input, ctx) {
+  const state2 = ctx.thinkState;
+  if (!state2 || state2.step !== "active") return;
+  const line = input.trim();
+  recordMessage(ctx, "user", line);
+  if (CANCEL_RE2.test(line) || DONE_RE.test(line)) {
+    clearThinkFlow(ctx, CANCEL_RE2.test(line) ? "cancel" : "done");
+    recordMessage(ctx, "agent", "Think channel closed");
+    return "Think closed";
+  }
+  if (isStrategistIntent(line)) {
+    clearThinkFlow(ctx, "handoff");
+    const summary = await startStrategistFlow(ctx, {
+      seed: extractObjectiveSeed(line),
+      origin: "nl"
+    }) ?? void 0;
+    return summary ?? "Handed off to strategist";
+  }
+  if (!canUseReplAi(ctx)) {
+    armKeylessThink(ctx, { seed: state2.seed ?? line, origin: state2.origin ?? "nl" });
+    return "Think awaiting connect";
+  }
+  const { runThinkTurn: runThinkTurn2 } = await Promise.resolve().then(() => (init_think(), think_exports));
+  await runThinkTurn2(line, ctx);
+  if (ctx.strategistState && ctx.strategistState.step !== "awaiting_analysis" && ctx.strategistState.step !== "awaiting_connect") {
+    clearThinkFlow(ctx, "handoff");
+    const { promptQueuedAiStrategist: promptQueuedAiStrategist2 } = await Promise.resolve().then(() => (init_strategist_flow(), strategist_flow_exports));
+    promptQueuedAiStrategist2(ctx);
+  }
+  return "Think turn";
+}
+var THINK_INTENT_RE, CANCEL_RE2, DONE_RE;
+var init_think_flow = __esm({
+  "src/conversation/think-flow.ts"() {
+    "use strict";
+    init_context2();
+    init_repl_api();
+    init_theme();
+    init_handoff_draft();
+    init_strategist_flow();
+    THINK_INTENT_RE = /\b(think\s+with\s+me|pressure[- ]?test|what\s+am\s+i\s+missing|challenge\s+(my\s+)?(assumption|thinking|hypothesis)|let'?s\s+(dig|explore|think|pressure)|dig\s+into|steelman|devil'?s\s+advocate|think\s+through|brainstorm\s+(with\s+me|this)|socratic)\b/i;
+    CANCEL_RE2 = /^(cancel|stop|quit|abort|never\s?mind|nevermind|forget it)\s*[.!]?\s*$/i;
+    DONE_RE = /^(done|enough|enough for now|that'?s enough|leave|exit think)\s*[.!]?\s*$/i;
+  }
+});
+
+// src/conversation/gap-card.ts
+import chalk20 from "chalk";
 function printGapCard(audit, opts = {}) {
   console.log();
   if (opts.skipSatisfied) {
     if (audit.missing.length > 0) {
-      console.log("  " + chalk18.bold("Data check"));
+      console.log("  " + chalk20.bold("Data check"));
     }
   } else if (audit.satisfied.length > 0) {
     const bits = audit.satisfied.map((item) => item.detail);
     console.log(
-      "  " + chalk18.green("\u2713") + " " + chalk18.bold("Data check") + chalk18.dim(" \u2014 " + bits.join(" \xB7 "))
+      "  " + chalk20.green("\u2713") + " " + chalk20.bold("Data check") + chalk20.dim(" \u2014 " + bits.join(" \xB7 "))
     );
   } else {
-    console.log("  " + chalk18.bold("Data check"));
+    console.log("  " + chalk20.bold("Data check"));
   }
   for (const item of audit.missing) {
-    console.log("  " + chalk18.red("\u2717") + " " + item.label + chalk18.dim(` \u2014 ${item.why}`));
-    console.log("    " + chalk18.dim(item.suggestion));
+    console.log("  " + chalk20.red("\u2717") + " " + item.label + chalk20.dim(` \u2014 ${item.why}`));
+    console.log("    " + chalk20.dim(item.suggestion));
   }
   if (audit.optional.length > 0) {
     const heads = audit.optional.map((item) => item.detail.split(" \u2014 ")[0] ?? item.detail);
     const joined = heads.join(" \xB7 ");
     if (joined.length <= 100) {
-      console.log("  " + chalk18.yellow("~") + " " + chalk18.dim(joined));
+      console.log("  " + chalk20.yellow("~") + " " + chalk20.dim(joined));
     } else {
       for (const item of audit.optional) {
-        console.log("  " + chalk18.yellow("~") + " " + chalk18.dim(`${item.label}: ${item.detail}`));
+        console.log("  " + chalk20.yellow("~") + " " + chalk20.dim(`${item.label}: ${item.detail}`));
       }
     }
   }
   console.log();
   if (audit.can_compute) {
     console.log(
-      "  " + chalk18.dim("Ready to compute. Press ") + chalk18.cyan("\u23CE") + chalk18.dim(" or type ") + chalk18.cyan('"go ahead"')
+      "  " + chalk20.dim(voiceGapReadyCta())
     );
   } else if (audit.missing.length > 0) {
     console.log(
-      "  " + chalk18.dim("Load data. Paste a CSV path, or press ") + chalk18.cyan("\u23CE") + chalk18.dim(" to ") + chalk18.cyan("use demo data")
+      "  " + chalk20.dim(voiceGapLoadCta())
     );
   }
   console.log();
@@ -18350,6 +19120,7 @@ function printGapCard(audit, opts = {}) {
 var init_gap_card = __esm({
   "src/conversation/gap-card.ts"() {
     "use strict";
+    init_copy();
   }
 });
 
@@ -18359,7 +19130,7 @@ __export(keyless_ask_exports, {
   isKeylessVitalsAsk: () => isKeylessVitalsAsk,
   tryKeylessAskAnswer: () => tryKeylessAskAnswer
 });
-import chalk19 from "chalk";
+import chalk21 from "chalk";
 function isKeylessVitalsAsk(input) {
   return KEYLESS_ASK_RE.test(input.trim());
 }
@@ -18405,39 +19176,42 @@ async function tryKeylessAskAnswer(ctx, input, opts = {}) {
   if (!primary) return false;
   const label = VITAL_SIGN_LABELS[primary.vital_sign] ?? primary.vital_sign;
   const dollarBit = primary.dollar_value != null && primary.dollar_value > 0 ? `${formatCurrency(primary.dollar_value)} ${primary.dollar_label ?? ""}`.trim() : null;
-  const headline = dollarBit ? `${label} \u2014 ${dollarBit} \u2014 is the most expensive problem to solve right now.` : `${label} (score ${Math.round(primary.score)}, ${primary.status}) is the problem to fix first.`;
+  const headline = voiceKeylessHeadline({
+    label,
+    dollarBit,
+    score: primary.score,
+    status: primary.status
+  });
   const runners = [...aggregate.vital_signs].filter((v) => v.vital_sign !== primary.vital_sign && (v.dollar_value ?? 0) > 0).sort((a, b) => (b.dollar_value ?? 0) - (a.dollar_value ?? 0)).slice(0, 2);
   console.log();
-  console.log("  " + chalk19.bold(headline));
+  console.log("  " + chalk21.bold(headline));
   if (opts.fromResume) {
     if (runners.length > 0) {
       console.log(
-        "  " + chalk19.dim("Next after that: ") + chalk19.dim(runners.map(formatRunnerBit).join(" \xB7 "))
+        "  " + chalk21.dim(voiceKeylessNextLabel()) + chalk21.dim(runners.map(formatRunnerBit).join(" \xB7 "))
       );
     }
   } else {
     console.log();
     if (gating && gating.vital_sign !== primary.vital_sign) {
       console.log(
-        "  " + chalk19.dim("Gating vital: ") + paint("accent", VITAL_SIGN_LABELS[gating.vital_sign]) + chalk19.dim(` (score ${Math.round(gating.score)}) \u2014 it bounds what you can trust downstream.`)
+        "  " + chalk21.dim("Gating vital: ") + paint("accent", VITAL_SIGN_LABELS[gating.vital_sign]) + chalk21.dim(voiceKeylessGatingWrap(VITAL_SIGN_LABELS[gating.vital_sign], gating.score))
       );
     }
     if (runners.length > 0) {
-      console.log("  " + chalk19.dim("Also on the board:"));
+      console.log("  " + chalk21.dim(voiceKeylessAlsoLabel()));
       for (const vs of runners) {
-        console.log("    " + chalk19.dim("\xB7 ") + formatVitalLine(vs));
+        console.log("    " + chalk21.dim("\xB7 ") + formatVitalLine(vs));
       }
     }
     if (aggregate.total_value_at_risk != null && aggregate.total_value_at_risk > 0) {
       console.log(
-        "  " + chalk19.dim("Total at risk: ") + chalk19.green(formatCurrency(aggregate.total_value_at_risk))
+        "  " + chalk21.dim("Total at risk: ") + chalk21.green(formatCurrency(aggregate.total_value_at_risk))
       );
     }
   }
   console.log();
-  console.log(
-    "  " + chalk19.dim("Press ") + paint("accent", "\u23CE") + chalk19.dim(" to connect a key (") + paint("accent", "/connect") + chalk19.dim(") for the why and the plan. NTRP will finish this question after you connect.")
-  );
+  console.log("  " + chalk21.dim(voiceKeylessConnectCta()));
   console.log();
   if (!opts.fromResume) {
     recordMessage(ctx, "user", input);
@@ -18454,12 +19228,13 @@ var init_keyless_ask = __esm({
     init_formatters();
     init_theme();
     init_health_score();
+    init_copy();
     KEYLESS_ASK_RE = /\b(most expensive|biggest risk|expensive problem|what should (i|we) fix|fix first|biggest problem|largest risk|where (are we|do we) (bleed|leak|hurt))\b/i;
   }
 });
 
 // src/conversation/keyless-definitions.ts
-import chalk20 from "chalk";
+import chalk22 from "chalk";
 function isPossessiveMetricAsk(input) {
   return POSSESSIVE_RE.test(input.trim());
 }
@@ -18512,9 +19287,9 @@ function tryKeylessDefinitionAnswer(ctx, input) {
   const bench = explainer.benchmarkHint?.(motion);
   console.log();
   console.log(
-    "  " + sectionHeading(explainer.label) + chalk20.dim(` \xB7 ${explainer.kind === "vital" ? "vital sign" : "SaaS metric"}`)
+    "  " + sectionHeading(explainer.label) + chalk22.dim(` \xB7 ${explainer.kind === "vital" ? "vital sign" : "SaaS metric"}`)
   );
-  console.log("  " + chalk20.dim(explainer.tagline));
+  console.log("  " + chalk22.dim(explainer.tagline));
   console.log();
   console.log("  " + bold("Meaning"));
   printWrapped2(explainer.meaning, "    ");
@@ -18526,16 +19301,16 @@ function tryKeylessDefinitionAnswer(ctx, input) {
   }
   if (bench) {
     console.log();
-    console.log("  " + chalk20.dim(`Benchmark \xB7 ${bench}`));
+    console.log("  " + chalk22.dim(`Benchmark \xB7 ${bench}`));
   }
   if (explainer.dollar_label) {
     console.log(
-      "  " + chalk20.dim(`Dollar translation \xB7 ${explainer.dollar_label}`)
+      "  " + chalk22.dim(`Dollar translation \xB7 ${explainer.dollar_label}`)
     );
   }
   console.log();
   console.log(
-    "  " + chalk20.dim("More: ") + paint("accent", `/deepdive ${explainer.id}`) + chalk20.dim(" \xB7 full tour: ") + paint("accent", "/deepdive")
+    "  " + chalk22.dim("More: ") + paint("accent", `/deepdive ${explainer.id}`) + chalk22.dim(" \xB7 full tour: ") + paint("accent", "/deepdive")
   );
   console.log();
   recordMessage(ctx, "user", input);
@@ -18565,7 +19340,7 @@ var init_keyless_definitions = __esm({
 });
 
 // src/conversation/orchestrator.ts
-import chalk21 from "chalk";
+import chalk23 from "chalk";
 async function handleExploreWithoutKey(ctx, input) {
   if (isDefinitionAsk(input) && tryKeylessDefinitionAnswer(ctx, input)) {
     return;
@@ -18595,7 +19370,7 @@ async function handleExploreWithoutKey(ctx, input) {
     );
     if (ctx.pendingAsk) {
       console.log(
-        "  " + chalk21.dim("Your question is stored. NTRP will answer it after you connect.")
+        "  " + chalk23.dim("Your question is stored. NTRP will answer it after you connect.")
       );
     }
     if (ctx.gapAudit) {
@@ -18610,12 +19385,12 @@ async function handleExploreWithoutKey(ctx, input) {
     return;
   }
   console.log();
-  console.log("  " + chalk21.yellow("No key is connected. Q&A stays off until you type ") + paint("accent", "/connect") + chalk21.yellow("."));
-  console.log("  " + chalk21.dim("These commands work without a key:"));
-  console.log("    " + paint("accent", "/deepdive") + chalk21.dim("                   slides for numbers and how to use NTRP"));
-  console.log("    " + paint("accent", "/playbook") + chalk21.dim("                    recommended plays from your computed vitals"));
-  console.log("    " + chalk21.cyan('"how should we fix this?"') + chalk21.dim("    a simple plan. No AI."));
-  console.log("    " + paint("accent", "/handoff") + chalk21.dim("                     write this analysis for another tool"));
+  console.log("  " + chalk23.yellow("No key is connected. Q&A stays off until you type ") + paint("accent", "/connect") + chalk23.yellow("."));
+  console.log("  " + chalk23.dim("These commands work without a key:"));
+  console.log("    " + paint("accent", "/deepdive") + chalk23.dim("                   slides for numbers and how to use NTRP"));
+  console.log("    " + paint("accent", "/playbook") + chalk23.dim("                    recommended plays from your computed vitals"));
+  console.log("    " + chalk23.cyan('"how should we fix this?"') + chalk23.dim("    a simple plan. No AI."));
+  console.log("    " + paint("accent", "/handoff") + chalk23.dim("                     write this analysis for another tool"));
   console.log();
   recordMessage(
     ctx,
@@ -19270,7 +20045,7 @@ var nl_exports = {};
 __export(nl_exports, {
   runNaturalLanguage: () => runNaturalLanguage
 });
-import chalk22 from "chalk";
+import chalk24 from "chalk";
 async function runNaturalLanguage(input, ctx) {
   if (isSmokeProtocolTrigger(input)) {
     recordMessage(ctx, "user", input);
@@ -19282,10 +20057,10 @@ async function runNaturalLanguage(input, ctx) {
       printAnswer(result.answer);
       recordMessage(ctx, "agent", result.answer);
       console.log();
-      return extractSummary(result.answer);
+      return extractSummary2(result.answer);
     } catch (err) {
       spinner2.fail("Smoke protocol failed");
-      console.error("  " + chalk22.red(String(err.message ?? err)));
+      console.error("  " + chalk24.red(String(err.message ?? err)));
       console.log();
       return;
     }
@@ -19315,8 +20090,8 @@ async function runNaturalLanguage(input, ctx) {
       spinner2.succeed(metricsFirst ? "Session context ready" : "Health snapshot ready");
     } catch (err) {
       spinner2.fail("Could not compute health snapshot");
-      console.error("  " + chalk22.red(String(err.message ?? err)));
-      console.log("  " + chalk22.dim("Run ") + paint("accent", "/new") + chalk22.dim(" \u2192 pick Demo to load sample data."));
+      console.error("  " + chalk24.red(String(err.message ?? err)));
+      console.log("  " + chalk24.dim("Run ") + paint("accent", "/new") + chalk24.dim(" \u2192 pick Demo to load sample data."));
       console.log();
       return;
     }
@@ -19354,7 +20129,7 @@ async function runNaturalLanguage(input, ctx) {
           break;
         case "thinking":
           spinner.stop();
-          console.log("  " + chalk22.dim.italic(event.text));
+          console.log("  " + chalk24.dim.italic(event.text));
           spinner.start("Thinking\u2026");
           break;
         case "answer":
@@ -19364,7 +20139,7 @@ async function runNaturalLanguage(input, ctx) {
           break;
         case "finding":
           spinner.stop();
-          printFindingInline(event.finding);
+          printFindingInline2(event.finding);
           break;
         case "done":
           spinner.stop();
@@ -19374,7 +20149,7 @@ async function runNaturalLanguage(input, ctx) {
     }
   } catch (err) {
     spinner.fail("Error while investigating");
-    console.error("  " + chalk22.red(String(err.message ?? err)));
+    console.error("  " + chalk24.red(String(err.message ?? err)));
     console.log();
     return;
   } finally {
@@ -19384,7 +20159,7 @@ async function runNaturalLanguage(input, ctx) {
     ctx.conversation = distillThread(rawHistory);
   }
   if (!lastAnswer) {
-    console.log("  " + chalk22.dim("(no answer returned)"));
+    console.log("  " + chalk24.dim("(no answer returned)"));
   } else {
     recordMessage(ctx, "agent", lastAnswer);
     if (ctx.pendingAsk) {
@@ -19400,12 +20175,12 @@ async function runNaturalLanguage(input, ctx) {
   console.log();
   const { promptQueuedAiStrategist: promptQueuedAiStrategist2 } = await Promise.resolve().then(() => (init_strategist_flow(), strategist_flow_exports));
   promptQueuedAiStrategist2(ctx);
-  return lastAnswer ? extractSummary(lastAnswer) : void 0;
+  return lastAnswer ? extractSummary2(lastAnswer) : void 0;
 }
 function printAnswer(text) {
   printMarkdown(text, { indent: 2 });
 }
-function extractSummary(text) {
+function extractSummary2(text) {
   const plain = text.replace(/#{1,6}\s+/g, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^[-*]\s+/gm, "").trim();
   const sentenceMatch = plain.match(/^(.+?[.!?])(?:\s|$)/);
   const sentence = sentenceMatch ? sentenceMatch[1] : plain.split("\n")[0];
@@ -19413,16 +20188,16 @@ function extractSummary(text) {
   const truncated = sentence.slice(0, 60).replace(/\s+\S*$/, "");
   return truncated + "\u2026";
 }
-function printFindingInline(finding) {
+function printFindingInline2(finding) {
   const sev = finding.severity;
   console.log();
-  console.log("  " + severityPaint(sev)(`[${sev}]`) + " " + chalk22.bold(finding.segment));
+  console.log("  " + severityPaint(sev)(`[${sev}]`) + " " + chalk24.bold(finding.segment));
   printMarkdown(finding.finding, { indent: 2 });
   const play = finding.recommended_plays?.[0];
-  if (play) console.log("  " + chalk22.dim("\u2192 " + play.play_name + " \u2014 " + play.rationale));
+  if (play) console.log("  " + chalk24.dim("\u2192 " + play.play_name + " \u2014 " + play.rationale));
   if (finding.recommended_focus) {
     console.log(
-      "  " + chalk22.dim("How this works: ") + paint("accent", `/deepdive ${finding.recommended_focus}`)
+      "  " + chalk24.dim("How this works: ") + paint("accent", `/deepdive ${finding.recommended_focus}`)
     );
   }
 }
@@ -19458,12 +20233,12 @@ __export(demo_exports, {
   printDemoDisabled: () => printDemoDisabled,
   setDemoEnabled: () => setDemoEnabled
 });
-import chalk23 from "chalk";
+import chalk25 from "chalk";
 function printDemoDisabled() {
   console.log();
-  console.log("  " + chalk23.red(DEMO_DISABLED_MESSAGE));
+  console.log("  " + chalk25.red(DEMO_DISABLED_MESSAGE));
   console.log(
-    "  " + chalk23.dim("Re-enable with ") + paint("accent", "/config set demo-enabled true") + chalk23.dim(".")
+    "  " + chalk25.dim("Re-enable with ") + paint("accent", "/config set demo-enabled true") + chalk25.dim(".")
   );
   console.log();
 }
@@ -22765,16 +23540,16 @@ var generate_exports = {};
 __export(generate_exports, {
   handler: () => handler2
 });
-import chalk24 from "chalk";
+import chalk26 from "chalk";
 async function handler2(args, ctx) {
   const { flags } = parseArgs(args, ["list-scenarios", "regen-taxonomy", "brief"]);
   const quiet = ctx.execution.quiet;
   const brief = getBool(flags, "brief");
   if (getBool(flags, "list-scenarios")) {
-    console.log(chalk24.bold("\n  Available Scenarios:\n"));
+    console.log(chalk26.bold("\n  Available Scenarios:\n"));
     for (const s of SCENARIO_LIST) {
-      console.log(`  ${chalk24.cyan(s.key.padEnd(20))} ${s.label}`);
-      console.log(`  ${chalk24.dim(" ".repeat(20))} ${s.description}
+      console.log(`  ${chalk26.cyan(s.key.padEnd(20))} ${s.label}`);
+      console.log(`  ${chalk26.dim(" ".repeat(20))} ${s.description}
 `);
     }
     return true;
@@ -22784,9 +23559,9 @@ async function handler2(args, ctx) {
   const skipProfile = getFalse(flags, "profile");
   if (!isProfileConfigured(profile) && !skipProfile) {
     console.error();
-    console.error("  " + chalk24.red("No company profile found."));
-    console.error("  " + chalk24.dim("Run ") + paint("accent", "/onboard") + chalk24.dim(" first for a richer demo,"));
-    console.error("  " + chalk24.dim("or pass ") + paint("accent", "--no-profile") + chalk24.dim(" to skip."));
+    console.error("  " + chalk26.red("No company profile found."));
+    console.error("  " + chalk26.dim("Run ") + paint("accent", "/onboard") + chalk26.dim(" first for a richer demo,"));
+    console.error("  " + chalk26.dim("or pass ") + paint("accent", "--no-profile") + chalk26.dim(" to skip."));
     console.error();
     markFailure(ctx);
     return false;
@@ -22794,8 +23569,8 @@ async function handler2(args, ctx) {
   const explicitScenario = getString(flags, "scenario", "s");
   const resolvedScenario = resolveScenarioInput(explicitScenario);
   if (resolvedScenario === null) {
-    console.error(chalk24.red(`  Unknown scenario: ${explicitScenario}`));
-    console.log(chalk24.dim(`  Valid: ${SCENARIO_LIST.map((s) => s.key).join(", ")}`));
+    console.error(chalk26.red(`  Unknown scenario: ${explicitScenario}`));
+    console.log(chalk26.dim(`  Valid: ${SCENARIO_LIST.map((s) => s.key).join(", ")}`));
     markFailure(ctx);
     return false;
   }
@@ -22809,10 +23584,10 @@ async function handler2(args, ctx) {
     const s = getScenario(scenario);
     console.log();
     if (brief) {
-      console.log("  " + paint("accent", "\u2713 Demo: ") + bold(s.label) + chalk24.dim(" \u2014 " + s.hook));
+      console.log("  " + paint("accent", "\u2713 Demo: ") + bold(s.label) + chalk26.dim(" \u2014 " + s.hook));
     } else {
       console.log("  " + paint("accent", "\u2713 Scenario: ") + bold(s.label));
-      console.log("  " + chalk24.dim(s.story));
+      console.log("  " + chalk26.dim(s.story));
       console.log();
     }
   }
@@ -22842,18 +23617,18 @@ async function handler2(args, ctx) {
         if (brief) {
           spinner.succeed(`Demo loaded \u2014 ${briefCounts(result.counts)}`);
         } else {
-          spinner.succeed(`Generated demo data for "${chalk24.cyan(scenario)}" scenario`);
+          spinner.succeed(`Generated demo data for "${chalk26.cyan(scenario)}" scenario`);
           console.log();
           printEntityCounts(result.counts);
         }
       }
       if (!quiet && !brief && ctx.analysis.primary !== "revenue_metrics") {
-        console.log(chalk24.dim("\n  Run /diagnose to compute vital signs.\n"));
+        console.log(chalk26.dim("\n  Run /diagnose to compute vital signs.\n"));
       }
     }
   } catch (err) {
     if (spinner) spinner.fail("Generation failed");
-    console.error(chalk24.red(String(err)));
+    console.error(chalk26.red(String(err)));
     markFailure(ctx);
     return false;
   }
@@ -22891,7 +23666,7 @@ async function loadOrBuildTaxonomy(profile, forceRegen, ctx) {
     return taxonomy;
   } catch (err) {
     spinner.fail("Couldn't build market taxonomy \u2014 using generic data pools");
-    console.log("  " + chalk24.dim(String(err.message ?? err)));
+    console.log("  " + chalk26.dim(String(err.message ?? err)));
     return void 0;
   }
 }
@@ -22986,7 +23761,7 @@ __export(inbox_setup_exports, {
   reuseInboxFolderIfPresent: () => reuseInboxFolderIfPresent,
   shouldOfferInboxSkillSetup: () => shouldOfferInboxSkillSetup
 });
-import chalk25 from "chalk";
+import chalk27 from "chalk";
 import { existsSync as existsSync22 } from "fs";
 function markDemoOffered() {
   setConfigValue("ai-inbox-nudge-seen", "true");
@@ -23008,27 +23783,27 @@ function printSkipHint(beat) {
   const skillCmd = paint("accent", "/inbox skill");
   if (beat === "demo") {
     console.log(
-      "  " + chalk25.dim("Skipped. NTRP will ask once when you load your own data. Or type ") + setCmd + chalk25.dim(" then ") + skillCmd
+      "  " + chalk27.dim("Skipped. NTRP will ask once when you load your own data. Or type ") + setCmd + chalk27.dim(" then ") + skillCmd
     );
     return;
   }
   console.log(
-    "  " + chalk25.dim("Skipped. NTRP will not ask again. Type ") + setCmd + chalk25.dim(" then ") + skillCmd + chalk25.dim(" at any time.")
+    "  " + chalk27.dim("Skipped. NTRP will not ask again. Type ") + setCmd + chalk27.dim(" then ") + skillCmd + chalk27.dim(" at any time.")
   );
 }
 async function reuseInboxFolderIfPresent(session, beat, folderPath = defaultAiInboxDir()) {
   if (getAiInboxDir()) return false;
   if (!existsSync22(folderPath)) return false;
-  console.log("  " + chalk25.dim("Pickup folder still on disk: ") + folderPath);
+  console.log("  " + chalk27.dim("Pickup folder still on disk: ") + folderPath);
   const reuse = await session.confirm("Reuse this pickup folder?", true);
   if (!reuse) return false;
   const resolved = setAiInboxDir(folderPath);
   markDemoOffered();
   if (beat === "production") markProductionOffered();
   console.log();
-  console.log("  " + paint("accent", "Inbox ready") + chalk25.dim("  ") + resolved);
+  console.log("  " + paint("accent", "Inbox ready") + chalk27.dim("  ") + resolved);
   console.log(
-    "  " + chalk25.dim("Folder reused. Type ") + paint("accent", "/inbox skill") + chalk25.dim(" to print the finder again.")
+    "  " + chalk27.dim("Folder reused. Type ") + paint("accent", "/inbox skill") + chalk27.dim(" to print the finder again.")
   );
   console.log();
   return true;
@@ -23039,12 +23814,12 @@ async function offerInboxSkillSetup(session, opts = {}) {
   console.log();
   console.log("  " + bold("Teach Claude where handoffs live"));
   console.log(
-    "  " + chalk25.dim(
+    "  " + chalk27.dim(
       "Optional. NTRP copies every handoff into one folder. You paste instructions once; later /handoff just writes the file."
     )
   );
   if (beat === "production" && getConfigValue("ai-inbox-nudge-seen") === "true") {
-    console.log("  " + chalk25.dim("You skipped this during demo."));
+    console.log("  " + chalk27.dim("You skipped this during demo."));
   }
   console.log();
   if (await reuseInboxFolderIfPresent(session, beat)) return;
@@ -23075,16 +23850,16 @@ async function offerInboxSkillSetup(session, opts = {}) {
   markDemoOffered();
   if (beat === "production") markProductionOffered();
   console.log();
-  console.log("  " + paint("accent", "Inbox ready") + chalk25.dim("  ") + resolved);
+  console.log("  " + paint("accent", "Inbox ready") + chalk27.dim("  ") + resolved);
   if (n > 0) {
-    console.log("  " + chalk25.dim(`Synced ${n} recent export${n === 1 ? "" : "s"}.`));
+    console.log("  " + chalk27.dim(`Synced ${n} recent export${n === 1 ? "" : "s"}.`));
   }
   console.log(
-    "  " + chalk25.dim("Paste this skill into Claude once. Later, tell Claude to open the latest NTRP handoff.")
+    "  " + chalk27.dim("Paste this skill into Claude once. Later, tell Claude to open the latest NTRP handoff.")
   );
   printStandingSkill();
   await session.askPressEnter("Paste the skill into Claude. Then continue");
-  console.log("  " + chalk25.dim("Done. Later handoffs write to that folder. The skill is not printed again."));
+  console.log("  " + chalk27.dim("Done. Later handoffs write to that folder. The skill is not printed again."));
   console.log();
 }
 async function maybeOfferInboxOnProduction(ctx) {
@@ -23117,7 +23892,7 @@ var ingest_exports = {};
 __export(ingest_exports, {
   handler: () => handler3
 });
-import chalk26 from "chalk";
+import chalk28 from "chalk";
 import { readFileSync as readFileSync20, existsSync as existsSync23 } from "fs";
 import { basename as basename6 } from "path";
 async function handler3(args, ctx) {
@@ -23138,21 +23913,21 @@ async function handler3(args, ctx) {
   const source = getString(flags, "source", "s") ?? "salesforce";
   const skipResolve = getBool(flags, "skip-resolve");
   if (!file) {
-    console.error(chalk26.red("  Usage: /ingest <file> [--source salesforce|hubspot|outreach]"));
-    console.error(chalk26.dim("         /ingest --demo [--scenario <name>]"));
+    console.error(chalk28.red("  Usage: /ingest <file> [--source salesforce|hubspot|outreach]"));
+    console.error(chalk28.dim("         /ingest --demo [--scenario <name>]"));
     process.exit(1);
   }
   if (!existsSync23(file)) {
-    console.error(chalk26.red(`  File not found: ${file}`));
+    console.error(chalk28.red(`  File not found: ${file}`));
     process.exit(1);
   }
   const profile = loadProfile();
   const skipProfile = getFalse(flags, "profile");
   if (!profile && !skipProfile) {
     console.error();
-    console.error("  " + chalk26.red("No company profile found."));
-    console.error("  " + chalk26.dim("Run ") + paint("accent", "/onboard") + chalk26.dim(" first for better column mapping,"));
-    console.error("  " + chalk26.dim("or pass ") + paint("accent", "--no-profile") + chalk26.dim(" to skip."));
+    console.error("  " + chalk28.red("No company profile found."));
+    console.error("  " + chalk28.dim("Run ") + paint("accent", "/onboard") + chalk28.dim(" first for better column mapping,"));
+    console.error("  " + chalk28.dim("or pass ") + paint("accent", "--no-profile") + chalk28.dim(" to skip."));
     console.error();
     process.exit(1);
   }
@@ -23184,15 +23959,15 @@ async function handler3(args, ctx) {
         row_count: result2.imported
       });
       spinner.succeed(
-        `Imported ${chalk26.bold(result2.imported.toString())} revenue events from ${chalk26.dim(basename6(file))}`
+        `Imported ${chalk28.bold(result2.imported.toString())} revenue events from ${chalk28.dim(basename6(file))}`
       );
       if (result2.errors.length > 0) {
-        console.log(chalk26.yellow(`  ${result2.errors.length} rows skipped`));
+        console.log(chalk28.yellow(`  ${result2.errors.length} rows skipped`));
       }
       if (ctx.analysis) {
         ctx.analysis.data_source_type = "revenue_ledger";
       }
-      console.log(chalk26.dim("  Run ") + chalk26.cyan("/metrics") + chalk26.dim(" for SaaS metrics with ledger-backed retention."));
+      console.log(chalk28.dim("  Run ") + chalk28.cyan("/metrics") + chalk28.dim(" for SaaS metrics with ledger-backed retention."));
       const { maybeOfferInboxOnProduction: maybeOfferInboxOnProduction3 } = await Promise.resolve().then(() => (init_inbox_setup(), inbox_setup_exports));
       await maybeOfferInboxOnProduction3(ctx);
       return `${result2.imported} revenue events from ${basename6(file)}`;
@@ -23201,7 +23976,7 @@ async function handler3(args, ctx) {
     const detection = detectEntityType(headers, source);
     if (!detection) {
       spinner.fail(`Could not auto-detect entity type for source: ${source}`);
-      console.log(chalk26.dim("  Headers found: " + headers.join(", ")));
+      console.log(chalk28.dim("  Headers found: " + headers.join(", ")));
       process.exit(1);
     }
     spinner.text = `Importing ${rows.length} ${detection.entityType} rows...`;
@@ -23224,15 +23999,15 @@ async function handler3(args, ctx) {
       row_count: result.imported
     });
     spinner.succeed(
-      `Imported ${chalk26.bold(result.imported.toString())} ${detection.entityType} from ${chalk26.dim(basename6(file))} (${source})`
+      `Imported ${chalk28.bold(result.imported.toString())} ${detection.entityType} from ${chalk28.dim(basename6(file))} (${source})`
     );
     if (result.errors.length > 0) {
-      console.log(chalk26.yellow(`  ${result.errors.length} rows skipped`));
+      console.log(chalk28.yellow(`  ${result.errors.length} rows skipped`));
       for (const err of result.errors.slice(0, 3)) {
-        console.log(chalk26.dim(`    - ${err}`));
+        console.log(chalk28.dim(`    - ${err}`));
       }
       if (result.errors.length > 3) {
-        console.log(chalk26.dim(`    ... and ${result.errors.length - 3} more`));
+        console.log(chalk28.dim(`    ... and ${result.errors.length - 3} more`));
       }
     }
     if (!skipResolve) {
@@ -23251,7 +24026,7 @@ async function handler3(args, ctx) {
     return `${result.imported} ${detection.entityType} from ${basename6(file)}`;
   } catch (err) {
     spinner.fail("Import failed");
-    console.error(chalk26.red(String(err)));
+    console.error(chalk28.red(String(err)));
     process.exit(1);
   }
 }
@@ -23363,13 +24138,13 @@ __export(demo_fit_exports, {
   resolveDemoScenarioForLoad: () => resolveDemoScenarioForLoad,
   runDemoFitQuiz: () => runDemoFitQuiz
 });
-import chalk27 from "chalk";
+import chalk29 from "chalk";
 async function runDemoFitQuiz(session, opts = {}) {
   if (opts.intro !== false) {
     console.log();
     console.log("  " + bold("Fit a sample book of business"));
     console.log(
-      "  " + chalk27.dim(
+      "  " + chalk29.dim(
         "No API key needed. Two questions about how you sell, then you pick which of seven sample pipelines feels closest."
       )
     );
@@ -23387,8 +24162,8 @@ async function runDemoFitQuiz(session, opts = {}) {
   );
   const recommended = inferDemoScenario({ salesMotion: motion, dealBand });
   console.log();
-  console.log("  " + chalk27.dim("Recommended: ") + paint("accent", getScenario(recommended.scenario).label));
-  console.log("  " + chalk27.dim(recommended.reason));
+  console.log("  " + chalk29.dim("Recommended: ") + paint("accent", getScenario(recommended.scenario).label));
+  console.log("  " + chalk29.dim(recommended.reason));
   const scenario = await session.choose(
     "Which of these sample books feels closest to the one you manage?",
     scenarioMenuChoices(),
@@ -23408,8 +24183,8 @@ async function offerFittedDemoAfterOnboard(session, ctx, profile) {
   const s = getScenario(fit.scenario);
   console.log();
   console.log("  " + bold("A sample pipeline that looks like you"));
-  console.log("  " + paint("accent", s.label) + chalk27.dim(" \u2014 " + s.hook));
-  console.log("  " + chalk27.dim(fit.reason));
+  console.log("  " + paint("accent", s.label) + chalk29.dim(" \u2014 " + s.hook));
+  console.log("  " + chalk29.dim(fit.reason));
   console.log();
   const action = await session.choose(
     "Try NTRP on that book of business?",
@@ -23466,8 +24241,8 @@ async function resolveDemoScenarioForLoad(ctx, opts = {}) {
     if (!opts.forceQuiz && isProfileConfigured(profile) && profile) {
       const fit = await resolveProfileFit(profile, ctx);
       console.log();
-      console.log("  " + chalk27.dim("Recommended: ") + paint("accent", getScenario(fit.scenario).label));
-      console.log("  " + chalk27.dim(fit.reason));
+      console.log("  " + chalk29.dim("Recommended: ") + paint("accent", getScenario(fit.scenario).label));
+      console.log("  " + chalk29.dim(fit.reason));
       const scenario = await session.choose(
         "Which sample book of business?",
         scenarioMenuChoices(),
@@ -23531,7 +24306,7 @@ __export(ingest_chat_exports, {
 import { existsSync as existsSync24 } from "fs";
 import { basename as basename7, resolve as resolve9 } from "path";
 import { homedir as homedir8 } from "os";
-import chalk28 from "chalk";
+import chalk30 from "chalk";
 function extractFilePath(input) {
   const trimmed = input.trim();
   const patterns = [
@@ -23566,7 +24341,7 @@ function looksLikeFilePath(input) {
 }
 async function ingestFromChat(ctx, filePath) {
   if (!ctx.rl) {
-    console.log("  " + chalk28.red("Ingest confirm requires interactive mode."));
+    console.log("  " + chalk30.red("Ingest confirm requires interactive mode."));
     return false;
   }
   const name = basename7(filePath);
@@ -23574,7 +24349,7 @@ async function ingestFromChat(ctx, filePath) {
   try {
     const ok = await prompts.confirm(`Ingest ${name} as CRM export?`, true);
     if (!ok) {
-      console.log("  " + chalk28.dim("Ingest cancelled."));
+      console.log("  " + chalk30.dim("Ingest cancelled."));
       return false;
     }
   } finally {
@@ -23602,7 +24377,7 @@ async function ingestFromChat(ctx, filePath) {
         true
       );
       if (useAi) {
-        console.log("  " + chalk28.dim("AI column mapping is not wired to ingest yet \u2014 trying standard ingest."));
+        console.log("  " + chalk30.dim("AI column mapping is not wired to ingest yet \u2014 trying standard ingest."));
       }
     } finally {
       prompts2.close();
@@ -23629,7 +24404,7 @@ async function ingestFromChat(ctx, filePath) {
   invalidateGapAudit(ctx);
   saveSessionState(ctx);
   console.log();
-  console.log("  " + paint("accent", "\u2713 Data loaded") + chalk28.dim(` \u2014 ${name}`));
+  console.log("  " + paint("accent", "\u2713 Data loaded") + chalk30.dim(` \u2014 ${name}`));
   recordMessage(ctx, "user", `[ingested ${name}]`);
   recordMessage(ctx, "agent", `Loaded ${name}. Checking what we can analyze\u2026`);
   const audit = await refreshGapAudit(ctx);
@@ -23637,7 +24412,7 @@ async function ingestFromChat(ctx, filePath) {
   if (audit.can_compute && ctx.scope?.confirmed_at) {
     if (ctx.pendingAsk) {
       console.log();
-      console.log("  " + chalk28.dim("Computing so I can answer\u2026"));
+      console.log("  " + chalk30.dim("Computing so I can answer\u2026"));
       await runConversationCompute(ctx);
       return true;
     }
@@ -23685,7 +24460,7 @@ async function loadDemoFromChat(ctx, scenario, opts = {}) {
     const { getScenario: getScenario2 } = await Promise.resolve().then(() => (init_scenarios(), scenarios_exports));
     const s = getScenario2(chosen);
     console.log();
-    console.log("  " + paint("accent", "Fitting ") + s.label + chalk28.dim(" \u2014 " + s.hook));
+    console.log("  " + paint("accent", "Fitting ") + s.label + chalk30.dim(" \u2014 " + s.hook));
   }
   const { handler: demo } = await Promise.resolve().then(() => (init_generate(), generate_exports));
   const args = ["--no-profile", "--brief"];
@@ -23721,7 +24496,7 @@ async function loadDemoFromChat(ctx, scenario, opts = {}) {
   const shouldAuto = opts.autoCompute || Boolean(ctx.pendingAsk && audit.can_compute && ctx.scope?.confirmed_at);
   if (shouldAuto && audit.can_compute) {
     console.log();
-    console.log("  " + chalk28.dim("Computing so I can answer\u2026"));
+    console.log("  " + chalk30.dim("Computing so I can answer\u2026"));
     await runConversationCompute(ctx);
     return true;
   }
@@ -23754,7 +24529,7 @@ __export(pending_ask_exports, {
   queuePendingAsk: () => queuePendingAsk,
   resumePendingAsk: () => resumePendingAsk
 });
-import chalk29 from "chalk";
+import chalk31 from "chalk";
 function looksLikeQuestion(input) {
   const text = input.trim();
   if (!text) return false;
@@ -23790,7 +24565,7 @@ function printFocusChip(ctx) {
   const period = ctx.scope.time_horizon ? ` \xB7 ${ctx.scope.time_horizon}` : "";
   console.log();
   console.log(
-    "  " + chalk29.dim("Focus: ") + paint("accent", lens) + chalk29.dim(period) + chalk29.dim(" \u2014 type ") + chalk29.cyan("adjust") + chalk29.dim(" to change")
+    "  " + chalk31.dim("Focus: ") + paint("accent", lens) + chalk31.dim(period) + chalk31.dim(" \u2014 type ") + chalk31.cyan("adjust") + chalk31.dim(" to change")
   );
   console.log();
 }
@@ -23801,7 +24576,7 @@ async function resumePendingAsk(ctx) {
   if (canUseReplAi(ctx)) {
     console.log();
     console.log(
-      "  " + chalk29.dim(
+      "  " + chalk31.dim(
         pending.keylessAnswered ? "Picking up your question with the connected engine\u2026" : "Picking up your question\u2026"
       )
     );
@@ -23834,7 +24609,7 @@ async function offerDemoToAnswer(ctx) {
     const go = await prompts.confirm("Use demo data to answer this?", true);
     if (!go) {
       console.log(
-        "  " + chalk29.dim("Paste a CSV path when ready, or say ") + chalk29.cyan("use demo data") + chalk29.dim(".")
+        "  " + chalk31.dim("Paste a CSV path when ready, or say ") + chalk31.cyan("use demo data") + chalk31.dim(".")
       );
       console.log();
       return false;
@@ -23866,11 +24641,11 @@ __export(compute_exports2, {
   isComputeIntent: () => isComputeIntent,
   runConversationCompute: () => runConversationCompute
 });
-import chalk30 from "chalk";
+import chalk32 from "chalk";
 async function runConversationCompute(ctx) {
   const lens = ctx.scope?.primary_lens ?? ctx.analysis.primary;
   ctx.computeInProgress = true;
-  const willAnswer = Boolean(ctx.pendingAsk?.text) && !ctx.strategistState;
+  const willAnswer = Boolean(ctx.pendingAsk?.text) && !ctx.strategistState && ctx.thinkState?.step !== "awaiting_analysis";
   try {
     if (lens === "revenue_metrics") {
       const { runMetricsAnalysis: runMetricsAnalysis2, extractHeadlineMetrics: extractHeadlineMetrics2 } = await Promise.resolve().then(() => (init_metrics_analysis(), metrics_analysis_exports));
@@ -23898,6 +24673,7 @@ async function runConversationCompute(ctx) {
           interactive: !willAnswer
         });
         await resumeQueuedStrategist(ctx);
+        await resumeQueuedThink(ctx);
         await closeComputeTurn(ctx, willAnswer, "revenue_metrics");
         creditGapCompute(ctx);
         creditMetricsComplete(ctx, false);
@@ -23917,11 +24693,12 @@ async function runConversationCompute(ctx) {
     invalidateGapAudit(ctx);
     saveSessionState(ctx);
     await resumeQueuedStrategist(ctx);
+    await resumeQueuedThink(ctx);
     await closeComputeTurn(ctx, willAnswer, "gtm_health");
     creditGapCompute(ctx);
     return typeof summary === "string" ? summary : "Health analysis ready";
   } catch (err) {
-    console.error("  " + chalk30.red(String(err.message ?? err)));
+    console.error("  " + chalk32.red(String(err.message ?? err)));
     return;
   } finally {
     ctx.computeInProgress = false;
@@ -23934,9 +24711,16 @@ async function resumeQueuedStrategist(ctx) {
   const { resumeStrategistAfterCompute: resumeStrategistAfterCompute2 } = await Promise.resolve().then(() => (init_strategist_flow(), strategist_flow_exports));
   await resumeStrategistAfterCompute2(ctx);
 }
+async function resumeQueuedThink(ctx) {
+  if (ctx.thinkState?.step !== "awaiting_analysis") return;
+  ctx.computeInProgress = false;
+  const { resumeThinkAfterCompute: resumeThinkAfterCompute2 } = await Promise.resolve().then(() => (init_think_flow(), think_flow_exports));
+  await resumeThinkAfterCompute2(ctx);
+}
 async function resumePendingAskAfterCompute(ctx) {
   if (!ctx.pendingAsk?.text) return false;
   if (ctx.strategistState) return false;
+  if (ctx.thinkState?.step === "active" || ctx.thinkState?.step === "awaiting_analysis") return false;
   const { resumePendingAsk: resumePendingAsk2 } = await Promise.resolve().then(() => (init_pending_ask(), pending_ask_exports));
   return resumePendingAsk2(ctx);
 }
@@ -24405,6 +25189,7 @@ async function handleDraftStrategy(input) {
   if (!objective) return { error: "objective is required." };
   if (!isAnalysisReady2(ctx)) {
     ctx.strategistState = { step: "awaiting_analysis", objective, origin: "ai" };
+    if (ctx.thinkState) ctx.thinkState = void 0;
     saveSessionState2(ctx);
     return {
       queued: true,
@@ -24413,6 +25198,7 @@ async function handleDraftStrategy(input) {
     };
   }
   ctx.strategistState = { step: "objective_confirm", objective, origin: "ai" };
+  if (ctx.thinkState) ctx.thinkState = void 0;
   saveSessionState2(ctx);
   return {
     launched: true,
@@ -24420,6 +25206,32 @@ async function handleDraftStrategy(input) {
     note: "Strategist handoff armed. After your reply the user sees an objective confirmation card and the engine runs a full grounding/backcast/stress-test session. Keep your reply to one or two sentences introducing the handoff \u2014 do NOT write the plan yourself."
   };
 }
+async function handleUpdateThinkScratch(input) {
+  const { getAgentContext: getAgentContext2 } = await Promise.resolve().then(() => (init_agent_context(), agent_context_exports));
+  const { saveSessionState: saveSessionState2 } = await Promise.resolve().then(() => (init_context2(), context_exports));
+  const ctx = getAgentContext2();
+  if (!ctx) return { error: "No active session context." };
+  if (!ctx.thinkState || ctx.thinkState.step !== "active") {
+    return { error: "Think channel is not active." };
+  }
+  const asStringList = (value) => {
+    if (!Array.isArray(value)) return void 0;
+    return value.filter((v) => typeof v === "string").map((s) => s.trim()).filter(Boolean).slice(0, 12);
+  };
+  const open = asStringList(input.open_questions);
+  const challenged = asStringList(input.challenged_assumptions);
+  const hypotheses = asStringList(input.working_hypotheses);
+  if (open) ctx.thinkState.open_questions = open;
+  if (challenged) ctx.thinkState.challenged_assumptions = challenged;
+  if (hypotheses) ctx.thinkState.working_hypotheses = hypotheses;
+  saveSessionState2(ctx);
+  return {
+    updated: true,
+    open_questions: ctx.thinkState.open_questions ?? [],
+    challenged_assumptions: ctx.thinkState.challenged_assumptions ?? [],
+    working_hypotheses: ctx.thinkState.working_hypotheses ?? []
+  };
+}
 async function handleGetSessionBrief(input) {
   const raw = typeof input.session_id === "string" ? input.session_id.trim() : "";
   if (!raw) return { error: "session_id is required." };
@@ -24545,13 +25357,182 @@ var init_tool_handlers = __esm({
       audit_data_gaps: (_, __) => handleAuditDataGaps(),
       run_compute: (_, __) => handleRunCompute(),
       draft_handoff: (input, _) => handleDraftHandoff(input),
-      draft_strategy: (input, _) => handleDraftStrategy(input)
+      draft_strategy: (input, _) => handleDraftStrategy(input),
+      update_think_scratch: (input, _) => handleUpdateThinkScratch(input)
     };
   }
 });
 
-// src/ai/agentic-loop.ts
+// src/ai/think-prompt.ts
 function companyContextSection3() {
+  const block = buildCompanyProfileBlock();
+  return block ? `COMPANY CONTEXT:
+${block}
+
+` : "";
+}
+function operatorSection3() {
+  const block = buildOperatorBlock();
+  return block ? `${block}
+
+` : "";
+}
+function buildScratchBlock(state2) {
+  if (!state2) return "";
+  const lines = [];
+  if (state2.seed) lines.push(`Seed topic: ${state2.seed}`);
+  if (state2.open_questions?.length) {
+    lines.push("Open questions:");
+    for (const q of state2.open_questions) lines.push(`- ${q}`);
+  }
+  if (state2.challenged_assumptions?.length) {
+    lines.push("Challenged assumptions:");
+    for (const a of state2.challenged_assumptions) lines.push(`- ${a}`);
+  }
+  if (state2.working_hypotheses?.length) {
+    lines.push("Working hypotheses:");
+    for (const h of state2.working_hypotheses) lines.push(`- ${h}`);
+  }
+  if (lines.length === 0) return "";
+  return `
+THINK SCRATCH (session working memory \u2014 update via update_think_scratch):
+${lines.join("\n")}
+`;
+}
+function buildThinkWithMeSystemPrompt(opts = {}) {
+  const sessionBlock = opts.sessionContext ? `
+PREVIOUS SESSION CONTEXT:
+The user resumed an earlier session. Here is what they were investigating before:
+${opts.sessionContext}
+Treat this as already-established background. Pick up where it left off \u2014 do not re-introduce it as if it were new.
+
+` : "";
+  const memorySection = opts.memoryBlock ? `
+WHAT YOU ALREADY KNOW ABOUT THIS BUSINESS (durable memory):
+${opts.memoryBlock}
+Reference this naturally. Do not re-derive things you already know; build on them.
+
+` : "";
+  const analysisSection = opts.analysisBlock ? `
+SESSION ANALYSIS CONTEXT:
+${opts.analysisBlock}
+Use get_revenue_metrics and get_revenue_metrics_timeseries when the user asks about SaaS metrics, retention, or period trends.
+
+` : "";
+  const artifactSection = opts.sessionArtifact ? `
+COMPLETED SESSION ANALYSIS:
+${opts.sessionArtifact}
+Cite numbers from here; call tools when you need a new cut or to pressure-test a claim.
+
+` : "";
+  const conversationSection = opts.conversationBlock ? `
+CONVERSATION STATE:
+${opts.conversationBlock}
+
+` : "";
+  const scratchSection = buildScratchBlock(opts.thinkState);
+  const socraticCraft = `HOW YOU THINK WITH THE USER (socratic partner \u2014 not a search box, not a strategist):
+- You are a thinking partner. Prefer sharp questions that unlock the user's idea over dumping answers.
+- Protect imagination: give "what if" space before the smell-test \u2014 do not kill creativity in the first sentence.
+- Steelman the user's position before you attack it; then deliver one hard pushback grounded in evidence when possible.
+- Ground claims about THIS pipeline in tool results. Label speculation explicitly ("hypothesis:", "speculation:").
+- Each turn should ADVANCE the thread: a new question, a challenge, a synthesis, or a fork \u2014 never rehash.
+- If the question is ambiguous, ask at most ONE clarifying question. Otherwise choose a fork and state it.
+- Never invent a multi-week roadmap inline. When they want commitment, call draft_strategy with a crisp objective.
+- Keep open_questions, challenged_assumptions, and working_hypotheses current via update_think_scratch.
+- You have continuity via prior think-channel messages. Never repeat an angle already covered unless asked.`;
+  const jobSection = `YOUR JOB (THINK CHANNEL \u2014 always deep):
+- Decide whether you need tools, a direct answer, or both. Do not re-call a tool whose result you already have.
+- Lead with the answer or the question that matters most, then structure.
+- When you use numbers, include dollar values where available and lead with financial impact.
+- Descriptive exploration stays in this channel; plan-of-attack questions hand off via draft_strategy.
+- After a successful draft_strategy tool result: reply with at most 1\u20132 sentences introducing the handoff. Do not write the plan.`;
+  const formattingSection = `
+FORMATTING (your answer is rendered in a terminal via a small markdown renderer):
+- Use **bold** for every dollar figure, score, play name, and person name.
+- Use *italics* for conversational asides and your closing follow-up question.
+- Use ### for section headings \u2014 never # or ##. The renderer flattens depth.
+- For multi-point answers, prefer a one-line lead + bullet list over long paragraph blocks.
+- Keep paragraphs to 3-4 sentences.
+- Prefer short tables (\u22643 columns, \u22645 rows, cells \u226430 chars).
+- End with a dim horizontal rule (---) followed by one italicized follow-up question or fork.
+
+${buildUserVisibleProseBlock()}
+`;
+  const commandSection = `PRESET COMMANDS (slash commands the user can type \u2014 you may SUGGEST these; you cannot run them):
+${buildCommandCatalogBlock()}
+
+COMMAND SUGGESTION RULES:
+- Suggest at most ONE command when it adds capability beyond your answer (e.g. \`/strategy\`, \`/handoff\`).
+- Never claim a command was run. Never invent flags.
+- Type \`done\` or \`cancel\` leaves the think channel back to ask \u203A.`;
+  const stable = `You are a world-class GTM operating partner in a dedicated THINK WITH ME channel. The user wants collaborative exploration \u2014 imagination, pressure-testing, and evidence \u2014 not a slide deck and not a finished strategy plan.
+
+${companyContextSection3()}${operatorSection3()}${socraticCraft}
+
+ANALYST INSTINCT (judgment a CEO pays for \u2014 apply by default):
+${ANALYST_INSTINCT_BLOCK}
+
+${jobSection}
+
+EXECUTION BIAS (how you work):
+${EXECUTION_BIAS_BLOCK}
+
+GTM ENGINEERING (how recommendations become systems):
+${GTM_ENGINEERING_BLOCK}
+
+OUTPUT DOCTRINE (how answers are structured for recall):
+${PYRAMID_OUTPUT_BLOCK}
+
+${buildUserVisibleProseBlock()}
+
+CONTEXT:
+The user's health scores and top divergences were included as JSON at the start of this conversation. Use them, the think-channel history, and SESSION STATE as background and as hints for which tools to call.
+
+VITAL SIGNS EXPLAINED (with dollar translations):
+${VITAL_SIGNS_BLOCK}
+
+PLAYBOOK \u2014 name a play when it helps the user act (not a full program):
+${buildPlaybookBlock()}
+
+${commandSection}
+${formattingSection}
+OUTPUT RULES:
+- Respond in plain text markdown (not JSON). You do NOT need to emit the findings schema.
+- Include specific numbers from tool results, never guess.
+- When you have enough information, answer or ask \u2014 don't call tools you don't need.
+
+SAFETY & EVIDENCE (non-negotiable):
+${SAFETY_BLOCK}`;
+  const dynamicSections = [
+    sessionBlock,
+    memorySection,
+    analysisSection,
+    artifactSection,
+    conversationSection,
+    scratchSection
+  ].map((s) => s.trim()).filter(Boolean);
+  const dynamic = [
+    "SESSION STATE (current \u2014 changes as the session progresses):",
+    ...dynamicSections,
+    buildRuntimeBlock()
+  ].join("\n\n");
+  return { stable, dynamic };
+}
+var init_think_prompt = __esm({
+  "src/ai/think-prompt.ts"() {
+    "use strict";
+    init_prompt_parts();
+    init_prompt();
+  }
+});
+
+// src/ai/agentic-loop.ts
+function findingsJsonSchemaNudge() {
+  return `Respond with ONLY a JSON array of finding objects \u2014 no prose, no markdown fences. Each object needs: severity, segment, finding, vital_signs, entity_count, recommended_focus, dollar_value, recommended_plays. Shape:
+${buildFindingsSchemaBlock()}`;
+}
+function companyContextSection4() {
   const block = buildCompanyProfileBlock();
   if (!block) return "";
   return `COMPANY CONTEXT (use this to make every answer specific to the business \u2014 use industry-appropriate language, anchor dollar figures to their deal size):
@@ -24559,7 +25540,7 @@ ${block}
 
 `;
 }
-function operatorSection3() {
+function operatorSection4() {
   const block = buildOperatorBlock();
   if (!block) return "";
   return `${block}
@@ -24569,7 +25550,7 @@ function operatorSection3() {
 function buildSystemPrompt2() {
   const stable = `You are an expert GTM health investigator. You have tools to query a local database of CRM and pipeline data. Your job is to investigate the health scores you've been given and discover the specific root causes behind any problems.
 
-${companyContextSection3()}${operatorSection3()}INVESTIGATION APPROACH:
+${companyContextSection4()}${operatorSection4()}INVESTIGATION APPROACH:
 1. Start by examining the health summary to understand the overall picture
 2. Drill into the lowest-scoring vital signs using get_vital_sign_detail
 3. Check divergences to find segments that are significantly worse than average
@@ -24595,7 +25576,7 @@ ${buildPlaybookBlock()}
 OUTPUT DOCTRINE (how findings are structured for recall):
 ${PYRAMID_OUTPUT_BLOCK}
 
-${USER_VISIBLE_STE_BLOCK}
+${buildUserVisibleProseBlock()}
 
 RULES:
 - Build evidence BEFORE claiming a finding. Call at least 2 tools before emitting a finding.
@@ -24617,7 +25598,7 @@ FORMATTING (the \`finding\` field on each finding is rendered in a terminal via
 - Never place emoji inside a table cell or heading \u2014 they break column alignment.
 
 OUTPUT FORMAT \u2014 when you're ready to present findings, respond with ONLY a JSON array:
-${FINDINGS_SCHEMA_BLOCK}
+${buildFindingsSchemaBlock()}
 
 Keep investigating until you have a clear picture. Don't guess \u2014 use the tools.`;
   return { stable, dynamic: buildRuntimeBlock() };
@@ -24700,7 +25681,7 @@ FORMATTING (your answer is rendered in a terminal via a small markdown renderer)
 - Use \`inline code\` for CRM field names, SQL snippets, or literal values.
 - End with a dim horizontal rule (---) followed by one italicized follow-up question.
 
-${USER_VISIBLE_STE_BLOCK}
+${buildUserVisibleProseBlock()}
 ` : `
 FORMATTING (brief mode \u2014 scannable, not chunky):
 - Open with ONE direct sentence that answers the question. Then a blank line before any list.
@@ -24715,7 +25696,7 @@ FORMATTING (brief mode \u2014 scannable, not chunky):
 - No ### headings, no tables, no --- footer, no closing "want me to dig deeper?" question.
 - Single-point answers can stay one sentence \u2014 don't force bullets when one line is enough.
 
-${USER_VISIBLE_STE_BLOCK}
+${buildUserVisibleProseBlock()}
 `;
   const commandStyleRule = responseMode === "brief" ? '- Style in brief mode: a suggestion is at most ONE short trailing line after your answer (e.g. "`/segment compare enterprise smb` gives the full side-by-side.") \u2014 no heading, no footer.' : "- Style: weave the suggestion naturally into your close \u2014 one sentence with the exact invocation in `inline code`.";
   const commandSection = `PRESET COMMANDS (slash commands the user can type at the prompt \u2014 you may SUGGEST these; you have no ability to run them):
@@ -24743,7 +25724,7 @@ ${GTM_ENGINEERING_BLOCK}
 OUTPUT DOCTRINE (how answers are structured for recall):
 ${PYRAMID_OUTPUT_BLOCK}
 
-${USER_VISIBLE_STE_BLOCK}
+${buildUserVisibleProseBlock()}
 
 `;
   const referenceSection = responseMode === "brief" ? "" : `CONTEXT:
@@ -24758,7 +25739,7 @@ ${buildPlaybookBlock()}
 ${commandSection}`;
   const stable = `You are a world-class GTM operating partner \u2014 the kind of analyst a CEO keeps on speed dial. You are exceptionally well-read, rigorous, and commercially sharp, and you have tools to query a local database of this company's CRM and pipeline data. The user is having an ongoing, free-form conversation with you about their go-to-market health and SaaS metrics.
 
-${companyContextSection3()}${operatorSection3()}${conversationRules}
+${companyContextSection4()}${operatorSection4()}${conversationRules}
 
 ${analystSection}
 
@@ -24804,20 +25785,27 @@ async function* agenticFindings(computeResult, divergences, options) {
   assertReplAi(options.ctx);
   const mode = options.mode ?? "investigation";
   const experiment = options.experiment ?? "production";
-  const responseMode = experiment === "baseline" || experiment === "a" || experiment === "b" ? "deep" : options.responseMode ?? (options.sessionArtifact ? "brief" : "deep");
-  const useTools = mode === "investigation" || responseMode === "deep";
+  const responseMode = mode === "think" ? "deep" : experiment === "baseline" || experiment === "a" || experiment === "b" ? "deep" : options.responseMode ?? (options.sessionArtifact ? "brief" : "deep");
+  const useTools = mode === "investigation" || mode === "think" || responseMode === "deep";
   const maxTokens = mode === "fresh" && responseMode === "brief" ? BRIEF_MAX_TOKENS : DEEP_MAX_TOKENS;
   const surface = mode === "fresh" ? responseMode === "brief" ? "agentic_fresh_brief" : "agentic_investigation" : "agentic_investigation";
   const llmCfg = loadLlmConfig();
   const tier = tierForSurface(surface, llmCfg.tier);
-  const systemPrompt = mode === "fresh" ? buildFreshNlSystemPrompt(
+  const systemPrompt = mode === "think" ? buildThinkWithMeSystemPrompt({
+    sessionContext: options.sessionContext,
+    memoryBlock: options.memoryBlock,
+    analysisBlock: options.analysisBlock,
+    conversationBlock: options.conversationBlock,
+    sessionArtifact: options.sessionArtifact,
+    thinkState: options.ctx.thinkState
+  }) : mode === "fresh" ? buildFreshNlSystemPrompt(
     options.sessionContext,
     options.memoryBlock,
     options.analysisBlock,
     options.conversationBlock,
     { responseMode, sessionArtifact: options.sessionArtifact, experiment }
   ) : buildSystemPrompt2();
-  const tools2 = useTools ? mode === "fresh" ? buildFreshNlTools() : buildInvestigationTools() : [];
+  const tools2 = useTools ? mode === "think" ? buildThinkTools() : mode === "fresh" ? buildFreshNlTools() : buildInvestigationTools() : [];
   const toolCtx = { computeResult, divergences };
   if (options.includeMetrics) {
     try {
@@ -24829,7 +25817,8 @@ async function* agenticFindings(computeResult, divergences, options) {
   const initialContext = buildInitialContext(computeResult, divergences, options.userQuestion);
   const priorRaw = options.priorMessages ?? [];
   const priorMessages = priorRaw.length > 0 && typeof priorRaw[0] === "object" && priorRaw[0] !== null && "content" in priorRaw[0] ? normalizeThread(priorRaw) : priorRaw;
-  const messages = mode === "fresh" && priorMessages.length > 0 && options.userQuestion ? [...priorMessages, { role: "user", content: options.userQuestion }] : [{ role: "user", content: initialContext }];
+  const conversational = mode === "fresh" || mode === "think";
+  const messages = conversational && priorMessages.length > 0 && options.userQuestion ? [...priorMessages, { role: "user", content: options.userQuestion }] : [{ role: "user", content: initialContext }];
   let lastMeta = { provider_used: "anthropic", model_used: "unknown" };
   const loopGuard = new ToolLoopGuard();
   const allowedTools = new Set(tools2.map((t) => t.name));
@@ -24859,7 +25848,7 @@ async function* agenticFindings(computeResult, divergences, options) {
     const response = await callLlm(messages, maxTokens, true);
     if (response.tool_calls.length === 0) {
       const fullText = response.text;
-      if (mode === "fresh") {
+      if (conversational) {
         const findings3 = parseFindings(fullText);
         if (findings3.length > 0) {
           for (const finding of findings3) yield { type: "finding", finding };
@@ -24879,7 +25868,7 @@ async function* agenticFindings(computeResult, divergences, options) {
         messages.push(retry.assistant_message);
       }
       if (findings2.length === 0) {
-        messages.push({ role: "user", content: FINDINGS_JSON_SCHEMA_NUDGE });
+        messages.push({ role: "user", content: findingsJsonSchemaNudge() });
         const retry2 = await callLlm(messages, maxTokens, false);
         findings2 = parseFindings(retry2.text);
         messages.push(retry2.assistant_message);
@@ -24907,7 +25896,7 @@ async function* agenticFindings(computeResult, divergences, options) {
       });
     }
   }
-  if (mode === "fresh") {
+  if (conversational) {
     messages.push({
       role: "user",
       content: "You've reached the tool budget. Please answer the user's question now with what you've learned."
@@ -24926,7 +25915,7 @@ async function* agenticFindings(computeResult, divergences, options) {
   let findings = parseFindings(final.text);
   messages.push(final.assistant_message);
   if (findings.length === 0) {
-    messages.push({ role: "user", content: FINDINGS_JSON_SCHEMA_NUDGE });
+    messages.push({ role: "user", content: findingsJsonSchemaNudge() });
     final = await callLlm(messages, 4096, false);
     findings = parseFindings(final.text);
     messages.push(final.assistant_message);
@@ -24965,7 +25954,7 @@ Here is the current GTM health snapshot as background. Use it plus any tools you
 function parseFindings(text) {
   return (parseJsonArrayFromText(text) ?? []).map(withKnownRecommendedPlays);
 }
-var MAX_ITERATIONS, INVESTIGATION_EVIDENCE_NUDGE_AFTER, BRIEF_MAX_TOKENS, DEEP_MAX_TOKENS, FINDINGS_JSON_NUDGE, FINDINGS_JSON_SCHEMA_NUDGE;
+var MAX_ITERATIONS, INVESTIGATION_EVIDENCE_NUDGE_AFTER, BRIEF_MAX_TOKENS, DEEP_MAX_TOKENS, FINDINGS_JSON_NUDGE;
 var init_agentic_loop = __esm({
   "src/ai/agentic-loop.ts"() {
     "use strict";
@@ -24983,13 +25972,13 @@ var init_agentic_loop = __esm({
     init_thread();
     init_untrusted();
     init_prompt_parts();
+    init_think_prompt();
+    init_prompt();
     MAX_ITERATIONS = 10;
     INVESTIGATION_EVIDENCE_NUDGE_AFTER = 5;
     BRIEF_MAX_TOKENS = 768;
     DEEP_MAX_TOKENS = 4096;
     FINDINGS_JSON_NUDGE = "Please format your findings as the JSON array specified in your instructions. Respond with ONLY the JSON array, no other text.";
-    FINDINGS_JSON_SCHEMA_NUDGE = `Respond with ONLY a JSON array of finding objects \u2014 no prose, no markdown fences. Each object needs: severity, segment, finding, vital_signs, entity_count, recommended_focus, dollar_value, recommended_plays. Shape:
-${FINDINGS_SCHEMA_BLOCK}`;
   }
 });