@sonnechasser/ntrp 1.4.5 → 1.4.6

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\`.`
       },
       {
@@ -11294,8 +11294,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 +13874,6 @@ __export(phase_exports, {
   buildConversationPrompt: () => buildConversationPrompt,
   consumeOrientEmptyEnterCoach: () => consumeOrientEmptyEnterCoach,
   formatPhaseLabel: () => formatPhaseLabel,
-  getConversationPhaseBlock: () => getConversationPhaseBlock,
   resolveConversationPhase: () => resolveConversationPhase,
   sessionHasData: () => sessionHasData
 });
@@ -13911,6 +13913,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 +13923,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 +13948,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 +13972,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"
@@ -16053,15 +16047,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 +16085,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 +16125,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 +16164,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 +16201,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 +16241,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 +16401,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 +16437,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 +16467,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 +16559,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 +16588,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."
@@ -18813,6 +18807,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 +19010,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 +19097,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 +19161,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 +19247,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 +20329,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 +20430,7 @@ var init_nl = __esm({
     "use strict";
     init_spinner();
     init_context2();
+    init_situation();
     init_phase();
     init_agent_context();
     init_orchestrator();
@@ -25499,12 +25658,12 @@ 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.
 - 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.
@@ -25538,7 +25697,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}
@@ -25588,7 +25747,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 };
 }
@@ -25705,12 +25864,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 +25877,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.
@@ -25838,7 +25999,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 +26031,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 }
+    {
+      responseMode,
+      sessionArtifact: options.sessionArtifact,
+      experiment,
+      runtimeFacts: buildSituationalRuntimeFacts(options.ctx, {
+        responseMode
+      })
+    }
   ) : buildSystemPrompt2();
-  const tools2 = useTools ? mode === "think" ? buildThinkTools() : mode === "fresh" ? buildFreshNlTools() : buildInvestigationTools() : [];
+  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 +26220,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 +26414,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 +26459,7 @@ var init_ask = __esm({
     init_divergence();
     init_repl_api();
     init_context2();
-    init_phase();
+    init_situation();
     init_session_analysis();
     init_smoke_protocol();
   }