@sonnechasser/ntrp 2.1.12 → 2.2.1

package/dist/mcp/server.js

@@ -1088,7 +1088,7 @@ import chalk3 from "chalk";
 function printDeepdiveHint(metricId, label) {
   const name = label ?? metricId;
   console.log(
-    "  " + chalk3.dim("How this number works: ") + paint("accent", `/deepdive ${metricId}`) + chalk3.dim(` \u2014 ${name}`)
+    "  " + chalk3.dim("How this number works: ") + paint("accent", `/tour ${metricId}`) + chalk3.dim(` \u2014 ${name}`)
   );
   console.log();
 }
@@ -12296,145 +12296,42 @@ var init_packs = __esm({
     SILENT = "Never name methodology brands in customer-visible text. Apply the moves; keep labels silent.";
     COUNSEL_PACKS = [
       {
-        id: "counsel_sales",
-        catalog_line: "- counsel_sales \u2014 pipeline conversion, capacity, deal strategy, sales-team structure",
-        internal_name: "Sales counsel",
-        vital_links: ["flow_rate", "thread_depth", "freshness", "signal_to_noise"],
-        board_cut: "Sales constraint in dollars (stuck, single-threaded, stale, misdirected effort) and the one sales-process bet.",
-        operator_cut: "Manager inspection cadence, stage exit criteria, SDR acceptance SLA, multi-thread targets \u2014 function owners.",
-        when_to_use: "flow_rate / thread_depth / opp freshness / activity noise; attainment, cycle, coverage, forecast-from-the-line.",
-        kill_rules: [
-          "No headcount before capacity math + constraint vital.",
-          "No more activity when signal_to_noise is red.",
-          "Do not protect zombie pipeline for coverage optics.",
-          "No invented reorgs or named people \u2014 function owners only.",
-          "Do not kill zombies first unless freshness/zombies are the gating constraint."
-        ],
-        silent_brand_rule: SILENT,
-        role_card_ids: ["vp_sales", "sales_manager", "ae", "sdr", "se", "sales_ops"],
-        tree_weight: { plg: 0.5, smb_velocity: 1, mid_market: 1, enterprise: 1 },
-        body: `THINK: Conversion physics \u2014 coverage vs win rate vs cycle vs noise. Structure (pod, hunter/farmer, overlay, SE pool) explains capacity, not the first fix. Inspection beats activity. Forecast fiction is a credibility problem before it is a revenue problem.
-ASK: Coverage, conversion, or cycle? Which stage clusters stuck $ ? Thread count on the largest deals? Which activities lack an opp? Where does manager commit diverge from stage evidence?
-CUT: stage-age, owner, segment, amount band, activity-to-opp link.
-DISAGREE: vs marketing \u2014 rejection reasons before "bad leads"; vs revops \u2014 keep fields that protect exit criteria, cut vanity; vs cs \u2014 oversell shows up in handoff packet; vs exec \u2014 sandbag vs stretch, use instruments.
-TREE: plg=assist/expand not a hunting machine. smb_velocity=SDR\u2192AE pod, speed. mid_market=balanced inspection. enterprise=SE pool, named accounts, multi-thread.
-CARDS: vp_sales for capacity/quota system; sales_manager for inspection; ae for deal strategy; sdr for create/accept; se only if enterprise/complex; sales_ops for territory/comp distortion.
-PLAYS: get_play_detail unstick-pipeline / multi-thread-deals / clean-dead-pipeline / retarget-effort / compress-sales-cycle only when that vital is the constraint.`
-      },
-      {
-        id: "counsel_marketing",
-        catalog_line: "- counsel_marketing \u2014 demand quality, ABM, PMM/lifecycle; content/brand/partner as support seats",
-        internal_name: "Marketing counsel",
-        vital_links: ["drop_rate", "signal_to_noise", "nrr"],
-        board_cut: "Marketing's dollar contribution and the leak (creation vs handoff vs conversion narrative).",
-        operator_cut: "SLA, scoring, journey gates, program kill rules, PMM adoption exams \u2014 function owners.",
-        when_to_use: "Pipeline creation, handoff leak, magic number / CAC inputs, messaging stalls, named-account whitespace.",
-        kill_rules: [
-          "Do not buy more top-of-funnel when drop_rate is the constraint.",
-          "Do not optimize MQL count against pipeline dollars.",
-          "No ABM theater on smb_velocity without named-account process.",
-          "Stop at accepted pipeline quality + narrative enablement \u2014 do not own close.",
-          "If content/brand/partner is not the constraint, do not open those cards."
+        id: "counsel_gtm",
+        catalog_line: "- counsel_gtm \u2014 one GTM consultant: weigh tradeoffs, pick one constraint, one sequence, one call",
+        internal_name: "GTM consultant",
+        vital_links: [
+          "freshness",
+          "flow_rate",
+          "drop_rate",
+          "signal_to_noise",
+          "thread_depth",
+          "nrr",
+          "grr"
         ],
-        silent_brand_rule: SILENT,
-        role_card_ids: [
-          "cmo",
-          "demand_gen",
-          "growth",
-          "abm",
-          "pmm",
-          "lifecycle",
-          "mkt_ops",
-          "content",
-          "brand",
-          "field_partner"
-        ],
-        tree_weight: { plg: 1, smb_velocity: 0.85, mid_market: 1, enterprise: 1 },
-        body: `THINK: Creation vs acceptance vs narrative. Sub-seats own different constraints \u2014 demand=volume/quality of accepted pipeline; ABM=named-list orchestration; PMM=win-rate/cycle via message; lifecycle=nurture/reactivation without colliding SDR; mkt ops=taxonomy/sync; content/brand/partner=support, not default.
-ASK: Is the leak before CRM, in routing, or at AE reject? Which channel's pipeline closes? Are MQLs a shared definition? Would fewer named accounts beat more spend?
-CUT: source, campaign, MQL\u2192SQL\u2192Opp, named-list vs rest, journey vs SDR sequence overlap.
-DISAGREE: vs sales \u2014 instrument acceptance reasons, not blame; vs revops \u2014 shared definitions, not last-touch religion; vs cs \u2014 frequency caps on customers; vs exec \u2014 brand spend needs a GTM exam or defer.
-TREE: plg=growth/lifecycle over classical demand. smb_velocity=inbound+outbound shared; no fake ABM. mid_market=demand-led, ABM opportunistic. enterprise=ABM+PMM first.
-CARDS: demand_gen if creation/quality; abm if named list; pmm if propose/decide stalls; lifecycle if nurture/collision; mkt_ops if scoring/sync; growth if PLG activation; content/brand/field_partner only when that sub-seat is the constraint.
-PLAYS: get_play_detail demand-quality-over-volume when accepts are weak; abm-orchestration when named-list process exists; rebalance-pipeline-mix / improve-magic-number for mix/efficiency. Handoff dollars usually belong with revops (fix-handoff-gap / harden-routing-sla) \u2014 marketing consumes the SLA.`
-      },
-      {
-        id: "counsel_revops",
-        catalog_line: "- counsel_revops \u2014 GTM systems, routing/SLA/hygiene; forecast/capacity/territory governance",
-        internal_name: "RevOps counsel",
-        vital_links: ["drop_rate", "freshness", "signal_to_noise"],
-        board_cut: "Whether the revenue machine's instruments can be trusted; cost of leak from process/system breaks.",
-        operator_cut: "Routing SLA, stage validation, sync observability, hygiene, GTM eng backlog \u2014 RevOps / mkt ops / GTM eng.",
-        when_to_use: "Broken instruments, routing, sync, definitions, hygiene, automation debt; forecast ritual design; capacity/territory ops.",
-        kill_rules: [
-          "No governance theater when routing/SLA is broken.",
-          "Do not automate bad process.",
-          "No boil-the-ocean warehouse while drop_rate burns.",
-          "Do not take sides on credit wars \u2014 impose shared definitions.",
-          "Prefer system/process enforcement over headcount."
-        ],
-        silent_brand_rule: SILENT,
-        role_card_ids: ["vp_revops", "revops_specialist", "gtm_engineer", "mkt_ops", "sales_ops"],
-        tree_weight: { plg: 0.6, smb_velocity: 0.75, mid_market: 1, enterprise: 1 },
-        body: `THINK: 65% systems \u2014 missing vs late vs wrong vs unused data. Foundation identity before activation automation. 35% governance \u2014 forecast ritual (timely commits, inspection cadence), capacity model math, territory/comp ops that distort behavior. Dashboards without SLA/enforcement are theater.
-ASK: Behavior or instrument? Which timer/queue/sync break maps to the dollar? Do we have observability before another flow? Is forecast wrong because inputs are dirty or because the ritual is missing? Does territory/comp explain attainment better than skill talk?
-CUT: source\u2192owner path, unassigned age, stage-exit compliance, sync error class, identity match, commit vs inspection evidence.
-DISAGREE: vs sales \u2014 keep fields that protect exit criteria; vs marketing \u2014 time-box safe launches; vs cs \u2014 identity + handoff packet before dual-tool debates; vs exec \u2014 platform spend tied to constraint dollar and a 30-day hold exam.
-TREE: plg=product\u2194CRM identity. smb_velocity=lean routing/SLA. mid_market=full OS. enterprise=matrixed + GTM eng.
-CARDS: revops_specialist for day-to-day CRM/SLA; gtm_engineer for integrations/identity; mkt_ops for MAP/sync; sales_ops for territory/comp; vp_revops for OS tradeoffs and freeze decisions.
-PLAYS: get_play_detail harden-routing-sla when timers/observability are the leak; fix-handoff-gap when the path/source audit is missing; forecast-ritual-hygiene only after instrument trust; clean-dead-pipeline / retarget-effort when hygiene/automation feeds noise.`
-      },
-      {
-        id: "counsel_exec",
-        catalog_line: "- counsel_exec \u2014 merge seats into one constraint, one sequence, board-ready call",
-        internal_name: "Executive counsel",
-        vital_links: ["freshness", "flow_rate", "drop_rate", "signal_to_noise", "thread_depth", "nrr", "grr"],
         board_cut: "The call, the dollar, the one bet, the exam date.",
         operator_cut: "Sequenced workstreams with function owners and contingencies.",
-        when_to_use: "Always in strategist roundtable before plan ship; cross-functional objectives; seat conflicts.",
+        when_to_use: "Any GTM advice \u2014 light NL or full plan. Always before plan ship; cross-functional objectives; CS vs new-logo tension.",
         kill_rules: [
-          "Do not average seats into mush \u2014 pick a constraint and sequence.",
+          "Merge, do not concatenate \u2014 one governing constraint and one sequence.",
           "No reorg/headcount as first move.",
           "No parallel initiatives that starve the bottleneck.",
           "Open with verdict + dollars, not methodology.",
-          "Do not ignore CS when NRR is the dollar engine."
+          "Do not drop retention when NRR/GRR dollars matter alongside new-logo.",
+          "Do not print named-role opinions or pack ids as speakers."
         ],
         silent_brand_rule: SILENT,
-        role_card_ids: ["cro", "cmo", "vp_sales", "vp_revops", "vp_cs"],
+        role_card_ids: [],
         tree_weight: { plg: 1, smb_velocity: 1, mid_market: 1, enterprise: 1 },
-        body: `THINK: Merge, do not concatenate. One governing constraint. Drop non-constraint theater. Board altitude = verdict + dollar + exam; operator altitude = sequenced owners. CS is the dollar engine when NRR/GRR dwarfs new-logo at risk (typical PLG and installed-base heavy enterprise).
-ASK: What unlocks the others? What dies in 90 days if we are wrong? Which seat's ask is polish?
+        body: `THINK: Merge, do not concatenate. One governing constraint. Drop non-constraint theater. Board altitude = verdict + dollar + exam; operator altitude = sequenced Monday owners (who does the work \u2014 not who is talking).
+TENSIONS (weigh inside one recommendation \u2014 never as competing seats):
+- CS vs new-logo: when NRR/GRR dollars and new-logo/freshness dollars both matter, keep both in one sequence under one governing constraint. Do not drop retention.
+- Quality vs volume: accepted pipeline quality and conversion beat MQL/activity theater when drop_rate or signal_to_noise is the constraint.
+- Systems vs theater: instrument trust (routing/SLA/hygiene) before narrative bets or dashboards without enforcement.
+ASK: What unlocks the others? What dies in 90 days if we are wrong? Which ask is polish?
 CUT: layer order of vitals; $ at risk by function; in-flight work that collides.
-DISAGREE: Force other packs to drop non-constraint work. Reject sales-only or marketing-only tunnels when instruments point elsewhere. Hold RevOps to instrument trust before narrative bets. Hold CS in the plan when GRR is the money.
+DISAGREE (fold in \u2014 do not stage speakers): reject sales-only or marketing-only tunnels when instruments point elsewhere; hold systems work when instruments are untrusted; hold CS in the plan when GRR/NRR is the money; reject more top-of-funnel when drop_rate is the leak.
 TREE: plg=CS/growth weight. smb_velocity=sales machine + routing. mid_market=full GTM. enterprise=thread/ABM/SE + NRR.
-CARDS: cro for sequencing investment; cmo when demand/brand tradeoff; vp_sales / vp_revops / vp_cs when that function must own the Monday bet. Do not clone this pack into the CRO card.
-PLAYS: do not pick plays here \u2014 sequence the constraint owner's play and demote the rest to contingency.`
-      },
-      {
-        id: "counsel_cs",
-        catalog_line: "- counsel_cs \u2014 NRR/GRR, renewals, TTV/onboarding, sales\u2192CS handoff",
-        internal_name: "Customer Success counsel",
-        vital_links: ["freshness", "nrr", "grr", "contraction_arr"],
-        board_cut: "NRR/GRR dollars at risk and the retention/expansion bet.",
-        operator_cut: "Risk flags, renewal cadence, handoff packet fields, touch model by segment \u2014 CS / renewals / onboarding.",
-        when_to_use: "NRR/GRR/churn/expansion; post-sale handoff; renewals; after sales wins that create CS landmines.",
-        kill_rules: [
-          "Do not push expansion into unhealthy accounts.",
-          "No more QBRs when onboarding/TTV is the constraint.",
-          "Do not treat renewals as pure billing.",
-          "Do not ignore sales handoff quality as root cause.",
-          "No CS headcount before segmentation/touch-model math."
-        ],
-        silent_brand_rule: SILENT,
-        role_card_ids: ["vp_cs", "csm", "renewals", "onboarding"],
-        tree_weight: { plg: 1, smb_velocity: 0.7, mid_market: 1, enterprise: 1 },
-        body: `THINK: GRR/NRR dollars. Churn vs failed expansion vs both. TTV/onboarding leak beats QBR theater. Champion loss vs product vs oversell. Expansion only after health restore when churn risk is high. Sales\u2192CS packet is often the real drop after Closed-Won.
-ASK: Leading indicator 60\u201390 days before churn? Was the sale clean (ICP/scope/handoff)? Onboarding incomplete or value never landed? Expansion owner CS vs AM vs AE?
-CUT: tenure, segment, product usage, renewal date aging, handoff-packet completeness, champion map.
-DISAGREE: vs sales \u2014 oversell and late CS involvement; vs marketing \u2014 customer email fatigue; vs revops \u2014 one SoR for renewal dates/risk; vs exec \u2014 growth plans must carry GRR exams.
-TREE: plg=CS+lifecycle+growth share the constraint. smb_velocity=often folded into CSM/AE; still name GRR. mid_market=full CS OS. enterprise=strategic accounts, renewals specialist.
-CARDS: csm for health/save; renewals for commercial deadline; vp_cs for touch model and where expansion sits; onboarding for readiness/TTV (capture required when events are missing).
-PLAYS: get_play_detail reduce-logo-churn / fix-renewal-process / renewal-early-warning / accelerate-expansion / sales-cs-handoff-packet when that instrument is the constraint.`
+PLAYS: sequence the constraint owner's play and demote the rest to contingency. Monday owners stay function-shaped ("RevOps starts the path audit") \u2014 never nameplates for who is talking.`
       }
     ];
   }
@@ -14181,139 +14078,38 @@ var init_constraint_signals = __esm({
 });
 
 // src/data/gtm-counsel/seating.ts
-function defaultSeatOrder(tree) {
-  const tieBreak = TREE_TIE_BREAKS[tree];
-  return COUNSEL_PACKS.filter(
-    (pack) => pack.id !== "counsel_exec"
-  ).slice().sort((a, b) => {
-    const weightDelta = b.tree_weight[tree] - a.tree_weight[tree];
-    if (weightDelta !== 0) return weightDelta;
-    return tieBreak.indexOf(a.id) - tieBreak.indexOf(b.id);
-  }).map((pack) => pack.id);
-}
-function baselineSeatWeight(packId, tree) {
-  const pack = COUNSEL_PACKS.find((candidate) => candidate.id === packId);
-  const weight = pack?.tree_weight[tree] ?? 0.5;
-  if (weight >= 0.8) return "full";
-  if (weight >= 0.5) return "secondary";
-  return "risk_note";
-}
 function inferConstraintOwnerPacks(objective, playIds = [], gatingVital) {
   return resolveLegacyConstraint(objective, playIds, gatingVital).locked_owners;
 }
 function inferConstraintOwnerPack(objective, playIds = [], gatingVital) {
   return inferConstraintOwnerPacks(objective, playIds, gatingVital)[0] ?? null;
 }
-function inferRoundtableBias(objective, profile) {
-  const text = [objective, profile?.user_scope, profile?.custom_context].filter(Boolean).join(" ").toLowerCase();
-  const notes = [];
-  const demoteToRiskNote = [];
-  const preferFull = [];
-  const strongMarketing = /marketing (lens|view|perspective)|from marketing|as cmo\b/.test(text);
-  const strongRevops = /revops (lens|view)|rev ops (lens|view)|systems view|from revops/.test(text);
-  const strongCs = /cs (lens|view)|success (lens|view)|retention view|nrr view/.test(text);
-  const strongSales = /sales (lens|view|perspective)|from sales|ae view|quota view/.test(text);
-  const weakMarketing = /\b(cmo|demand gen|demand-gen|mqls?\b|abm\b|pmm\b)\b/.test(text);
-  const weakRevops = /\b(revops|rev ops|routing sla|gtm engineer)\b/.test(text);
-  const weakCs = /\b(customer success|renewals manager|csm\b)\b/.test(text);
-  const weakSales = /\b(vp sales|sales manager|quota attain)\b/.test(text);
-  const notCro = /not cro|ignore cro|operator framing|not ceo.centric|skip exec politics/.test(text);
-  if (strongMarketing || weakMarketing) {
-    preferFull.push("counsel_marketing", "counsel_exec");
-    notes.push(strongMarketing ? "Bias: marketing-weighted roundtable" : "Bias: marketing mentioned \u2014 keep marketing full");
-  }
-  if (strongRevops || weakRevops) {
-    preferFull.push("counsel_revops", "counsel_exec");
-    notes.push(strongRevops ? "Bias: RevOps-weighted roundtable" : "Bias: RevOps mentioned \u2014 keep RevOps full");
-  }
-  if (strongCs || weakCs) {
-    preferFull.push("counsel_cs", "counsel_exec");
-    notes.push(strongCs ? "Bias: CS-weighted roundtable" : "Bias: CS mentioned \u2014 keep CS full");
-  }
-  if (strongSales || weakSales) {
-    preferFull.push("counsel_sales", "counsel_exec");
-    notes.push(strongSales ? "Bias: sales-weighted roundtable" : "Bias: sales mentioned \u2014 keep sales full");
-  }
-  if (notCro) {
-    notes.push("Bias: operator framing for exec seat (not CRO-centric voice)");
-  }
-  const strong = [
-    strongMarketing ? "counsel_marketing" : null,
-    strongRevops ? "counsel_revops" : null,
-    strongCs ? "counsel_cs" : null,
-    strongSales ? "counsel_sales" : null
-  ].filter((p) => p != null);
-  if (strong.length === 1) {
-    for (const p of ALL_FUNCTION) {
-      if (p !== strong[0]) demoteToRiskNote.push(p);
-    }
-  }
-  return { demoteToRiskNote, preferFull, notes };
+function inferRoundtableBias(_objective, _profile) {
+  return { demoteToRiskNote: [], preferFull: [], notes: [] };
 }
 function buildRoundtableSeating(opts) {
-  const {
-    tree,
-    objective,
-    profile = null,
-    playIds = [],
-    gatingVital = null,
-    operatorConstraints = []
-  } = opts;
-  const bias = inferRoundtableBias(objective, profile);
-  const objectiveContext = {
-    objective,
-    play_ids: playIds,
-    operator_constraints: operatorConstraints
+  const constraint = opts.resolvedConstraint ?? resolveLegacyConstraint(
+    opts.objective,
+    opts.playIds ?? [],
+    opts.gatingVital ?? null
+  );
+  const bias_notes = [...constraint.notes ?? []];
+  if (constraint.locked_owners?.length) {
+    bias_notes.push(
+      `Constraint owners (internal, not speakers): ${constraint.locked_owners.join(", ")}`
+    );
+  }
+  return {
+    tree: opts.tree ?? "mid_market",
+    seats: [],
+    bias_notes,
+    constraint
   };
-  const constraint = opts.resolvedConstraint ?? resolveConstraint({
-    health: opts.health ?? {
-      gating_vital: gatingVital && ["freshness", "flow_rate", "drop_rate", "signal_to_noise", "thread_depth"].includes(
-        gatingVital
-      ) ? gatingVital : null
-    },
-    objective: objectiveContext
-  });
-  const constraintOwners = constraint.locked_owners;
-  const ownerSet = new Set(constraintOwners);
-  const demote = new Set(bias.demoteToRiskNote);
-  const prefer = new Set(bias.preferFull);
-  const seats = [{ pack_id: "counsel_exec", weight: "full" }];
-  for (const packId of defaultSeatOrder(tree)) {
-    let weight = baselineSeatWeight(packId, tree);
-    if (demote.has(packId) && !prefer.has(packId)) weight = "risk_note";
-    if (prefer.has(packId)) weight = "full";
-    if (ownerSet.has(packId)) weight = "full";
-    seats.push({ pack_id: packId, weight });
-  }
-  for (const owner of constraintOwners) {
-    if (!seats.some((s) => s.pack_id === owner)) {
-      seats.push({ pack_id: owner, weight: "full" });
-    }
-  }
-  const bias_notes = [...bias.notes, ...constraint.notes];
-  if (constraintOwners.length) {
-    bias_notes.push(`Constraint-owning pack locked full: ${constraintOwners.join(", ")}`);
-  }
-  return { tree, seats, bias_notes, constraint };
-}
-var ALL_FUNCTION, TREE_TIE_BREAKS;
+}
 var init_seating = __esm({
   "src/data/gtm-counsel/seating.ts"() {
     "use strict";
-    init_packs();
     init_constraint_signals();
-    ALL_FUNCTION = [
-      "counsel_sales",
-      "counsel_marketing",
-      "counsel_revops",
-      "counsel_cs"
-    ];
-    TREE_TIE_BREAKS = {
-      plg: ["counsel_cs", "counsel_marketing", "counsel_revops", "counsel_sales"],
-      smb_velocity: ["counsel_sales", "counsel_revops", "counsel_marketing", "counsel_cs"],
-      mid_market: ["counsel_sales", "counsel_marketing", "counsel_revops", "counsel_cs"],
-      enterprise: ["counsel_sales", "counsel_marketing", "counsel_revops", "counsel_cs"]
-    };
   }
 });
 
@@ -14351,7 +14147,7 @@ __export(gtm_counsel_exports, {
 });
 function buildCounselCatalogBlock() {
   const lines = COUNSEL_PACKS.map((p) => p.catalog_line).join("\n");
-  return `GTM counsel packs (function perspectives). Call get_counsel_detail for a pack body. Open get_role_card only for ids listed on the pack you pulled \u2014 do not enumerate every role. Never invent reorgs; never name methodology brands to the user.
+  return `GTM consultant (one voice). Call get_counsel_detail with counsel_gtm for the pack body. Do not open role cards. Never invent reorgs; never name methodology brands to the user; never print pack ids or function seats as speakers.
 ${lines}`;
 }
 function buildOrgTreeContextLine(profile) {
@@ -14377,7 +14173,7 @@ function formatCounselDetail(pack, tree) {
     tree_weight: pack.tree_weight[tree],
     org_tree: tree,
     body: pack.body,
-    notice: "Apply moves in body/board_cut/operator_cut. Never name internal methodology brands to the user. Open get_role_card for listed role_card_ids when challenging owners."
+    notice: "Apply moves in body/board_cut/operator_cut. Never name internal methodology brands to the user. Speak as one GTM consultant \u2014 never as competing seats or named-role opinions."
   };
 }
 function formatRoleCardDetail(card, tree) {
@@ -15026,21 +14822,33 @@ Hours saved, weekly activity trend, session counts, AI token usage, and the full
 Type reset to confirm. This clears hours and milestones. The install identity stays.`
       },
       {
-        name: "deepdive",
+        name: "tour",
         raw: `---
-name: deepdive
+name: tour
 description: Show slides for numbers and how to use NTRP
 section: Navigation
 args: [<metric>|guide|list|tour]
-handler: ../commands/deepdive.ts
+handler: ../commands/tour.ts
 ---
 
 CLI slide deck: SaaS refresher, five vital signs (definition, formula, visual, dollar translation), then a how-to section (talk, ask, ship to your AI, loop).
-Bare \`/deepdive\` runs the full onboarding tour. Type \`/deepdive guide\` to jump to how to use NTRP (includes teaching the inbox once).
-Type \`/deepdive handoff\` for the ship-to-AI slide. Type \`/deepdive <metric>\` to jump to one metric card.
-Type \`/deepdive list\` to print the catalog. Works without an AI key. Re-run anytime from the homescreen.
+Bare \`/tour\` runs the full onboarding tour. Type \`/tour guide\` to jump to how to use NTRP (includes teaching the inbox once).
+Type \`/tour handoff\` for the ship-to-AI slide. Type \`/tour <metric>\` to jump to one metric card.
+Type \`/tour list\` to print the catalog. Works without an AI key. Re-run anytime from the homescreen.
 During the tour: Enter advances, \`b\` / \`back\` goes to the previous slide, \`q\` quits. After the tour, the same \`b\` / \`back\` word steps back one confirm gate in the REPL (scope, data, strategy) \u2014 it does not unload data or undo compute.
 Live values overlay when an analysis exists.`
+      },
+      {
+        name: "deepdive",
+        raw: `---
+name: deepdive
+description: Retired \u2014 the slideshow is /tour
+section: Hidden
+hidden: true
+handler: ../commands/deepdive.ts
+---
+
+Former name for the numbers slideshow. Prints a one-line pointer to \`/tour\`. Does not open the deck.`
       },
       {
         name: "thinkwithme",
@@ -16275,39 +16083,19 @@ var init_tool_schemas = __esm({
       },
       {
         name: "get_counsel_detail",
-        description: "Read a GTM function counsel pack (sales, marketing, revops, exec, cs): when to use, kill rules, vital links, role cards to open, and instruction body. Use before recommending cross-functional work or during strategist roundtable. Never name methodology brands to the user; no invented reorgs.",
+        description: "Read the GTM consultant pack (counsel_gtm): when to use, kill rules, vital links, and instruction body. Use before recommending cross-functional work or during strategist plan check. One voice \u2014 never seat competing functions. Never name methodology brands to the user; no invented reorgs.",
         parameters: {
           type: "object",
           properties: {
             counsel_id: {
               type: "string",
               maxLength: 40,
-              description: "Exact id: counsel_sales, counsel_marketing, counsel_revops, counsel_exec, or counsel_cs."
+              description: "Exact id: counsel_gtm."
             }
           },
           required: ["counsel_id"]
         }
       },
-      {
-        name: "get_role_card",
-        description: "Read a GTM role expertise card (e.g. ae, sdr, vp_revops, csm): owns/does-not-own, metrics, consult questions, failure modes, and tensions. Call after get_counsel_detail when you need how a specific seat thinks. Annotates presence for the active org tree.",
-        parameters: {
-          type: "object",
-          properties: {
-            role_id: {
-              type: "string",
-              maxLength: 40,
-              description: "Exact role id listed on the pack you pulled via get_counsel_detail, e.g. 'ae', 'demand_gen', 'gtm_engineer'."
-            },
-            org_tree: {
-              type: "string",
-              enum: ["plg", "smb_velocity", "mid_market", "enterprise"],
-              description: "Optional org tree override; defaults to profile sales_motion / mid_market."
-            }
-          },
-          required: ["role_id"]
-        }
-      },
       {
         name: "get_session_brief",
         description: "Read the 1-page context brief of a PRIOR session by id or 4-char suffix: status, dataset, scope, computed scores with dollar values, headline metrics, deliverables, and conversation log. Use when the user references earlier work \u2014 'last week we found\u2026', 'compare with the previous analysis', 'what did session 9297 conclude?'. Read-only.",
@@ -18859,17 +18647,9 @@ function renderRuminationLog(job) {
   );
   if (job.library_path) lines.push(`Strategy: ${job.library_path}`);
   if (job.handoff_path) lines.push(`Handoff: ${job.handoff_path}`);
-  if (job.roundtable) {
-    lines.push("");
-    lines.push("## Counsel roundtable");
+  if (job.roundtable?.digest) {
     lines.push("");
     lines.push(job.roundtable.digest);
-    if (job.roundtable.issues.length) {
-      lines.push("");
-      lines.push(
-        `Validation: ${job.roundtable.issues.map((entry) => entry.code).join(", ")}`
-      );
-    }
   }
   lines.push("");
   lines.push("## Rounds");
@@ -18998,7 +18778,7 @@ function consumeOrientEmptyEnterCoach(ctx) {
   if (!hasValidLicense()) {
     return "Type /activate to paste a key. Type /checkout if you need to sign up.";
   }
-  return "Type a question, type use demo data, or type /deepdive. Enter alone does not start a step here.";
+  return "Type a question, type use demo data, or type /tour. Enter alone does not start a step here.";
 }
 function formatPhaseLabel(phase) {
   switch (phase) {
@@ -19918,7 +19698,7 @@ function buildExploreTeachingGhosts(ctx, staticExplore) {
   if (cached2 && cached2.length > 0) {
     const ghosts = asksToGhostHints(cached2);
     const gating = ctx.snapshot.computeResult?.aggregate.gating_vital_sign;
-    if (gating) ghosts.push(`try /deepdive ${gating}`);
+    if (gating) ghosts.push(`try /tour ${gating}`);
     ghosts.push('try "how should we fix this?"');
     return dedupeGhosts(ghosts);
   }
@@ -19929,7 +19709,7 @@ function buildExploreTeachingGhosts(ctx, staticExplore) {
     });
     return dedupeGhosts([
       ...asksToGhostHints(asks),
-      `try /deepdive ${health.gating_vital_sign}`,
+      `try /tour ${health.gating_vital_sign}`,
       'try "how should we fix this?"'
     ]);
   }
@@ -20535,7 +20315,7 @@ function buildDefinitionsAppendix(bundle, opts = {}) {
   lines.push(`## Metric definitions (for the ${audienceLabel(audience)})`);
   lines.push("");
   lines.push(
-    audience === "ops" ? "Formula-first brief for operators who execute the plan. Full slides: `/deepdive <metric>`." : "Meaning-first brief for the room. Full slides: `/deepdive <metric>`."
+    audience === "ops" ? "Formula-first brief for operators who execute the plan. Full slides: `/tour <metric>`." : "Meaning-first brief for the room. Full slides: `/tour <metric>`."
   );
   lines.push("");
   for (const c of candidates) {
@@ -20622,8 +20402,8 @@ function generateMarkdownReport(data) {
       lines.push("");
       for (const entity of vs.entity_details.slice(0, 5)) {
         const name = entity.name ?? entity.id ?? "Unknown";
-        const issue2 = entity.issue ?? "";
-        lines.push(`- **${name}**: ${issue2}`);
+        const issue = entity.issue ?? "";
+        lines.push(`- **${name}**: ${issue}`);
       }
       if (vs.entity_details.length > 5) {
         lines.push(`- *...and ${vs.entity_details.length - 5} more*`);
@@ -21636,56 +21416,36 @@ Respond with the full plan as strict JSON matching this schema \u2014 no markdow
 ${STRATEGIST_PLAN_SCHEMA_BLOCK}`;
 }
 function buildRoundtableMessage(input) {
-  const bias = input.biasNotes.length > 0 ? `Bias notes:
+  const bias = input.biasNotes.length > 0 ? `Weighing notes:
 - ${input.biasNotes.join("\n- ")}
 
 ` : "";
-  const owner = input.constraintOwner ? `Constraint-owning pack (must stay full seat): ${input.constraintOwner}
-
-` : "";
-  const constraint = input.constraint ? `CONSTRAINT CHANNELS:
+  const constraint = input.constraint ? `CONSTRAINT CHANNELS (weigh inside one recommendation \u2014 do not print as speakers):
 - Health gate: ${input.constraint.health_gate ? String(input.constraint.health_gate.id) : "not verified"} \u2192 ${input.constraint.health_gate_owners.join(", ") || "no mapped owner"}
 - Objective constraint: ${input.constraint.objective_constraint ? String(input.constraint.objective_constraint.id) : "not verified"} \u2192 ${input.constraint.objective_owners.join(", ") || "no mapped owner"}
-- If these differ, preserve both seats and have exec sequence the objective behind the health gate unless evidence supports another order.
+- If both matter (e.g. freshness/new-logo dollars and red NRR/GRR), keep both in one sequence under one governing constraint. Do not drop retention.
 
 ` : "";
-  return `STAGE R \u2014 ROUNDTABLE. Org tree: ${input.tree}. Before stress-testing, seat GTM counsel packs and challenge the draft.
+  return `STAGE R \u2014 PLAN CHECK. Org tree: ${input.tree}. Before stress-testing, run one GTM consultant check on the draft. Speak as NTRP \u2014 one voice. No seats, no CRO/CMO/CS/sales/marketing/RevOps/Exec nameplates.
 
-${owner}${constraint}${bias}EXEC MERGE SEAT: counsel_exec (full; call get_counsel_detail; output only in top-level exec).
-FUNCTION SEATS (weight full = deep challenge; secondary/risk_note = short risk note only):
-${input.seatsBlock}
-
-Call get_counsel_detail only for full seats. risk_note and secondary seats write a short risk without a full pack pull. Cap get_role_card to one id per challenged workstream owner \u2014 pick from that pack's role_card_ids. Call get_play_detail if a play_id is thin. Do not invent reorgs or named people. Never name methodology brands in customer-facing fields.
+${constraint}${bias}Call get_counsel_detail for counsel_gtm only. Do not call get_role_card. Call get_play_detail if a play_id is thin. Do not invent reorgs or named people. Never name methodology brands in customer-facing fields. Monday owners on actions stay function-shaped ("RevOps starts the path audit") \u2014 that is who does the work, not who is talking.
 
 DRAFT PLAN JSON:
 ${input.draftPlanJson}
 
 Respond with STRICT JSON only (no prose, no fences):
 {
-  "seats": [
-    {
-      "pack": "counsel_sales",
-      "stance": "support" | "challenge" | "abstain",
-      "constraint_agree": true,
-      "challenge": "\u226440 words \u2014 what the draft gets wrong or misses; empty only if support + risk or exec pre-mortem",
-      "missing_exam": "metric + date + instrument (or empty string)",
-      "cross_functional_risk": "\u226430 words",
-      "role_cards_used": ["ae"]
-    }
-  ],
-  "exec": {
-    "governing_constraint": "one constraint with dollar label",
-    "sequence": ["play or workstream order"],
-    "drop": ["non-constraint theater to kill"],
-    "merge_verdict": "\u226450 words",
-    "pre_mortem": "if all seats support: the one most likely death cause; else optional"
-  }
+  "governing_constraint": "one constraint with dollar label",
+  "sequence": ["first move", "second move", "third move"],
+  "drop": "non-constraint theater to kill",
+  "verdict": "\u226450 words \u2014 one recommendation that already weighed the tradeoffs",
+  "pre_mortem": "required \u2014 the one most likely death cause if this plan ships as-is"
 }
 
-Rules: do not invent a fake challenge. Empty challenge is allowed only with stance support AND a non-empty cross_functional_risk or a non-empty exec.pre_mortem. If every seat supports, exec MUST write a pre-mortem death cause. Constraint-owning pack may not abstain without a risk note.`;
+Rules: one consultant, one sequence, one governing constraint. Fold CS vs new-logo, quality vs volume, and systems vs theater into the recommendation \u2014 never as competing opinions. pre_mortem is always required. Never emit seats[], exec wrappers, pack ids as speakers, or CRO/CMO/CS says headers.`;
 }
 function buildStressTestMessage(roundtableDigest) {
-  const roundtableBlock = roundtableDigest ? `0. ROUNDTABLE DIGEST (mandatory): address every challenge \u2014 accept and revise, or reject with an instrument reason. Add missing_exam items or explicitly defer with why. Reflect exec.drop in the final plan. If every seat supported, exec pre-mortem is the death cause check 1 must defend \u2014 do not invent a fake challenge after the fact.
+  const roundtableBlock = roundtableDigest ? `0. PLAN CHECK DIGEST (mandatory): address every challenge \u2014 accept and revise, or reject with an instrument reason. Add missing_exam items or explicitly defer with why. Reflect Drop in the final plan. If the check was all-agree, Pre-mortem is the death cause check 1 must defend \u2014 do not invent a fake challenge after the fact.
 ${roundtableDigest}
 
 ` : "";
@@ -22252,181 +22012,169 @@ function str2(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function strArray2(value) {
+  if (typeof value === "string") {
+    const t = value.trim();
+    return t ? [t] : [];
+  }
   return Array.isArray(value) ? value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [];
 }
 function words(value) {
   return value.trim() ? value.trim().split(/\s+/).length : 0;
 }
-function issue(issues, code, message, severity = "blocking") {
+function pushIssue(issues, code, message, severity = "blocking") {
   issues.push({ code, severity, message });
 }
-function parseSeat(raw, issues, index) {
-  if (!raw || typeof raw !== "object") {
-    issue(issues, "seat_shape", `Seat ${index + 1} is not an object.`);
-    return null;
-  }
-  const obj = raw;
-  const pack = str2(obj.pack);
-  if (pack === "counsel_exec") {
-    issue(issues, "exec_in_seats", "counsel_exec must appear only in the top-level exec object.");
-    return null;
-  }
-  if (!FUNCTION_PACKS.has(pack)) {
-    issue(issues, "unknown_pack", `Seat ${index + 1} has unknown pack '${pack || "(empty)"}'.`);
-    return null;
-  }
-  const stance = str2(obj.stance);
-  if (!STANCES.has(stance)) {
-    issue(issues, "invalid_stance", `${pack} has invalid stance '${stance || "(empty)"}'.`);
-  }
-  if (typeof obj.constraint_agree !== "boolean") {
-    issue(issues, "constraint_agree", `${pack} must set constraint_agree to true or false.`);
-  }
-  const challenge = str2(obj.challenge);
-  const risk = str2(obj.cross_functional_risk);
-  const missingExam = str2(obj.missing_exam);
-  if (words(challenge) > 40) {
-    issue(issues, "challenge_length", `${pack} challenge exceeds 40 words.`);
-  }
-  if (words(risk) > 30) {
-    issue(issues, "risk_length", `${pack} cross_functional_risk exceeds 30 words.`);
-  }
-  const roleCards = strArray2(obj.role_cards_used);
-  const allowed = new Set(getCounselPackById(pack)?.role_card_ids ?? []);
-  const validRoles = [];
-  for (const roleId of roleCards) {
-    if (!getRoleCardById(roleId) || !allowed.has(roleId)) {
-      issue(
+function scanBannedSpeakers(text, issues, field) {
+  for (const pattern of BANNED_SPEAKER_PATTERNS) {
+    if (pattern.test(text)) {
+      pushIssue(
         issues,
-        "role_not_in_pack",
-        `${pack} used role card '${roleId}' that is not listed on that pack.`
+        "banned_speaker",
+        `${field} must not name competing seats or role speakers.`
       );
-      continue;
+      return;
     }
-    validRoles.push(roleId);
   }
-  return {
-    pack,
-    stance: STANCES.has(stance) ? stance : "abstain",
-    constraint_agree: obj.constraint_agree === true,
-    challenge,
-    missing_exam: missingExam,
-    cross_functional_risk: risk,
-    role_cards_used: validRoles
-  };
 }
-function parseExec(raw, issues) {
+function parseConsultantCheck(raw, issues) {
   if (!raw || typeof raw !== "object") {
-    issue(issues, "missing_exec", "Roundtable requires a top-level exec object.");
+    pushIssue(issues, "consultant_shape", "Consultant check output is not a JSON object.");
     return null;
   }
   const obj = raw;
+  if ("seats" in obj) {
+    pushIssue(issues, "seats_forbidden", "Consultant check must not include a seats array.");
+  }
+  if (obj.exec && typeof obj.exec === "object") {
+    pushIssue(
+      issues,
+      "exec_wrapper_forbidden",
+      "Consultant check must be a flat object \u2014 not seats[] + exec."
+    );
+  }
   const governing = str2(obj.governing_constraint);
-  const verdict = str2(obj.merge_verdict);
-  if (!governing) issue(issues, "exec_constraint", "exec.governing_constraint is required.");
-  if (!verdict) issue(issues, "exec_verdict", "exec.merge_verdict is required.");
-  if (words(verdict) > 50) {
-    issue(issues, "exec_verdict_length", "exec.merge_verdict exceeds 50 words.");
+  const sequence = strArray2(obj.sequence);
+  const dropRaw = obj.drop;
+  const drop = Array.isArray(dropRaw) ? strArray2(dropRaw).join("; ") : str2(dropRaw);
+  const verdict = str2(obj.verdict) || str2(obj.merge_verdict);
+  const preMortem = str2(obj.pre_mortem) || str2(obj.preMortem);
+  if (!governing) pushIssue(issues, "governing_constraint", "governing_constraint is required.");
+  if (!verdict) pushIssue(issues, "verdict", "verdict is required.");
+  if (words(verdict) > 50) pushIssue(issues, "verdict_length", "verdict exceeds 50 words.");
+  if (!preMortem) {
+    pushIssue(
+      issues,
+      "missing_pre_mortem",
+      "pre_mortem is required (all-agree checks still need a death cause)."
+    );
+  }
+  for (const [field, text] of [
+    ["governing_constraint", governing],
+    ["verdict", verdict],
+    ["drop", drop],
+    ["pre_mortem", preMortem],
+    ["sequence", sequence.join(" ")]
+  ]) {
+    if (text) scanBannedSpeakers(text, issues, field);
   }
   return {
     governing_constraint: governing,
-    sequence: strArray2(obj.sequence),
-    drop: strArray2(obj.drop),
-    merge_verdict: verdict,
-    pre_mortem: str2(obj.pre_mortem)
+    sequence,
+    drop,
+    verdict,
+    pre_mortem: preMortem
   };
 }
-function validateRoundtableResult(raw, options) {
+function validateRoundtableResult(raw, options = {}) {
   const issues = [];
   if (!raw || typeof raw !== "object") {
     return {
       result: null,
-      issues: [{ code: "roundtable_shape", severity: "blocking", message: "Roundtable output is not a JSON object." }],
+      issues: [
+        {
+          code: "consultant_shape",
+          severity: "blocking",
+          message: "Consultant check output is not a JSON object."
+        }
+      ],
       blocking: true
     };
   }
-  const obj = raw;
-  if (!Array.isArray(obj.seats)) {
-    issue(issues, "missing_seats", "Roundtable requires a seats array.");
-  }
-  const seats = (Array.isArray(obj.seats) ? obj.seats : []).map((seat, index) => parseSeat(seat, issues, index)).filter((seat) => seat != null);
-  const exec = parseExec(obj.exec, issues);
-  const seen = /* @__PURE__ */ new Set();
-  for (const seat of seats) {
-    if (seen.has(seat.pack)) {
-      issue(issues, "duplicate_seat", `Roundtable contains duplicate seat ${seat.pack}.`);
-    }
-    seen.add(seat.pack);
-  }
-  const expected = options.seating.seats.filter((seat) => seat.pack_id !== "counsel_exec").map((seat) => seat.pack_id);
-  for (const pack of expected) {
-    if (!seen.has(pack)) issue(issues, "missing_seat", `Roundtable omitted seated pack ${pack}.`);
-  }
-  for (const pack of seen) {
-    if (!expected.includes(pack)) issue(issues, "unexpected_seat", `Roundtable emitted unseated pack ${pack}.`);
-  }
+  const parsed = parseConsultantCheck(raw, issues);
   const pulls = new Set(options.counselPulls ?? []);
   if (options.requireCounselPulls !== false) {
-    const fullPacks = options.seating.seats.filter((seat) => seat.weight === "full").map((seat) => seat.pack_id);
-    for (const pack of fullPacks) {
-      if (!pulls.has(pack)) {
-        issue(issues, "missing_counsel_pull", `Full seat ${pack} did not call get_counsel_detail.`);
-      }
-    }
-  }
-  if (exec) {
-    const allSupport = seats.length > 0 && seats.every((seat) => seat.stance === "support");
-    if (allSupport && !exec.pre_mortem) {
-      issue(issues, "missing_pre_mortem", "All-support roundtables require exec.pre_mortem.");
+    if (!pulls.has("counsel_gtm")) {
+      pushIssue(
+        issues,
+        "missing_counsel_pull",
+        "Consultant check must call get_counsel_detail for counsel_gtm."
+      );
     }
-    for (const seat of seats) {
-      if (!seat.challenge && !(seat.stance === "support" && (Boolean(seat.cross_functional_risk) || Boolean(exec.pre_mortem)))) {
-        issue(
+    for (const pull of pulls) {
+      if (pull !== "counsel_gtm") {
+        pushIssue(
           issues,
-          "empty_challenge",
-          `${seat.pack} may leave challenge empty only with support plus risk or exec pre-mortem.`
+          "forbidden_counsel_pull",
+          `Only counsel_gtm may be pulled (saw '${pull}').`
         );
       }
-      if (seat.stance === "abstain" && !seat.cross_functional_risk) {
-        issue(issues, "abstain_without_risk", `${seat.pack} abstained without a risk note.`);
-      }
     }
   }
-  for (const owner of options.constraintOwners) {
-    const seat = seats.find((candidate) => candidate.pack === owner);
-    if (!seat) continue;
-    if (seat.stance === "abstain" && !seat.cross_functional_risk) {
-      issue(issues, "owner_abstain", `Constraint owner ${owner} abstained without a risk note.`);
+  if (options.requireRetentionInSequence && parsed) {
+    const blob = `${parsed.governing_constraint} ${parsed.sequence.join(" ")} ${parsed.verdict} ${parsed.drop}`.toLowerCase();
+    const hasRetention = /nrr|grr|retention|renewal|churn|expansion/.test(blob);
+    const hasNewLogo = /freshness|new[- ]?logo|acquisition|inbound|outbound/.test(blob);
+    if (hasNewLogo && !hasRetention) {
+      pushIssue(
+        issues,
+        "retention_dropped",
+        "Dual-dollar check: new-logo/freshness present but retention/NRR/GRR absent from sequence.",
+        "advisory"
+      );
     }
   }
   const blocking = issues.some((entry) => entry.severity === "blocking");
   return {
-    result: exec ? { seats, exec } : null,
+    result: blocking ? null : parsed,
     issues,
     blocking
   };
 }
-function parseAndValidateRoundtable(text, options) {
+function parseAndValidateRoundtable(text, options = {}) {
   return validateRoundtableResult(parseJsonObjectFromText(text), options);
 }
 function formatRoundtableDigestFromResult(result) {
-  const lines = result.seats.map(
-    (seat) => `- ${seat.pack} [${seat.stance}]: ${seat.challenge || "(no challenge)"}${seat.missing_exam ? ` | missing exam: ${seat.missing_exam}` : ""}${seat.cross_functional_risk ? ` | risk: ${seat.cross_functional_risk}` : ""}`
-  );
-  lines.push(`EXEC governing: ${result.exec.governing_constraint || "(none)"}`);
-  if (result.exec.sequence.length) lines.push(`EXEC sequence: ${result.exec.sequence.join(" \u2192 ")}`);
-  if (result.exec.drop.length) lines.push(`EXEC drop: ${result.exec.drop.join("; ")}`);
-  if (result.exec.merge_verdict) lines.push(`EXEC verdict: ${result.exec.merge_verdict}`);
-  if (result.exec.pre_mortem) lines.push(`EXEC pre-mortem: ${result.exec.pre_mortem}`);
+  const lines = [];
+  if (result.governing_constraint) {
+    lines.push(`Governing constraint: ${result.governing_constraint}`);
+  }
+  if (result.sequence.length) {
+    lines.push(`Sequence: ${result.sequence.join(" then ")}`);
+  }
+  if (result.drop) {
+    lines.push(`Drop: ${result.drop}`);
+  }
+  if (result.verdict) {
+    lines.push(`Verdict: ${result.verdict}`);
+  }
+  if (result.pre_mortem) {
+    lines.push(`Pre-mortem: ${result.pre_mortem}`);
+  }
   return lines.join("\n");
 }
-function buildRoundtableRetryMessage(validation, seating) {
-  const required = seating.seats.filter((seat) => seat.pack_id !== "counsel_exec").map((seat) => seat.pack_id).join(", ");
+function buildRoundtableRetryMessage(validation, _seating) {
   const failures = validation.issues.filter((entry) => entry.severity === "blocking").map((entry) => `${entry.code}: ${entry.message}`).join("\n- ");
-  return `Roundtable JSON did not validate.
-- ${failures || "roundtable_shape: unusable JSON"}
-Required function seats: ${required}.
-Respond with ONLY corrected roundtable JSON. counsel_exec belongs only in top-level exec. All-support requires exec.pre_mortem.`;
+  return `Plan check JSON did not validate.
+- ${failures || "consultant_shape: unusable JSON"}
+Respond with ONLY corrected flat JSON (no seats, no exec wrapper):
+{
+  "governing_constraint": "...",
+  "sequence": ["a", "b", "c"],
+  "drop": "...",
+  "verdict": "...",
+  "pre_mortem": "..."
+}
+Call get_counsel_detail for counsel_gtm only. pre_mortem is required. Never print CRO/CMO/CS/sales/marketing/RevOps/Exec as speakers.`;
 }
 function normalizedPlanText(plan) {
   return JSON.stringify(plan).toLowerCase();
@@ -22438,69 +22186,55 @@ function checkRoundtableReflection(input) {
   const issues = [];
   const draft = normalizedPlanText(input.draftPlan);
   const final = normalizedPlanText(input.finalPlan);
-  for (const dropped of input.roundtable.exec.drop) {
-    const needle = dropped.toLowerCase();
-    if (needle.length >= 4 && draft.includes(needle) && final.includes(needle)) {
-      issue(
-        issues,
-        "roundtable_drop_ignored",
-        `Final plan still contains exec drop '${dropped}'.`,
-        "advisory"
-      );
-    }
-  }
-  for (const seat of input.roundtable.seats) {
-    if (seat.missing_exam) {
-      const tokens = significantTokens(seat.missing_exam);
-      if (tokens.length > 0 && !tokens.some((token) => final.includes(token))) {
-        issue(
+  if (input.roundtable.drop) {
+    for (const dropped of input.roundtable.drop.split(/;|\n/).map((part) => part.trim()).filter(Boolean)) {
+      const needle = dropped.toLowerCase();
+      if (needle.length >= 4 && draft.includes(needle) && final.includes(needle)) {
+        pushIssue(
           issues,
-          "roundtable_exam_missing",
-          `${seat.pack} missing exam is not visible in the final plan.`,
+          "consultant_drop_ignored",
+          `Final plan still contains drop '${dropped}'.`,
           "advisory"
         );
       }
     }
-    if (seat.stance === "challenge" && seat.challenge && draft === final) {
-      issue(
-        issues,
-        "roundtable_unaddressed",
-        `${seat.pack} challenged the draft but the final plan is unchanged.`,
-        "advisory"
-      );
-    }
   }
-  const allSupport = input.roundtable.seats.length > 0 && input.roundtable.seats.every((seat) => seat.stance === "support");
-  if (allSupport && input.roundtable.exec.pre_mortem) {
+  if (input.roundtable.pre_mortem) {
     const defensiveText = JSON.stringify({
       risks: input.finalPlan.risks,
       assumptions: input.finalPlan.assumptions,
       contingencies: input.finalPlan.workstreams.map((ws) => ws.contingency)
     }).toLowerCase();
-    const tokens = significantTokens(input.roundtable.exec.pre_mortem);
+    const tokens = significantTokens(input.roundtable.pre_mortem);
     if (tokens.length > 0 && !tokens.some((token) => defensiveText.includes(token))) {
-      issue(
+      pushIssue(
         issues,
-        "roundtable_premortem_missing",
-        "Final risks and contingencies do not reflect exec.pre_mortem.",
+        "consultant_premortem_missing",
+        "Final risks and contingencies do not reflect pre_mortem.",
         "advisory"
       );
     }
   }
   return { issues, blocking: false };
 }
-var FUNCTION_PACKS, STANCES;
+var BANNED_SPEAKER_PATTERNS;
 var init_roundtable_validate = __esm({
   "src/ai/roundtable-validate.ts"() {
     "use strict";
-    init_gtm_counsel();
     init_strategist_validate();
-    FUNCTION_PACKS = new Set(
-      listCounselPackIds().filter(
-        (id) => id !== "counsel_exec"
-      )
-    );
-    STANCES = /* @__PURE__ */ new Set(["support", "challenge", "abstain"]);
+    BANNED_SPEAKER_PATTERNS = [
+      /\bCRO\s+says\b/i,
+      /\bCMO\s+says\b/i,
+      /\bCS\s+says\b/i,
+      /\bsales\s+says\b/i,
+      /\bfrom a marketing lens\b/i,
+      /\bfrom a sales lens\b/i,
+      /\bcounsel_sales\b/,
+      /\bcounsel_marketing\b/,
+      /\bcounsel_revops\b/,
+      /\bcounsel_cs\b/,
+      /\bcounsel_exec\b/
+    ];
   }
 });
 
@@ -23077,9 +22811,7 @@ ${STRATEGIST_PLAN_SCHEMA_BLOCK}`
   const observeRoundtableTool = (name, args) => {
     if (name !== "get_counsel_detail") return;
     const counselId = typeof args.counsel_id === "string" ? args.counsel_id : "";
-    if (["counsel_sales", "counsel_marketing", "counsel_revops", "counsel_exec", "counsel_cs"].includes(
-      counselId
-    )) {
+    if (counselId === "counsel_gtm") {
       counselPulls.add(counselId);
     }
   };
@@ -23099,7 +22831,7 @@ ${STRATEGIST_PLAN_SCHEMA_BLOCK}`
   const roundtableText = yield* runStage(
     "strategist",
     ROUNDTABLE_MAX_ROUNDS,
-    "Tool budget reached for roundtable. Respond with the roundtable JSON now \u2014 strict JSON only.",
+    "Tool budget reached for the plan check. Respond with the plan-check JSON now \u2014 strict JSON only.",
     true,
     observeRoundtableTool
   );
@@ -23117,7 +22849,7 @@ ${STRATEGIST_PLAN_SCHEMA_BLOCK}`
     const retryText = yield* runStage(
       "strategist",
       2,
-      "Respond with ONLY corrected roundtable JSON now. No prose.",
+      "Respond with ONLY corrected plan-check JSON now. No prose.",
       true,
       observeRoundtableTool
     );
@@ -23132,13 +22864,13 @@ ${STRATEGIST_PLAN_SCHEMA_BLOCK}`
   const roundtableIssues = [...roundtableValidation.issues];
   let roundtableDigest = roundtableResult ? formatRoundtableDigestFromResult(roundtableResult) : "";
   if (!roundtableResult) {
-    roundtableDigest = "(Roundtable JSON failed structural validation \u2014 Stage C must run a pre-mortem, preserve both constraint channels, and avoid rubber-stamping the draft.)";
+    roundtableDigest = "Plan check didn't land. Stress-testing still runs.";
     yield {
       type: "notice",
-      text: `Roundtable validation failed: ${roundtableValidation.issues.filter((entry) => entry.severity === "blocking").map((entry) => entry.code).join(", ") || "unknown shape"}.`
+      text: "Plan check didn't land. Stress-testing still runs."
     };
   } else {
-    yield { type: "notice", text: "Roundtable counsel captured \u2014 feeding into stress test." };
+    yield { type: "notice", text: "Recommendation locked. Stress-testing next." };
   }
   yield { type: "stage", stage: "stress", label: STAGE_LABELS.stress };
   messages.push({ role: "user", content: buildStressTestMessage(roundtableDigest) });
@@ -23176,8 +22908,8 @@ Respond with ONLY the corrected plan JSON object in the required schema (title,
       text: "Strategist JSON failed validation \u2014 emitting grounded fallback plan from live vitals."
     };
   }
-  for (const issue2 of validated.issues) {
-    yield { type: "notice", text: issue2 };
+  for (const issue of validated.issues) {
+    yield { type: "notice", text: issue };
   }
   if (roundtableResult && candidatePlan) {
     const reflection = checkRoundtableReflection({
@@ -23187,10 +22919,6 @@ Respond with ONLY the corrected plan JSON object in the required schema (title,
     });
     for (const reflectionIssue of reflection.issues) {
       roundtableIssues.push(reflectionIssue);
-      yield {
-        type: "notice",
-        text: `Counsel reflection (${reflectionIssue.code}): ${reflectionIssue.message}`
-      };
     }
   }
   yield {
@@ -23299,7 +23027,7 @@ var init_strategist2 = __esm({
     STAGE_LABELS = {
       ground: "Grounding \u2014 reading health, metrics, segments, history",
       backcast: "Sequencing \u2014 backcasting from objective",
-      roundtable: "Roundtable \u2014 sales, marketing, RevOps, CS, exec counsel",
+      roundtable: "Checking the plan",
       stress: "Stress-testing \u2014 capacity, measurability, timeline"
     };
   }
@@ -23331,6 +23059,10 @@ function recordScoreStreak(job, score) {
   }
   job.last_critic_score = score;
 }
+function formatBlockingGapForUser(gap) {
+  if (gap.code === "roundtable_invalid") return "Plan check didn't land.";
+  return `Plan gap (${gap.code}): ${gap.note}`;
+}
 async function* strategistCraftSession(options) {
   assertReplAi(options.ctx);
   const todayIso = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -23373,8 +23105,8 @@ async function* strategistCraftSession(options) {
       const gap = {
         code: "roundtable_invalid",
         severity: "blocking",
-        note: !job.roundtable ? "No validated counsel roundtable is attached to this plan." : job.roundtable.counsel_fingerprint !== currentFingerprint ? "The latest counsel roundtable is stale for the current plan." : "The latest counsel roundtable failed structural validation.",
-        fix: "Re-run Stage R with every seated pack, required counsel pulls, and a valid exec merge."
+        note: !job.roundtable ? "No validated plan check is attached to this plan." : job.roundtable.counsel_fingerprint !== currentFingerprint ? "The latest plan check is stale for the current plan." : "The latest plan check failed structural validation.",
+        fix: "Re-run the plan check until it lands a single consultant recommendation with a pre-mortem."
       };
       scored.gaps.push(gap);
       scored.blocking.push(gap);
@@ -23452,7 +23184,7 @@ async function* strategistCraftSession(options) {
           };
           const rubric = scorePlan(locked);
           job.rubric_gaps = rubric.gaps;
-          yield { ...event, plan: locked, issues: [...event.issues, ...rubric.blocking.map((g) => `Plan gap (${g.code}): ${g.note}`)] };
+          yield { ...event, plan: locked, issues: [...event.issues, ...rubric.blocking.map(formatBlockingGapForUser)] };
         } else if (event.type === "done") {
           lastMeta = event.usage ?? lastMeta;
           job.cumulative_input_tokens += event.usage?.input_tokens ?? 0;
@@ -23522,7 +23254,7 @@ async function* strategistCraftSession(options) {
           planJson: JSON.stringify(plan),
           rubricGaps: [
             rubric.blocking.map((g) => `${g.code}: ${g.note}`).join("\n") || "(none)",
-            lastRoundtableDigest ? `ROUNDTABLE DIGEST (address or reject with instruments):
+            lastRoundtableDigest ? `PLAN CHECK DIGEST (address or reject with instruments):
 ${lastRoundtableDigest}` : ""
           ].filter(Boolean).join("\n\n"),
           healthSnapshot
@@ -23634,7 +23366,7 @@ ${lastRoundtableDigest}` : ""
         if (nextFp !== lastCounselFp) {
           yield {
             type: "notice",
-            text: "Plan plays/constraints shifted \u2014 re-running counsel roundtable pass."
+            text: "Plan shifted. Checking the plan again."
           };
           try {
             const profile = loadProfile();
@@ -23712,7 +23444,7 @@ ${lastRoundtableDigest}` : ""
               requireCounselPulls: false
             });
             const result = validation.blocking ? null : validation.result;
-            lastRoundtableDigest = result ? formatRoundtableDigestFromResult(result) : "(Craft counsel re-entry failed structural validation; critic must not ship until Stage R is valid.)";
+            lastRoundtableDigest = result ? formatRoundtableDigestFromResult(result) : "Plan check didn't land.";
             const record = {
               seating,
               result,
@@ -23728,7 +23460,7 @@ ${lastRoundtableDigest}` : ""
               lastCounselFp = "";
               yield {
                 type: "notice",
-                text: `Craft roundtable invalid: ${validation.issues.filter((entry) => entry.severity === "blocking").map((entry) => entry.code).join(", ")}.`
+                text: "Plan check didn't land."
               };
             } else {
               lastCounselFp = nextFp;
@@ -23755,7 +23487,7 @@ ${lastRoundtableDigest}` : ""
             }
             yield {
               type: "notice",
-              text: `Craft roundtable re-entry failed: ${String(err.message ?? err)}.`
+              text: "Plan check didn't land."
             };
           }
         }
@@ -23776,7 +23508,7 @@ ${lastRoundtableDigest}` : ""
       yield {
         type: "plan",
         plan: job.plan,
-        issues: rubric.blocking.map((g) => `Plan gap (${g.code}): ${g.note}`),
+        issues: rubric.blocking.map(formatBlockingGapForUser),
         measurable_targets: measurable.measurable_targets,
         total_targets: measurable.total_targets,
         baseline_batch_id: options.baselineBatchId ?? null
@@ -23873,12 +23605,6 @@ function renderCraftHandoffMarkdown(opts) {
     lines.push(formatWorkstreamMarkdown(ws).trimEnd());
     lines.push("");
   }
-  if (opts.roundtableDigest) {
-    lines.push("## Counsel roundtable");
-    lines.push("");
-    lines.push(opts.roundtableDigest);
-    lines.push("");
-  }
   const risks = filterOperatorLines(plan.risks);
   if (risks.length > 0) {
     lines.push("## Risks");
@@ -24922,8 +24648,8 @@ var init_ghost_hints = __esm({
     PHASE_GHOST_HINTS = {
       orient: [
         'try "pipeline health"',
-        "try /deepdive",
-        "try /deepdive guide",
+        "try /tour",
+        "try /tour guide",
         'try "is our retention real for the board?"',
         'try "what is the most expensive problem to solve?"',
         'try "board deck on Q3"'
@@ -24940,7 +24666,7 @@ var init_ghost_hints = __esm({
         'try "how should we fix this?"',
         'try "which segment is weakest?"',
         'try "what is ARR?"',
-        "try /deepdive freshness",
+        "try /tour freshness",
         'try "ship a board deck"'
       ]
     };
@@ -24999,7 +24725,7 @@ function buildSituationalAwarenessBlock(ctx, opts = {}) {
       "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"
+      "Available now: answer from the artifact; suggest at most one of /strategy, /handoff, /tour <metric>, /thinkwithme, /playbook"
     );
     if (channel === "explore" && responseMode === "deep") {
       lines.push(
@@ -25662,7 +25388,7 @@ function tryKeylessDefinitionAnswer(ctx, input) {
   }
   console.log();
   console.log(
-    "  " + chalk23.dim("More: ") + paint("accent", `/deepdive ${explainer.id}`) + chalk23.dim(" \xB7 full tour: ") + paint("accent", "/deepdive")
+    "  " + chalk23.dim("More: ") + paint("accent", `/tour ${explainer.id}`) + chalk23.dim(" \xB7 full tour: ") + paint("accent", "/tour")
   );
   console.log();
   recordMessage(ctx, "user", input);
@@ -25739,7 +25465,7 @@ async function handleExploreWithoutKey(ctx, input) {
   console.log();
   console.log("  " + chalk24.yellow("No key is connected. Q&A stays off until you type ") + paint("accent", "/connect") + chalk24.yellow("."));
   console.log("  " + chalk24.dim("These commands work without a key:"));
-  console.log("    " + paint("accent", "/deepdive") + chalk24.dim("                   slides for numbers and how to use NTRP"));
+  console.log("    " + paint("accent", "/tour") + chalk24.dim("                   slides for numbers and how to use NTRP"));
   console.log("    " + paint("accent", "/playbook") + chalk24.dim("                    recommended plays from your computed vitals"));
   console.log("    " + chalk24.cyan('"how should we fix this?"') + chalk24.dim("    a simple plan. No AI."));
   console.log("    " + paint("accent", "/handoff") + chalk24.dim("                     write this analysis for another tool"));
@@ -25747,7 +25473,7 @@ async function handleExploreWithoutKey(ctx, input) {
   recordMessage(
     ctx,
     "agent",
-    "No key is connected. Offered paths without a key (/deepdive, /playbook, simple plan, /handoff)."
+    "No key is connected. Offered paths without a key (/tour, /playbook, simple plan, /handoff)."
   );
 }
 var NO_KEY_NUDGES;
@@ -26395,6 +26121,7 @@ var init_smoke_protocol = __esm({
 // src/cli/nl.ts
 var nl_exports = {};
 __export(nl_exports, {
+  runExploreExpandAnswer: () => runExploreExpandAnswer,
   runNaturalLanguage: () => runNaturalLanguage
 });
 import chalk25 from "chalk";
@@ -26402,16 +26129,16 @@ async function runNaturalLanguage(input, ctx) {
   if (isSmokeProtocolTrigger(input)) {
     recordMessage(ctx, "user", input);
     console.log();
-    const spinner2 = makeSpinner("Running smoke protocol\u2026");
+    const spinner = makeSpinner("Running smoke protocol\u2026");
     try {
       const result = await runSmokeProtocol(input, ctx);
-      spinner2.succeed("Smoke protocol complete");
+      spinner.succeed("Smoke protocol complete");
       printAnswer(result.answer);
       recordMessage(ctx, "agent", result.answer);
       console.log();
       return extractSummary2(result.answer);
     } catch (err) {
-      spinner2.fail("Smoke protocol failed");
+      spinner.fail("Smoke protocol failed");
       console.error("  " + chalk25.red(String(err.message ?? err)));
       console.log();
       return;
@@ -26426,6 +26153,22 @@ async function runNaturalLanguage(input, ctx) {
     return;
   }
   recordMessage(ctx, "user", input);
+  const responseMode = resolveExploreResponseMode(input, ctx, ctx.conversation.length);
+  return runExploreAgent(ctx, {
+    userQuestion: input,
+    responseMode,
+    showExpandHint: responseMode === "brief"
+  });
+}
+async function runExploreExpandAnswer(ctx, question) {
+  return runExploreAgent(ctx, {
+    userQuestion: question,
+    responseMode: "deep",
+    showExpandHint: false
+  });
+}
+async function runExploreAgent(ctx, opts) {
+  const { userQuestion, responseMode, showExpandHint } = opts;
   let snapshot = ctx.snapshot.computeResult;
   if (!snapshot) {
     const metricsFirst = prefersMetricsFirstContext(ctx);
@@ -26442,7 +26185,7 @@ async function runNaturalLanguage(input, ctx) {
     }
   }
   console.log();
-  const memoryBlock = await buildMemoryBlock(input).catch((err) => {
+  const memoryBlock = await buildMemoryBlock(userQuestion).catch((err) => {
     debugError("nl.buildMemoryBlock", err);
     return "";
   });
@@ -26453,13 +26196,12 @@ async function runNaturalLanguage(input, ctx) {
   setAgentContext(ctx);
   try {
     const analysisBlock = buildAnalysisBlock(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) : "";
     for await (const event of agenticFindings(snapshot, ctx.snapshot.divergences, {
       mode: "fresh",
-      userQuestion: input,
+      userQuestion,
       sessionContext: ctx.resumedSessionSummary,
       includeMetrics: true,
       analysisBlock,
@@ -26500,7 +26242,7 @@ async function runNaturalLanguage(input, ctx) {
     const { isLlmAuthError: isLlmAuthError2 } = await Promise.resolve().then(() => (init_errors2(), errors_exports));
     if (isLlmAuthError2(err)) {
       const { queuePendingAsk: queuePendingAsk2 } = await Promise.resolve().then(() => (init_pending_ask(), pending_ask_exports));
-      if (!ctx.pendingAsk) queuePendingAsk2(ctx, input, "explore");
+      if (!ctx.pendingAsk) queuePendingAsk2(ctx, userQuestion, "explore");
       const { recoverFromAuthFailure: recoverFromAuthFailure2 } = await Promise.resolve().then(() => (init_auth_recovery(), auth_recovery_exports));
       await recoverFromAuthFailure2(ctx, err);
       return;
@@ -26525,8 +26267,18 @@ async function runNaturalLanguage(input, ctx) {
       saveSessionState(ctx);
     }
     creditNlAnswer(ctx, Math.floor(ctx.messages.length / 2));
-    recordAnalysis({ question: input, answer: lastAnswer, tools: toolsUsed, session_id: ctx.sessionId });
-    ctx.lastExchange = { question: input, answer: lastAnswer };
+    recordAnalysis({
+      question: userQuestion,
+      answer: lastAnswer,
+      tools: toolsUsed,
+      session_id: ctx.sessionId
+    });
+    ctx.lastExchange = { question: userQuestion, answer: lastAnswer, mode: responseMode };
+    if (showExpandHint) {
+      console.log(
+        "  " + chalk25.dim("Type ") + chalk25.cyan("expand") + chalk25.dim(" for more reasoning.")
+      );
+    }
   }
   console.log();
   const { promptQueuedAiStrategist: promptQueuedAiStrategist2 } = await Promise.resolve().then(() => (init_strategist_flow(), strategist_flow_exports));
@@ -26553,7 +26305,7 @@ function printFindingInline2(finding) {
   if (play) console.log("  " + chalk25.dim("\u2192 " + play.play_name + " \u2014 " + play.rationale));
   if (finding.recommended_focus) {
     console.log(
-      "  " + chalk25.dim("How this works: ") + paint("accent", `/deepdive ${finding.recommended_focus}`)
+      "  " + chalk25.dim("How this works: ") + paint("accent", `/tour ${finding.recommended_focus}`)
     );
   }
 }
@@ -31177,8 +30929,8 @@ var init_diagnose = __esm({
 function summarizeEntityDetails(details = []) {
   const summary = {};
   for (const detail of details) {
-    const issue2 = typeof detail.issue === "string" ? detail.issue : "unclassified";
-    summary[issue2] = (summary[issue2] ?? 0) + 1;
+    const issue = typeof detail.issue === "string" ? detail.issue : "unclassified";
+    summary[issue] = (summary[issue] ?? 0) + 1;
   }
   return summary;
 }
@@ -31658,8 +31410,8 @@ async function handleGetVitalSignDetail(input, ctx) {
   if (!vital) return { error: `Vital sign '${vitalSign}' not found` };
   const entitySummary = {};
   for (const detail of vital.entity_details) {
-    const issue2 = detail.issue;
-    const key = issue2 ?? "unclassified";
+    const issue = detail.issue;
+    const key = issue ?? "unclassified";
     entitySummary[key] = (entitySummary[key] ?? 0) + 1;
   }
   return {
@@ -31974,27 +31726,6 @@ async function handleGetCounselDetail(input) {
   }
   return formatCounselDetail2(pack, getActiveOrgTree2());
 }
-async function handleGetRoleCard(input) {
-  const roleId = typeof input.role_id === "string" ? input.role_id.trim() : "";
-  const {
-    getRoleCardById: getRoleCardById2,
-    listRoleCardIds: listRoleCardIds2,
-    formatRoleCardDetail: formatRoleCardDetail2,
-    getActiveOrgTree: getActiveOrgTree2,
-    listOrgTreeIds: listOrgTreeIds2
-  } = await Promise.resolve().then(() => (init_gtm_counsel(), gtm_counsel_exports));
-  const card = roleId ? getRoleCardById2(roleId) : void 0;
-  if (!card) {
-    return {
-      error: `Unknown role id '${roleId}'.`,
-      valid_role_ids: listRoleCardIds2()
-    };
-  }
-  const treeArg = typeof input.org_tree === "string" ? input.org_tree.trim() : "";
-  const trees = listOrgTreeIds2();
-  const tree = trees.includes(treeArg) ? treeArg : getActiveOrgTree2();
-  return formatRoleCardDetail2(card, tree);
-}
 async function handleGetRevenueMetrics(_input, ctx) {
   if (!ctx.metrics || ctx.metrics.length === 0) {
     const { computeFullMetrics: computeFullMetrics2 } = await Promise.resolve().then(() => (init_compute(), compute_exports));
@@ -32291,7 +32022,6 @@ var init_tool_handlers = __esm({
       get_play_detail: (input, _) => handleGetPlayDetail(input),
       get_framework_detail: (input, _) => handleGetFrameworkDetail(input),
       get_counsel_detail: (input, _) => handleGetCounselDetail(input),
-      get_role_card: (input, _) => handleGetRoleCard(input),
       get_session_brief: (input, _) => handleGetSessionBrief(input),
       get_revenue_metrics: handleGetRevenueMetrics,
       get_revenue_metrics_timeseries: (input, _) => handleGetRevenueMetricsTimeseries(input),