@sonnechasser/ntrp 1.4.5 → 1.4.7

package/dist/mcp/server.js

@@ -10327,7 +10327,7 @@ 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.
+Requires an analysis and an AI key (\`/connect\`). Type \`done\` or \`cancel\` to return to \u203A.
 When you are ready to commit to a plan, say so or the partner can hand off to \`/strategy\`.`
       },
       {
@@ -10730,7 +10730,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;
+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, HEILMEIER_GATE, PYRAMID_OUTPUT_BLOCK;
 var init_prompt_parts = __esm({
   "src/ai/prompt-parts.ts"() {
     "use strict";
@@ -10809,12 +10809,23 @@ Instrument trust: every metric here carries confidence and reliability_gate fiel
 - EVERY FIX GETS A MECHANISM. One-time cleanups decay in a quarter. Pair each cleanup with the mechanism that keeps it fixed: a routing rule, an SLA with a report behind it, an enrichment waterfall, a signal-triggered task, an alert in the channel reps already work in.
 - INSTRUMENT WHAT YOU CHANGE. A system you can't measure is a system you can't defend at the next QBR. Name the metric each mechanism should move and where it will be read.
 Restraint: you diagnose and prescribe the system; you do not build it here. Name the mechanism class, not a vendor shopping list.`;
+    HEILMEIER_GATE = `Before you recommend an action, play, or workstream \u2014 run this gate. Failures are silent: kill, demote to an assumption, or ask one sharper question. Never say Heilmeier, DARPA, or catechism to the user.
+- END STATE. Name the precise outcome in one line. Vague goals die here.
+- STATUS QUO. How is it done today, and what is the hard limit of that approach?
+- NEWNESS. What is new in this approach, and why might it work when the status quo fails? If nothing is new, kill it as a restatement.
+- STAKE. Who cares? If it works, what difference does it make \u2014 dollars recovered or a decision unlocked? Name the cost of doing nothing. No stake \u2192 do not recommend.
+- RISKS AND PAYOFFS. State the main downside and the upside in the same breath.
+- EFFORT. Rough cost in team hours or capacity. If it cannot fit the team that exists, cut or re-sequence \u2014 do not soft-pedal.
+- TIME. Bound by sales-cycle and metric-update physics. Dates faster than evidence can appear are invalid.
+- EXAMS. Name a mid-term check and a final exam: dated, measurable, with an instrument that exists. No exams \u2192 demote to assumption or drop.
+- KILL RULE. If newness, stake, or exams fail: do not recommend. Demote, drop, or ask one sharper question. Surviving ideas then get pyramid packaging.`;
     PYRAMID_OUTPUT_BLOCK = `Structure everything the way a client remembers it \u2014 pyramid, answer first:
-- HEADLINE FIRST. Open with the verdict and the number in one sentence (\u226415 words where possible): what is true and what it costs. Never open with methodology or context.
-- THEN THE DRIVERS. Support the headline with 2-3 distinct, non-overlapping drivers, each with its own number. If two points share a cause, merge them.
+- HEADLINE FIRST. Open with the verdict and the number in one sentence (\u226420 words): what is true and what it costs. Never open with methodology or context.
+- THEN THE DRIVERS. Support the headline with 2-3 drivers that are distinct, non-overlapping, and together explain the headline \u2014 each with its own number. If two points share a cause, merge them.
 - 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).`;
+- 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).
+- BRIEF MODE. When brevity is required: one headline + \u22642 drivers + one so-what. Still answer-first; never open with a scorecard.`;
   }
 });
 
@@ -10902,7 +10913,7 @@ 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.`;
+  return `Pyramid-shaped, 2-3 sentences: (1) HEADLINE \u2014 verdict + dollar figure in one short sentence (\u226420 words); (2) DRIVERS \u2014 the one or two distinct, non-overlapping 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);
@@ -11294,8 +11305,11 @@ function buildInvestigationTools() {
   if (isWebRetrievalEnabled()) tools2.push(WEB_SEARCH_TOOL);
   return tools2;
 }
-function buildFreshNlTools() {
-  const tools2 = [...AGENTIC_TOOLS, ...CONVERSATION_TOOLS];
+function buildFreshNlTools(opts = {}) {
+  const conversationTools = opts.analysisReady ? CONVERSATION_TOOLS.filter(
+    (t) => t.name !== "propose_scope" && t.name !== "confirm_scope" && t.name !== "run_compute"
+  ) : CONVERSATION_TOOLS;
+  const tools2 = [...AGENTIC_TOOLS, ...conversationTools];
   if (isWebRetrievalEnabled()) tools2.push(WEB_SEARCH_TOOL);
   return tools2;
 }
@@ -13871,7 +13885,6 @@ __export(phase_exports, {
   buildConversationPrompt: () => buildConversationPrompt,
   consumeOrientEmptyEnterCoach: () => consumeOrientEmptyEnterCoach,
   formatPhaseLabel: () => formatPhaseLabel,
-  getConversationPhaseBlock: () => getConversationPhaseBlock,
   resolveConversationPhase: () => resolveConversationPhase,
   sessionHasData: () => sessionHasData
 });
@@ -13911,6 +13924,8 @@ function formatPhaseLabel(phase) {
   switch (phase) {
     case "orient":
       return "setup";
+    case "awaiting_data":
+      return "data loading";
     case "explore":
       return "ready to ask";
     case "think":
@@ -13919,15 +13934,24 @@ function formatPhaseLabel(phase) {
       return phase.replace(/_/g, " ");
   }
 }
+function accentPromptHead(phase, sessionName) {
+  const scope = sessionName ? ` ${sessionName}` : "";
+  if (phase === "orient" || phase === "awaiting_data" || phase === "explore") {
+    if (phase === "explore" && sessionName) {
+      return paint("accent", `\u203A`) + chalk8.dim(`${scope} `);
+    }
+    return paint("accent", `\u203A `);
+  }
+  if (phase === "compute") {
+    return paint("accent", `\u2026 `);
+  }
+  const word = PROMPT_LABELS[phase].replace(" \u203A", "");
+  return paint("accent", `${word}${scope} \u203A `);
+}
 function buildConversationPrompt(ctx) {
   const phase = resolveConversationPhase(ctx);
-  const label = PROMPT_LABELS[phase];
-  const scope = ctx.sessionName ? ` ${ctx.sessionName}` : "";
+  const sessionName = ctx.sessionName ?? "";
   const action = resolveRecommendedAction(ctx);
-  if (phase === "orient") {
-    const enterHint2 = action ? chalk8.dim(`\u23CE ${action.hint} `) : "";
-    return paint("accent", `${label} `) + enterHint2;
-  }
   if (phase === "explore") {
     const mode = defaultExploreResponseMode(ctx, Math.floor(ctx.messages.length / 2));
     const modeTag = mode === "brief" ? "brief" : "deep";
@@ -13935,34 +13959,15 @@ function buildConversationPrompt(ctx) {
     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 + thinkWait + enterHint2 + " ";
+    return accentPromptHead(phase, sessionName) + 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 + " ";
+    return accentPromptHead(phase, sessionName) + chalk8.dim(stack) + enterHint2 + " ";
   }
   const enterHint = action ? chalk8.dim(`\u23CE ${action.hint} `) : "";
-  return paint("accent", `${label.replace(" \u203A", "")}${scope} \u203A `) + enterHint;
-}
-function getConversationPhaseBlock(ctx) {
-  const phase = resolveConversationPhase(ctx);
-  const lines = [`Conversation phase: ${formatPhaseLabel(phase)}`];
-  if (ctx.scope) {
-    lines.push(`Intent: ${ctx.scope.intent_summary}`);
-    lines.push(`Primary lens: ${ctx.scope.primary_lens}`);
-    if (ctx.scope.audience) lines.push(`Audience: ${ctx.scope.audience}`);
-    if (ctx.scope.time_horizon) lines.push(`Time horizon: ${ctx.scope.time_horizon}`);
-    if (ctx.scope.confirmed_at) lines.push(`Scope confirmed: ${ctx.scope.confirmed_at}`);
-  }
-  if (ctx.dataset?.label) lines.push(`Dataset: ${ctx.dataset.label}`);
-  if (ctx.gapAudit) {
-    lines.push(`Can compute: ${ctx.gapAudit.can_compute}`);
-    if (ctx.gapAudit.missing.length > 0) {
-      lines.push(`Data gaps: ${ctx.gapAudit.missing.map((m) => m.label).join(", ")}`);
-    }
-  }
-  return lines.join("\n");
+  return accentPromptHead(phase, sessionName) + enterHint;
 }
 var PROMPT_LABELS;
 var init_phase = __esm({
@@ -13978,9 +13983,9 @@ var init_phase = __esm({
     PROMPT_LABELS = {
       orient: "\u203A",
       scope: "scope \u203A",
-      awaiting_data: "data \u203A",
+      awaiting_data: "\u203A",
       compute: "\u2026",
-      explore: "ask \u203A",
+      explore: "\u203A",
       think: "think \u203A",
       strategize: "strategy \u203A",
       deliver: "ship \u203A"
@@ -14308,7 +14313,7 @@ function buildMetricsPlaybookBlock() {
   const plays = getMetricsPlays();
   return plays.map((p) => `- "${p.name}" (id: ${p.id}) \u2014 when ${p.trigger_condition}: ${p.why}`).join("\n");
 }
-function buildSystemPrompt() {
+function buildMetricsFindingsSystemPrompt() {
   const profile = loadProfile();
   const profileBlock = buildCompanyProfileBlock();
   const motionLabel = motionBenchmarkLabel(profile?.sales_motion);
@@ -14387,7 +14392,7 @@ async function generateMetricsFindings(input, ctx) {
   const { response, meta } = await completeWithFailover(
     {
       surface: "metrics_findings",
-      system: buildSystemPrompt(),
+      system: buildMetricsFindingsSystemPrompt(),
       messages: [{ role: "user", content: userMessage }],
       max_tokens: 4096
     },
@@ -16053,15 +16058,15 @@ var init_metric_definitions = __esm({
         kind: "vital",
         label: "Freshness",
         group: "Vital Signs",
-        tagline: "Does the CRM report which records are still active?",
+        tagline: "Is the CRM still talking about live work \u2014 or a museum of old deals?",
         how_computed: "NTRP computes a weighted average of people, organizations, and opportunities with recent activity. Open opportunities must also not be past-due. Default windows: people and organizations 90 days, opportunities 30 days. Weights are 35 / 30 / 35.",
         formula_lines: [
           "freshness = people%\xD70.35 + orgs%\xD70.30 + opps%\xD70.35",
           "people/orgs fresh if activity within 90d",
           "opps fresh if activity within 30d AND not past-due"
         ],
-        meaning: "Board question: how much of this pipeline is real versus fiction? Dollar value equals the sum of amount on stale opportunities: pipeline at risk.",
-        expert_read: "Cut by owner and by stage first. Freshness reds concentrate on people or process. They rarely spread evenly. In a long-cycle enterprise motion, 30 quiet days can be normal cadence. In a velocity motion, 30 quiet days is a dead deal. A sudden cliff usually means a broken integration or a departed rep. It is not gradual decay. Check this false positive: bulk-imported records that nobody has touched yet.",
+        meaning: 'We treat Freshness as a truth check on the pipeline number. Quiet days mean different things by motion: in enterprise, 30 quiet days can be normal cadence; in a velocity book, that same silence often means the deal is already dead. Stale open amount is why we show "pipeline at risk."',
+        expert_read: `A useful first cut is by owner and by stage \u2014 reds tend to clump on people or process, not sprinkle evenly. A sudden cliff is usually a broken integration or a departed rep, not gradual decay. Watch for the false positive too: bulk-imported records nobody has touched yet can look "stale" when they're just new.`,
         deepdive: [
           "Status bands: green 80 or more, yellow 60 or more, red below 60. Motion presets can change the windows.",
           'Dollar translation: sum of amount on stale open opportunities \u2192 "pipeline at risk".',
@@ -16091,15 +16096,15 @@ var init_metric_definitions = __esm({
         kind: "vital",
         label: "Flow Rate",
         group: "Vital Signs",
-        tagline: "How fast do deals move, and where do they stop?",
+        tagline: "Where does deal motion slow \u2014 and what's stuck behind that bottleneck?",
         how_computed: "NTRP sets a base score from average open-deal age versus max_days. It then applies a penalty of up to 20 for the share of stuck deals. A deal is stuck when it has no update beyond stuck_days, or a past-due close. Status uses average open age, not the score alone.",
         formula_lines: [
           "base = 100 \xD7 (1 \u2212 avgOpenAge / max_days)",
           "score = base \u2212 stuckSharePenalty (\u226420)",
           "stuck = no update > stuck_days OR past-due close"
         ],
-        meaning: "Board question: is next quarter slipping because deals are stuck? Dollar value equals the amount stuck in pipeline.",
-        expert_read: "Cut by stage age, not only deal age. Find the stage where deals stop. That is usually one stage. Compare stuck-deal age to this company's own median cycle. Do not use a generic norm. Stuck deals plus past-due close dates signal optimistic forecasting. That is a credibility problem before it is a revenue problem.",
+        meaning: 'We think of Flow Rate as velocity risk with a dollar tag. When deals stop advancing \u2014 and especially when close dates slip past due \u2014 next quarter starts to feel optimistic on paper. The dollar line is the amount still "stuck in pipeline."',
+        expert_read: "We prefer stage age over deal age alone: find the stage where advancement collapses \u2014 it's usually one stage, not everywhere. Compare stuck age to this company's own median cycle rather than a generic norm. Stuck deals plus past-due closes are often a forecast-credibility problem before they're a revenue miss.",
         deepdive: [
           "Status uses average open age. Green is 45 days or less. Yellow is 90 days or less. Else red. Defaults: max_days 120, stuck_days 60.",
           'Dollar translation: sum of amount on stuck deals \u2192 "stuck in pipeline".',
@@ -16131,15 +16136,15 @@ var init_metric_definitions = __esm({
         kind: "vital",
         label: "Drop Rate",
         group: "Vital Signs",
-        tagline: "Where do leads drop between systems?",
+        tagline: "Where does paid demand fall between systems before anyone works it?",
         how_computed: "NTRP blends cross-system retention and opportunity retention. Cross-system retention is marketing people also present in sales. Opportunity retention is open opportunities that are not abandoned. Default weights: cross-system 60 percent, opportunity retention 40 percent. Abandoned means open opportunities with no activity in 30 days.",
         formula_lines: [
           "score = crossSystemRetention\xD70.6 + oppRetention\xD70.4",
           "cross-system = marketing people also in sales CRM",
           "abandoned = open opps with no activity in 30d"
         ],
-        meaning: "Board question: how much pipeline did we pay for and never work? Dollar value = droppedCount \xD7 conversionRate \xD7 avgDealSize \u2014 est. lost at handoff.",
-        expert_read: "This is almost always a systems failure. Causes include routing rules, unassigned territories, dead rep queues, or a sync gap between marketing and CRM. It is not lazy reps. First cut by lead source. The leak usually concentrates in one or two sources. The cheapest pipeline this business can buy is the leads it already paid for.",
+        meaning: 'We read Drop Rate as the price of the handoff leak \u2014 budget already spent on leads that never reach a working rep. The dollar estimate is droppedCount \xD7 conversion \xD7 avg deal size: "est. lost at handoff."',
+        expert_read: 'In practice this usually looks like a systems story: routing rules, unassigned territories, dead rep queues, or a sync gap between marketing and CRM \u2014 more often than "lazy reps." A useful first cut is by lead source; the leak tends to concentrate in one or two sources. The cheapest pipeline a business can buy is often the leads it already paid for.',
         deepdive: [
           "Status bands: green 80 or more, yellow 60 or more, red below 60.",
           'Dollar translation: dropped \xD7 conversion \xD7 avg deal (fallback: drop% \xD7 open pipeline) \u2192 "est. lost at handoff".',
@@ -16170,15 +16175,15 @@ var init_metric_definitions = __esm({
         kind: "vital",
         label: "Signal:Noise",
         group: "Vital Signs",
-        tagline: "How much activity is aimed at deals that can still close?",
+        tagline: "How much of the team's effort still aims at deals that can close?",
         how_computed: "Over a 90-day lookback, NTRP computes (signal activities / all activities) \xD7 100. Signal is activity linked to an open opportunity, a pipeline person, or a pipeline organization.",
         formula_lines: [
           "score = (signalCount / activityCount) \xD7 100",
           "signal = linked to open opp / pipeline person / pipeline org",
           "lookback = trailing 90 days"
         ],
-        meaning: "Board question: are we burning capacity on dead accounts? Dollar value = noiseCount \xD7 hours_per_activity \xD7 rep_hourly_cost \u2014 misdirected effort.",
-        expert_read: "Cut by rep and by account status. Noise usually means reps work dead accounts they already know. Targeting and account lists are stale. Persistent noise is a coverage-model problem, not a coaching problem. Check whether activity is logged against closed or unlinked records. That is often a hygiene artifact.",
+        meaning: `We treat Signal:Noise as activity efficiency with a capacity price. Noise hours \xD7 hours_per_activity \xD7 rep_hourly_cost becomes "misdirected effort" \u2014 energy aimed at accounts that can't still close.`,
+        expert_read: "A useful cut is by rep and by account status. Persistent noise often means reps keep working dead accounts they already know \u2014 stale targeting or coverage models more than a coaching gap. Also check whether activity is logged against closed or unlinked records; that can be a hygiene artifact pretending to be effort.",
         deepdive: [
           "Status bands: green 65 or more, yellow 40 or more, red below 40.",
           "Dollar defaults: 0.25 hours/activity \xD7 $75/hr (config: hours_per_activity, rep_hourly_cost).",
@@ -16207,15 +16212,15 @@ var init_metric_definitions = __esm({
         kind: "vital",
         label: "Thread Depth",
         group: "Vital Signs",
-        tagline: "How fragile is the pipeline if one champion stops?",
+        tagline: "How fragile is revenue if one champion changes jobs?",
         how_computed: "Percent of open deals with at least multi_thread_threshold distinct people active in the last 90 days. The default threshold is 2. People include opportunity-direct contacts and same-organization activity.",
         formula_lines: [
           "score = % open deals with \u22652 active people (90d)",
           "people counted via opp contacts + same-org activity",
           "threshold configurable (default 2)"
         ],
-        meaning: "Board question: how much revenue is lost if one contact changes jobs? Dollar value equals the sum of amount on single-threaded deals.",
-        expert_read: "Weight by deal size. One single-threaded mega-deal outweighs ten small ones. Single-threading late in the cycle is far more dangerous than early. In enterprise motions, Thread Depth is a leading indicator of slipped quarters. Champions change jobs. There is no second contact.",
+        meaning: "We read Thread Depth as resilience risk. One single-threaded mega-deal can outweigh ten small ones \u2014 and late-cycle single-threading is especially scary because champions change jobs. The dollar line sums amount on single-threaded deals.",
+        expert_read: "Weight by deal size when you triage. Single-threading late in the cycle tends to matter more than early. In enterprise motions, thin threads are often a leading indicator of slipped quarters: the champion leaves and there's no second contact warm enough to carry the deal.",
         deepdive: [
           "Status bands: green 65 or more, yellow 40 or more, red below 40.",
           'Dollar translation: sum of amount on single-threaded deals \u2192 "single-threaded".',
@@ -16247,14 +16252,14 @@ var init_metric_definitions = __esm({
         kind: "saas",
         label: "ARR",
         group: "Revenue",
-        tagline: "How big is the revenue engine, and from where?",
+        tagline: "How big is the engine \u2014 and what's the mix that got it there?",
         how_computed: "Sum of amount on closed-won opportunities in the dataset. This is pipeline-inferred ARR when a pure subscription ledger is not available.",
         formula_lines: [
           "ARR \u2248 \u03A3 amount on closed-won opportunities",
           "New + Expansion = growth \xB7 Churned + Contraction = leakage"
         ],
-        meaning: "Board question: how fast are we growing, and from where? Always decompose growth into new versus expansion. The mix is the story.",
-        expert_read: "Always decompose growth into new versus expansion. The mix is the story. Prefer this company's own trailing history over any external prior. A number below its reliability_gate is a hypothesis, not a fact.",
+        meaning: "We treat ARR as the size of the revenue engine \u2014 but the interesting story is the mix. New versus expansion growth, and how much leakage (churn + contraction) ate into it. From CRM exports we often infer this from closed-won amounts when a pure subscription ledger isn't available.",
+        expert_read: "Always decompose growth into new versus expansion before you brief anyone \u2014 the mix is the story. Prefer this company's own trailing history over an external prior. When a number sits below its reliability_gate, we treat it as a hypothesis, not a fact.",
         deepdive: [
           "Companion metrics: New ARR, Expansion ARR, Churned ARR, Contraction ARR.",
           "Estimation method may be ledger, pipeline_inferred, or snapshot. Read confidence and reliability_gate.",
@@ -16407,15 +16412,15 @@ var init_metric_definitions = __esm({
         kind: "saas",
         label: "Net Revenue Retention",
         group: "Retention",
-        tagline: "Would this business grow if sales stopped selling?",
+        tagline: "Would the base still grow if new logo sales paused?",
         how_computed: "startingArr = ARR + Churned + Contraction \u2212 Expansion. NRR = ((starting \u2212 Churned \u2212 Contraction + Expansion) / starting) \xD7 100.",
         formula_lines: [
           "starting = ARR + churned + contraction \u2212 expansion",
           "NRR = (starting \u2212 churned \u2212 contraction + expansion) / starting \xD7 100",
           "NRR = 100% + expansion% \u2212 contraction% \u2212 churn%"
         ],
-        meaning: "Board question: would this business grow if sales stopped selling? A value above 100% means growth from existing customers.",
-        expert_read: "Decompose before you judge. The same 95% can be a churn problem (product/PMF) or a no-expansion problem (packaging/motion). Those have different owners. Priors by segment: about 97% SMB, about 108% mid-market, about 118% enterprise medians. 110% or more is a strong signal at any stage.",
+        meaning: "We love NRR because it answers a sharp question: would this business still grow if sales stopped selling new logos? Above 100% means the installed base compounds. From CRM we reconstruct the walk (+expansion \u2212contraction \u2212churn) and stay humble when the data is pipeline-inferred.",
+        expert_read: "Decompose before you judge \u2014 the same 95% can be a churn/PMF problem or a no-expansion/packaging problem, and those have different owners. Rough priors by segment sit around 97% SMB, 108% mid-market, 118% enterprise medians; 110%+ is a strong signal at any stage.",
         deepdive: [
           "Always show the waterfall: +expansion \u2212contraction \u2212churn.",
           "GRR is the floor. NRR adds expansion on top.",
@@ -16443,14 +16448,14 @@ var init_metric_definitions = __esm({
         kind: "saas",
         label: "Gross Revenue Retention",
         group: "Retention",
-        tagline: "How leaky is the bucket before expansion hides it?",
+        tagline: "How leaky is the bucket before expansion can hide it?",
         how_computed: "GRR = ((startingArr \u2212 Churned \u2212 Contraction) / startingArr) \xD7 100. Expansion is excluded on purpose.",
         formula_lines: [
           "starting = ARR + churned + contraction \u2212 expansion",
           "GRR = (starting \u2212 churned \u2212 contraction) / starting \xD7 100"
         ],
-        meaning: "Board question: how leaky is the bucket before expansion hides it? Prior: above 90% is healthy. Above 95% is strong for enterprise.",
-        expert_read: "GRR is the honesty metric. Expansion can make NRR look fine while GRR erodes. Always read both.",
+        meaning: "We treat GRR as the honesty metric \u2014 churn plus contraction only, with expansion deliberately left out. That way a shiny NRR can't paper over a leaky bucket. Rough priors: above 90% feels healthy; above 95% is strong for enterprise.",
+        expert_read: "Always read GRR next to NRR. Expansion can make net retention look fine while the floor erodes. Owners tend to split: product/CS for logo churn, packaging for contraction.",
         deepdive: [
           "GRR never includes Expansion. That is the point.",
           "Owners: product and CS for churn. Packaging for contraction."
@@ -16473,14 +16478,14 @@ var init_metric_definitions = __esm({
         kind: "saas",
         label: "Pipeline Coverage",
         group: "Pipeline",
-        tagline: "Is next quarter already at risk?",
+        tagline: "Does next quarter already have enough real pipeline?",
         how_computed: "Open pipeline amount divided by trailing-90-day closed-won amount.",
         formula_lines: [
           "Coverage = openPipeline / trailing_90d_won",
           "required \u2248 1 / win_rate (discount for time left)"
         ],
-        meaning: "Board question: is next quarter already at risk? Priors scale with cycle length: about 3x for velocity/SMB, 4 to 5x for enterprise.",
-        expert_read: "Coverage has no meaning without win rate. Required coverage is about 1 / win rate, discounted for time left in the period. Inflated stages and zombie deals fake coverage. Cross-check with Freshness before you trust it.",
+        meaning: `We read coverage as an early "is next quarter already thin?" check. Priors scale with cycle length \u2014 roughly 3x for velocity/SMB, 4\u20135x for enterprise \u2014 but coverage without win rate is half a story. We also cross-check Freshness so zombies don't fake a healthy multiple.`,
+        expert_read: "Required coverage is roughly 1 / win rate, discounted for time left in the period. Inflated stages and stale deals can manufacture coverage that isn't there. Pair with Win Rate and Freshness before you trust the brief.",
         deepdive: [
           "Always pair with Win Rate and Freshness.",
           "Weighted Pipeline is the credibility-adjusted companion."
@@ -16565,14 +16570,14 @@ var init_metric_definitions = __esm({
         kind: "saas",
         label: "Pipeline Velocity",
         group: "Pipeline",
-        tagline: "Revenue throughput per day. Four levers, one number.",
+        tagline: "Four levers, one throughput number \u2014 which lever moved?",
         how_computed: "(openOpps \xD7 avgDeal \xD7 winRate) / avgCycleDays. Requires 3 or more dated closed-won deals. Unit: $/day.",
         formula_lines: [
           "Velocity = (openOpps \xD7 avgDeal \xD7 winRate) / avgCycleDays",
           "four levers: #opps \xB7 deal size \xB7 win rate \xB7 cycle days"
         ],
-        meaning: "Board question: which lever moved when throughput changed? This is the most decision-ready pipeline metric.",
-        expert_read: "When velocity changes, name which lever moved. A win-rate rise on falling opportunity volume is qualification tightening, not improvement.",
+        meaning: "We like velocity because it's decision-ready: revenue throughput per day with four named levers (volume, size, win rate, cycle). When throughput changes, the interesting question is which lever moved \u2014 not just whether the number went up.",
+        expert_read: 'Name the lever. A win-rate rise on falling opportunity volume often means qualification tightened, not that selling got "better." Needs a handful of dated wins; otherwise we leave it unavailable rather than invent a story.',
         deepdive: [
           "Needs 3 or more dated wins. Otherwise this metric is unavailable.",
           "Pairs with Flow Rate (cycle) and Win Rate (conversion)."
@@ -16594,11 +16599,11 @@ var init_metric_definitions = __esm({
         kind: "saas",
         label: "Win Rate",
         group: "Sales Efficiency",
-        tagline: "Of decided deals, how often do we win?",
+        tagline: "Of the deals we decide, how often do we win?",
         how_computed: "closed-won / (won + lost) \xD7 100.",
         formula_lines: ["Win Rate = won / (won + lost) \xD7 100"],
-        meaning: "Board question: are we converting the pipeline we create? Priors: 25\u201335% SMB, 18\u201325% mid-market, 12\u201318% enterprise on qualified opportunities.",
-        expert_read: "A rising win rate on falling opportunity volume is qualification tightening, not improvement. Check the denominator.",
+        meaning: "We read win rate as conversion of decided deals \u2014 are we winning the pipeline we create? Rough priors: ~25\u201335% SMB, ~18\u201325% mid-market, ~12\u201318% enterprise on qualified opportunities. It also sets how much coverage you need (~1 / win rate).",
+        expert_read: "Watch the denominator. A rising win rate on falling opportunity volume often means qualification tightened, not that the team suddenly sells better. Cut by segment or source before company-wide coaching.",
         deepdive: [
           "Required coverage is about 1 / win rate.",
           "Cut by segment or source before company-wide coaching."
@@ -17007,10 +17012,10 @@ function wrapForTarget(target, analysisBlock, conversationBlock, openQuestions,
   const contextLabel = handoffInstructionPrefix(ctx.analysis.primary);
   const forWhom = audiencePhrase(ctx.scope?.audience);
   const instructions = {
-    deck: `produce an executive review deck outline for ${company}, framed for ${forWhom}. Structure: (1) Headline number; (2) Pipeline health; (3) Top 3 risks with dollar impact; (4) Recommended plays; (5) Asks / decisions. Use the Metric definitions appendix so every slide can briefly remind the room what the number means for this audience.`,
+    deck: `produce an executive review deck outline for ${company}, framed for ${forWhom}. Pyramid structure: (1) HEADLINE \u2014 the governing number and verdict in one line; (2) DRIVERS \u2014 2\u20133 distinct, non-overlapping risks or causes with dollar impact (not a full scorecard); (3) SO-WHAT \u2014 recommended plays; (4) ASKS / decisions the room must make. Optionally one pipeline-health slide after the headline if it supports the call. Use the Metric definitions appendix so every slide can briefly remind the room what the number means for this audience.`,
     asana: `produce an Asana project plan with sections and tasks tied to findings for ${forWhom}. Prioritize by dollar impact. Reference metric definitions when a task owner needs to know what "good" looks like.`,
     clay: `produce a Clay table specification to operationalize the highest-impact finding for ${forWhom}.`,
-    plan: `produce a prioritized action plan for ${forWhom} with problem, play, first 3 steps, owner, and leading indicator per item. Ground indicators in the Metric definitions appendix.`
+    plan: `produce a prioritized action plan for ${forWhom}, answer-first: open with the governing call (highest-dollar problem), then items each with problem, play, first 3 steps, owner, and leading indicator. Ground indicators in the Metric definitions appendix. End with the sharpest asks / decisions.`
   };
   const parts = [
     `# NTRP handoff \u2192 ${target}`,
@@ -17405,10 +17410,13 @@ ${companyContextSection2()}${operatorSection2()}HOW YOU THINK (the strategist me
 8. RESPECT CAPACITY. Total effort must fit the team that actually exists. A brilliant plan the team cannot staff is a bad plan.
 
 ALTITUDE CONTRACT (the plan must work at every altitude a client reads it at):
-- 30,000 FT: summary_30k is a situation-complication-resolution narrative \u2014 where the business stands, what gates what, and what leadership should expect by when. A board member reads only this; it must survive being forwarded unedited.
+- 30,000 FT: summary_30k is answer-first \u2014 open with the governing thought and what leadership should expect by when, then the situation and complication that make it true. A board member reads only this; it must survive being forwarded unedited.
 - 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.
 
+OUTPUT DOCTRINE (narrative fields \u2014 summary_30k and workstream problem lines \u2014 follow pyramid recall):
+${PYRAMID_OUTPUT_BLOCK}
+
 ${buildUserVisibleProseBlock()}
 
 GTM ENGINEERING (plans install systems, not heroics):
@@ -17491,6 +17499,8 @@ function buildStressTestMessage() {
 6. EXPECTATION HONESTY: are target ranges defensible from the baseline and effort, or heroic? Widen ranges or lower confidence rather than promising what the data does not support. Where the local play track record shows a play has hit or missed here before, weight confidence accordingly.
 7. CONTINGENCY QUALITY: is each trigger observable on a specific date, and is each fallback a real pre-decision (alternate play, descope, escalate) rather than "monitor closely"?
 8. ALTITUDE CHECK: does summary_30k survive being forwarded to a board member unedited? Is each workstream title + problem a self-contained delegation one-liner? Is every first action startable within 48 hours?
+9. HEILMEIER GATE (silent \u2014 never name this to the user). Run every workstream through this filter. Failures: cut the workstream, demote it to assumptions, or rewrite until it passes \u2014 then emit final JSON.
+${HEILMEIER_GATE}
 
 Then respond with the FINAL revised plan as strict JSON in the same schema \u2014 no markdown fences, no prose. Fold what you learned into constraints, assumptions, risks, and confidence. This version is the one that gets saved and reviewed against, so make every number one you are willing to be checked on.`;
 }
@@ -18813,6 +18823,170 @@ var init_strategist_flow = __esm({
   }
 });
 
+// src/conversation/ghost-hints.ts
+function ghostExamplesForPhase(phase, limit = 2) {
+  const hints = PHASE_GHOST_HINTS[phase] ?? [];
+  return hints.slice(0, limit).map((h) => h.replace(/^try\s+/i, ""));
+}
+var PHASE_GHOST_HINTS;
+var init_ghost_hints = __esm({
+  "src/conversation/ghost-hints.ts"() {
+    "use strict";
+    PHASE_GHOST_HINTS = {
+      orient: [
+        'try "pipeline health"',
+        "try /deepdive",
+        "try /deepdive guide",
+        'try "is our retention real for the board?"',
+        'try "what is the most expensive problem to solve?"',
+        'try "board deck on Q3"'
+      ],
+      awaiting_data: [
+        'try "use demo data"',
+        "try a CSV path",
+        "try /ingest",
+        'try "go ahead"'
+      ],
+      explore: [
+        'try "what is the most expensive problem?"',
+        'try "how should we fix this?"',
+        'try "which segment is weakest?"',
+        'try "what is ARR?"',
+        "try /deepdive freshness",
+        'try "ship a board deck"'
+      ]
+    };
+  }
+});
+
+// src/conversation/situation.ts
+function buildSituationalAwarenessBlock(ctx, opts = {}) {
+  const phase = resolveConversationPhase(ctx);
+  const channel = opts.channel ?? (phase === "think" ? "think" : "explore");
+  const responseMode = opts.responseMode ?? (channel === "think" ? "deep" : defaultExploreResponseMode(ctx, Math.floor(ctx.messages.length / 2)));
+  const analysisReady = isAnalysisReady(ctx);
+  const action = resolveRecommendedAction(ctx);
+  const examples = ghostExamplesForPhase(
+    phase === "think" || phase === "strategize" || phase === "deliver" ? "explore" : phase,
+    2
+  );
+  const lines = [
+    "WHERE YOU ARE IN NTRP:",
+    FUNNEL_SPINE,
+    `Phase: ${phase} (${formatPhaseLabel(phase)}) \u2014 ${PHASE_MEANING[phase]}`
+  ];
+  if (channel === "think") {
+    lines.push("Channel: think \u2014 socratic partner; type done/cancel returns to \u203A");
+    lines.push("Response mode: deep (tools on)");
+  } else if (channel === "strategist") {
+    lines.push("Channel: strategist \u2014 measurable plan engine owns sequencing");
+  } else {
+    lines.push(
+      responseMode === "brief" ? "Response mode: brief (tools off; cite COMPLETED SESSION ANALYSIS; ~40\u201390 words)" : "Response mode: deep (tools on; new cuts and drill-downs)"
+    );
+  }
+  if (ctx.scope) {
+    const bits = [`Scope: ${ctx.scope.intent_summary}`, `lens=${ctx.scope.primary_lens}`];
+    if (ctx.scope.audience) bits.push(`audience=${ctx.scope.audience}`);
+    if (ctx.scope.time_horizon) bits.push(`horizon=${ctx.scope.time_horizon}`);
+    lines.push(bits.join(" \xB7 "));
+    if (ctx.scope.confirmed_at) lines.push(`Scope confirmed: ${ctx.scope.confirmed_at}`);
+  }
+  if (ctx.dataset?.label) {
+    lines.push(`Dataset: ${ctx.dataset.label} \xB7 stage=${ctx.stage}`);
+  } else if (sessionHasData(ctx)) {
+    lines.push(`Dataset: loaded \xB7 stage=${ctx.stage}`);
+  } else {
+    lines.push(`Dataset: empty \xB7 stage=${ctx.stage}`);
+  }
+  if (ctx.gapAudit) {
+    lines.push(`Can compute: ${ctx.gapAudit.can_compute}`);
+    if (ctx.gapAudit.missing.length > 0) {
+      lines.push(`Data gaps: ${ctx.gapAudit.missing.map((m) => m.label).join(", ")}`);
+    }
+  }
+  if (analysisReady) {
+    lines.push(
+      "Already done: scope confirmed; compute ran; do not re-propose scope or re-run compute unless the user asks to restart"
+    );
+    lines.push(
+      "Available now: answer from the artifact; suggest at most one of /strategy, /handoff, /deepdive <metric>, /thinkwithme, /playbook"
+    );
+    if (channel === "explore" && responseMode === "deep") {
+      lines.push(
+        "Tools: diagnostics + draft_strategy + draft_handoff (+ audit_data_gaps for re-check). Scope/compute orchestration is off."
+      );
+    }
+  } else if (phase === "awaiting_data") {
+    lines.push("Already done: scope confirmed; analysis not ready");
+    lines.push(
+      'Available now: tell the user to paste a CSV path, type "use demo data", or \u23CE go ahead when can_compute \u2014 you cannot open files'
+    );
+  } else if (phase === "scope") {
+    lines.push("Already done: intent proposed; waiting on confirm");
+    lines.push("Available now: wait for CLI confirm (\u23CE yes) \u2014 do not invent a different question");
+  } else if (phase === "orient") {
+    lines.push("Already done: nothing locked yet");
+    lines.push("Available now: help the user name a focus; CLI will propose scope from their words");
+  } else if (phase === "think") {
+    lines.push("Already done: analysis complete; think channel open");
+    lines.push("Available now: socratic exploration; draft_strategy / draft_handoff when ready to graduate");
+  }
+  lines.push(
+    `Armed user next step: ${action ? `${action.hint} (\u23CE submits "${action.submit}")` : "none"}`
+  );
+  lines.push(`Engine connected: ${canUseReplAi(ctx) ? "yes" : "no"}`);
+  if (examples.length > 0) {
+    lines.push(`User may try: ${examples.join(" \xB7 ")}`);
+  }
+  lines.push(
+    "Your job in this harness: fill the judgment gap after formula compute \u2014 connect dollars, name the expensive problem, do not restate scorecards the user already saw"
+  );
+  lines.push(
+    "Pre-explore funnel gates are handled by the CLI; you speak in explore/think/strategist unless tools explicitly allow a restart"
+  );
+  return lines.join("\n");
+}
+function buildSituationalRuntimeFacts(ctx, opts = {}) {
+  const phase = resolveConversationPhase(ctx);
+  const channel = opts.channel ?? (phase === "think" ? "think" : "explore");
+  const responseMode = opts.responseMode ?? (channel === "think" ? "deep" : defaultExploreResponseMode(ctx, Math.floor(ctx.messages.length / 2)));
+  return {
+    phase,
+    mode: responseMode,
+    lens: ctx.scope?.primary_lens,
+    stage: ctx.stage,
+    can_compute: ctx.gapAudit?.can_compute === void 0 ? void 0 : String(ctx.gapAudit.can_compute),
+    engine: canUseReplAi(ctx) ? "connected" : "none"
+  };
+}
+function getConversationPhaseBlock(ctx, opts = {}) {
+  return buildSituationalAwarenessBlock(ctx, opts);
+}
+var FUNNEL_SPINE, PHASE_MEANING;
+var init_situation = __esm({
+  "src/conversation/situation.ts"() {
+    "use strict";
+    init_context2();
+    init_explore_mode();
+    init_repl_api();
+    init_ghost_hints();
+    init_recommended_action();
+    init_phase();
+    FUNNEL_SPINE = "Funnel: orient \u2192 scope \u2192 data \u2192 compute \u2192 explore | side doors: think, strategy, ship";
+    PHASE_MEANING = {
+      orient: "setup \u2014 open chat; user has not locked a scope yet",
+      scope: "scope confirm \u2014 CLI owns yes/adjust; do not re-propose unless asked",
+      awaiting_data: "data gate \u2014 load CSV/demo or compute; CLI owns the gate",
+      compute: "compute in progress \u2014 wait",
+      explore: "analysis complete \u2014 free-form Q&A on this session's artifact",
+      think: "socratic think channel \u2014 return to \u203A via done/cancel",
+      strategize: "strategist flow \u2014 objective confirm or plan drafting",
+      deliver: "ship/handoff wizard \u2014 CLI owns write confirms"
+    };
+  }
+});
+
 // src/services/think.ts
 var think_exports = {};
 __export(think_exports, {
@@ -18852,7 +19026,7 @@ async function runThinkTurn(input, ctx) {
   setAgentContext(ctx);
   try {
     const analysisBlock = buildAnalysisBlock(ctx);
-    const conversationBlock = getConversationPhaseBlock(ctx);
+    const conversationBlock = getConversationPhaseBlock(ctx, { channel: "think", responseMode: "deep" });
     const bundle = await loadSessionAnalysisBundle();
     const sessionArtifact = hasAnyAnalysis(bundle) ? buildExploreContextBlock(bundle, ctx) : "";
     for await (const event of agenticFindings(snapshot, ctx.snapshot.divergences, {
@@ -18939,7 +19113,7 @@ var init_think = __esm({
     "use strict";
     init_spinner();
     init_context2();
-    init_phase();
+    init_situation();
     init_agent_context();
     init_agentic_loop();
     init_thread();
@@ -19003,7 +19177,7 @@ function printChannelIntro(seed) {
   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.")
+    ) + chalk19.cyan("done") + chalk19.dim(" or ") + chalk19.cyan("cancel") + chalk19.dim(" to return to \u203A.")
   );
   if (seed) {
     console.log("  " + chalk19.dim("Seed: ") + seed);
@@ -19089,7 +19263,7 @@ function clearThinkFlow(ctx, reason) {
   console.log();
   console.log(
     "  " + chalk19.dim(
-      reason === "done" ? "Think channel closed. Back to ask \u203A." : "Think session cancelled. Continue exploration."
+      reason === "done" ? "Think channel closed. Back to \u203A." : "Think session cancelled. Continue exploration."
     )
   );
   console.log();
@@ -20171,10 +20345,10 @@ async function runNaturalLanguage(input, ctx) {
   setAgentContext(ctx);
   try {
     const analysisBlock = buildAnalysisBlock(ctx);
-    const conversationBlock = getConversationPhaseBlock(ctx);
+    const responseMode = resolveExploreResponseMode(input, ctx, ctx.conversation.length);
+    const conversationBlock = getConversationPhaseBlock(ctx, { responseMode });
     const bundle = await loadSessionAnalysisBundle();
     const sessionArtifact = hasAnyAnalysis(bundle) ? buildExploreContextBlock(bundle, ctx) : "";
-    const responseMode = resolveExploreResponseMode(input, ctx, ctx.conversation.length);
     for await (const event of agenticFindings(snapshot, ctx.snapshot.divergences, {
       mode: "fresh",
       userQuestion: input,
@@ -20272,6 +20446,7 @@ var init_nl = __esm({
     "use strict";
     init_spinner();
     init_context2();
+    init_situation();
     init_phase();
     init_agent_context();
     init_orchestrator();
@@ -25499,13 +25674,14 @@ Cite numbers from here; call tools when you need a new cut or to pressure-test a
 
 ` : "";
   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):
+- Pre-explore funnel gates are handled by the CLI; you speak in the think channel after analysis.
 - You are a thinking partner. Prefer sharp questions that unlock the user's idea over dumping answers.
+- Probing turns: lead with the sharpest question that unlocks the next insight. Concluding turns: use pyramid (headline \u2192 drivers \u2192 so-what) \u2014 answer first, then structure.
 - 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:").
@@ -25516,7 +25692,7 @@ ${opts.conversationBlock}
 - 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.
+- Probing: lead with the question that matters most. Concluding: lead with the answer (headline), then drivers and so-what.
 - 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.`;
@@ -25538,7 +25714,7 @@ ${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.`;
+- Type \`done\` or \`cancel\` leaves the think channel back to \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}
@@ -25554,6 +25730,9 @@ ${EXECUTION_BIAS_BLOCK}
 GTM ENGINEERING (how recommendations become systems):
 ${GTM_ENGINEERING_BLOCK}
 
+IDEA GATE (when recommending a play or before draft_strategy \u2014 silent; probing/imagination turns skip this until you conclude):
+${HEILMEIER_GATE}
+
 OUTPUT DOCTRINE (how answers are structured for recall):
 ${PYRAMID_OUTPUT_BLOCK}
 
@@ -25588,7 +25767,7 @@ ${SAFETY_BLOCK}`;
   const dynamic = [
     "SESSION STATE (current \u2014 changes as the session progresses):",
     ...dynamicSections,
-    buildRuntimeBlock()
+    buildRuntimeBlock(opts.runtimeFacts ?? {})
   ].join("\n\n");
   return { stable, dynamic };
 }
@@ -25620,7 +25799,7 @@ function operatorSection4() {
 
 `;
 }
-function buildSystemPrompt2() {
+function buildSystemPrompt() {
   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.
 
 ${companyContextSection4()}${operatorSection4()}INVESTIGATION APPROACH:
@@ -25705,12 +25884,11 @@ The user already received the full report in the terminal. Answer follow-ups by
 
 ` : "";
   const conversationSection = conversationBlock ? `
-CONVERSATION STATE:
 ${conversationBlock}
-Do not run compute until audit_data_gaps reports can_compute. If the user needs to load data, tell them to paste a CSV path or type "use demo data". You cannot open files.
 
 ` : "";
   const conversationRules = `HOW A GREAT ANALYST CARRIES A CONVERSATION (read carefully \u2014 this is what separates you from a search box):
+- Pre-explore funnel gates (orient \u2192 scope \u2192 data \u2192 compute) are handled by the CLI. You speak after compute unless tools explicitly allow a restart.
 - You have continuity. The conversation so far is provided to you as prior messages. Read it before answering. You remember every angle you have already explored, every number you have already surfaced, and every recommendation you have already made.
 - Never repeat or re-recommend an analysis you have already presented in this conversation unless the user explicitly asks you to revisit, recall, or connect it. Repetition reads as forgetfulness and destroys trust.
 - Each answer should ADVANCE the discussion: go deeper, introduce a genuinely new angle, challenge an assumption, or synthesize across what you have already found. Move the thinking forward.
@@ -25719,6 +25897,9 @@ Do not run compute until audit_data_gaps reports can_compute. If the user needs
 - If you genuinely have nothing new to add on a topic, say so briefly and offer a different, higher-value direction \u2014 never pad with a recycled recommendation.`;
   const briefJob = `YOUR JOB (BRIEF MODE \u2014 default after analysis is complete):
 - Stay concise \u2014 roughly 40\u201390 words total, not a mini-report. Verdict first: your opening sentence is the headline the user should be able to repeat an hour later.
+- Lead with the single most expensive or most actionable implication from the completed session analysis \u2014 not a scorecard restatement.
+- Do not re-list all five vital signs unless the user asked for that inventory.
+- Prefer naming one playbook play or one next cut over a generic "want me to dig deeper?" close.
 - You are at 30,000 ft by default. If they ask for detail or a new data cut, that routes to deep mode automatically \u2014 don't cram the weeds in here.
 - Do NOT call tools unless the user explicitly asks for a new data cut (by rep, stage, list of deals, etc.). The completed analysis above is your source of truth.
 - Name a playbook play only when the user asks what to do or which action to take.
@@ -25788,12 +25969,18 @@ ${commandStyleRule}`;
 - Respond in plain text (not JSON). You do NOT need to emit the findings schema \u2014 only emit structured findings if the user explicitly asks for them.
 - Include specific numbers from tool results, never guess.
 - When you have enough information, answer directly. Don't call tools you don't need.`;
-  const executionBiasSection = responseMode === "brief" ? "" : `EXECUTION BIAS (how you work):
+  const executionBiasSection = responseMode === "brief" ? `OUTPUT DOCTRINE (brief \u2014 one headline + \u22642 drivers + one so-what):
+${PYRAMID_OUTPUT_BLOCK}
+
+` : `EXECUTION BIAS (how you work):
 ${EXECUTION_BIAS_BLOCK}
 
 GTM ENGINEERING (how your recommendations become systems):
 ${GTM_ENGINEERING_BLOCK}
 
+IDEA GATE (when recommending action \u2014 silent):
+${HEILMEIER_GATE}
+
 OUTPUT DOCTRINE (how answers are structured for recall):
 ${PYRAMID_OUTPUT_BLOCK}
 
@@ -25838,7 +26025,7 @@ ${briefCommandSection}` : "";
   const dynamic = [
     "SESSION STATE (current \u2014 changes as the session progresses):",
     ...dynamicSections,
-    buildRuntimeBlock()
+    buildRuntimeBlock(promptOptions.runtimeFacts ?? {})
   ].join("\n\n");
   return { stable, dynamic };
 }
@@ -25870,15 +26057,27 @@ async function* agenticFindings(computeResult, divergences, options) {
     analysisBlock: options.analysisBlock,
     conversationBlock: options.conversationBlock,
     sessionArtifact: options.sessionArtifact,
-    thinkState: options.ctx.thinkState
+    thinkState: options.ctx.thinkState,
+    runtimeFacts: buildSituationalRuntimeFacts(options.ctx, {
+      channel: "think",
+      responseMode: "deep"
+    })
   }) : mode === "fresh" ? buildFreshNlSystemPrompt(
     options.sessionContext,
     options.memoryBlock,
     options.analysisBlock,
     options.conversationBlock,
-    { responseMode, sessionArtifact: options.sessionArtifact, experiment }
-  ) : buildSystemPrompt2();
-  const tools2 = useTools ? mode === "think" ? buildThinkTools() : mode === "fresh" ? buildFreshNlTools() : buildInvestigationTools() : [];
+    {
+      responseMode,
+      sessionArtifact: options.sessionArtifact,
+      experiment,
+      runtimeFacts: buildSituationalRuntimeFacts(options.ctx, {
+        responseMode
+      })
+    }
+  ) : buildSystemPrompt();
+  const analysisReady = isAnalysisReady(options.ctx);
+  const tools2 = useTools ? mode === "think" ? buildThinkTools() : mode === "fresh" ? buildFreshNlTools({ analysisReady }) : buildInvestigationTools() : [];
   const toolCtx = { computeResult, divergences };
   if (options.includeMetrics) {
     try {
@@ -26047,6 +26246,8 @@ var init_agentic_loop = __esm({
     init_prompt_parts();
     init_think_prompt();
     init_prompt();
+    init_context2();
+    init_situation();
     MAX_ITERATIONS = 10;
     INVESTIGATION_EVIDENCE_NUDGE_AFTER = 5;
     BRIEF_MAX_TOKENS = 768;
@@ -26239,7 +26440,7 @@ async function* streamAsk(question, ctx) {
     sessionContext: ctx.resumedSessionSummary,
     includeMetrics: true,
     analysisBlock: buildAnalysisBlock(ctx),
-    conversationBlock: getConversationPhaseBlock(ctx),
+    conversationBlock: getConversationPhaseBlock(ctx, { responseMode }),
     sessionArtifact,
     responseMode,
     priorMessages: ctx.conversation,
@@ -26284,7 +26485,7 @@ var init_ask = __esm({
     init_divergence();
     init_repl_api();
     init_context2();
-    init_phase();
+    init_situation();
     init_session_analysis();
     init_smoke_protocol();
   }