@sonnechasser/ntrp 0.2.2 → 0.2.3

package/dist/strategist/strategist-smoke.js

@@ -0,0 +1,1775 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/ai/llm/thread-compat.ts
+var init_thread_compat = __esm({
+  "src/ai/llm/thread-compat.ts"() {
+    "use strict";
+  }
+});
+
+// src/io/context.ts
+var init_context = __esm({
+  "src/io/context.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/context.ts
+import { basename, join, resolve, sep } from "path";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, statSync, rmSync } from "fs";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+function isAnalysisReady(ctx) {
+  if (ctx.stage !== "analyzed" || ctx.analysis.completed.length === 0) return false;
+  if (!ctx.dataset) return false;
+  const counts = ctx.dataset.counts ?? {};
+  return Object.values(counts).some((n) => n > 0);
+}
+function defaultSessionAnalysis(primary = "gtm_health") {
+  return { primary, completed: [] };
+}
+var init_context2 = __esm({
+  "src/cli/context.ts"() {
+    "use strict";
+    init_thread_compat();
+    init_context();
+  }
+});
+
+// src/config/store.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, resolve as resolve2 } from "path";
+function ntrpHome() {
+  return NTRP_DIR;
+}
+function getMemoryDir() {
+  const dir = join2(NTRP_DIR, "memory");
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  return dir;
+}
+var NTRP_DIR, CONFIG_PATH;
+var init_store = __esm({
+  "src/config/store.ts"() {
+    "use strict";
+    NTRP_DIR = process.env.NTRP_HOME ? resolve2(process.env.NTRP_HOME) : join2(homedir2(), ".ntrp");
+    CONFIG_PATH = join2(NTRP_DIR, "config.json");
+  }
+});
+
+// src/config/profile.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
+var NTRP_DIR2, PROFILE_PATH;
+var init_profile = __esm({
+  "src/config/profile.ts"() {
+    "use strict";
+    init_store();
+    NTRP_DIR2 = ntrpHome();
+    PROFILE_PATH = join3(NTRP_DIR2, "profile.json");
+  }
+});
+
+// src/db/connection.ts
+import { dirname, join as join4, resolve as resolve3 } from "path";
+var NTRP_DIR3, DEFAULT_DB_PATH, DB_PATH_PINNED;
+var init_connection = __esm({
+  "src/db/connection.ts"() {
+    "use strict";
+    NTRP_DIR3 = process.env.NTRP_HOME ? resolve3(process.env.NTRP_HOME) : join4(process.env.HOME ?? "", ".ntrp");
+    DEFAULT_DB_PATH = process.env.NTRP_DB_PATH ? resolve3(process.env.NTRP_DB_PATH) : join4(NTRP_DIR3, "ntrp.duckdb");
+    DB_PATH_PINNED = !!process.env.NTRP_DB_PATH;
+  }
+});
+
+// src/output/formatters.ts
+var init_formatters = __esm({
+  "src/output/formatters.ts"() {
+    "use strict";
+  }
+});
+
+// src/db/queries.ts
+var init_queries = __esm({
+  "src/db/queries.ts"() {
+    "use strict";
+    init_connection();
+    init_formatters();
+    init_connection();
+  }
+});
+
+// src/ui/theme.ts
+import chalk from "chalk";
+var init_theme = __esm({
+  "src/ui/theme.ts"() {
+    "use strict";
+    init_formatters();
+  }
+});
+
+// src/services/session-analysis.ts
+var init_session_analysis = __esm({
+  "src/services/session-analysis.ts"() {
+    "use strict";
+    init_queries();
+    init_profile();
+    init_formatters();
+    init_theme();
+  }
+});
+
+// src/conversation/handoff-draft.ts
+function isShipIntent(input) {
+  const line = input.trim();
+  if (/\?\s*$/.test(line) || QUESTION_LEAD_RE.test(line)) return false;
+  return SHIP_INTENT_RE.test(line);
+}
+var QUESTION_LEAD_RE, SHIP_INTENT_RE;
+var init_handoff_draft = __esm({
+  "src/conversation/handoff-draft.ts"() {
+    "use strict";
+    init_profile();
+    init_session_analysis();
+    QUESTION_LEAD_RE = /^\s*(what|why|how|when|where|who|which|is|are|was|were|do|does|did|explain|tell me|help me understand)\b/i;
+    SHIP_INTENT_RE = /\b(ship|export|deliver|write[- ]?up|board memo|action plan|turn (this|it|that) into|(draft|create|make|build|prepare|generate|send)\s+(me\s+)?(a\s+|the\s+)?hand[- ]?off|hand[- ]?off\s+(prompt|doc|document|plan))\b/i;
+  }
+});
+
+// src/ai/llm/providers.ts
+var init_providers = __esm({
+  "src/ai/llm/providers.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// src/config/llm-config.ts
+var init_llm_config = __esm({
+  "src/config/llm-config.ts"() {
+    "use strict";
+    init_providers();
+    init_store();
+  }
+});
+
+// src/ai/llm/gate.ts
+var init_gate = __esm({
+  "src/ai/llm/gate.ts"() {
+    "use strict";
+    init_llm_config();
+  }
+});
+
+// src/ai/repl-api.ts
+var init_repl_api = __esm({
+  "src/ai/repl-api.ts"() {
+    "use strict";
+    init_gate();
+  }
+});
+
+// src/cli/repl-globals.ts
+var init_repl_globals = __esm({
+  "src/cli/repl-globals.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/prompts.ts
+import { createInterface } from "readline/promises";
+import { clearLine, cursorTo } from "readline";
+import chalk2 from "chalk";
+var init_prompts = __esm({
+  "src/cli/prompts.ts"() {
+    "use strict";
+    init_repl_globals();
+    init_theme();
+  }
+});
+
+// src/pipeline/segments.ts
+var init_segments = __esm({
+  "src/pipeline/segments.ts"() {
+    "use strict";
+    init_connection();
+    init_queries();
+  }
+});
+
+// src/baselines/defaults.ts
+var init_defaults = __esm({
+  "src/baselines/defaults.ts"() {
+    "use strict";
+  }
+});
+
+// src/baselines/profile-presets.ts
+var init_profile_presets = __esm({
+  "src/baselines/profile-presets.ts"() {
+    "use strict";
+  }
+});
+
+// src/baselines/resolve.ts
+var init_resolve = __esm({
+  "src/baselines/resolve.ts"() {
+    "use strict";
+    init_defaults();
+    init_profile_presets();
+  }
+});
+
+// src/vitals/shared.ts
+var init_shared = __esm({
+  "src/vitals/shared.ts"() {
+    "use strict";
+  }
+});
+
+// src/vitals/freshness.ts
+var init_freshness = __esm({
+  "src/vitals/freshness.ts"() {
+    "use strict";
+    init_defaults();
+    init_shared();
+  }
+});
+
+// src/vitals/flow-rate.ts
+var init_flow_rate = __esm({
+  "src/vitals/flow-rate.ts"() {
+    "use strict";
+    init_defaults();
+    init_shared();
+  }
+});
+
+// src/vitals/drop-rate.ts
+var init_drop_rate = __esm({
+  "src/vitals/drop-rate.ts"() {
+    "use strict";
+    init_defaults();
+    init_shared();
+  }
+});
+
+// src/vitals/signal-to-noise.ts
+var init_signal_to_noise = __esm({
+  "src/vitals/signal-to-noise.ts"() {
+    "use strict";
+    init_defaults();
+    init_store();
+    init_shared();
+  }
+});
+
+// src/vitals/thread-depth.ts
+var init_thread_depth = __esm({
+  "src/vitals/thread-depth.ts"() {
+    "use strict";
+    init_defaults();
+    init_shared();
+  }
+});
+
+// src/vitals/health-score.ts
+var LAYERS;
+var init_health_score = __esm({
+  "src/vitals/health-score.ts"() {
+    "use strict";
+    init_segments();
+    init_resolve();
+    init_freshness();
+    init_flow_rate();
+    init_drop_rate();
+    init_signal_to_noise();
+    init_thread_depth();
+    init_connection();
+    init_queries();
+    LAYERS = [
+      { layer: 1, signs: ["freshness"] },
+      { layer: 2, signs: ["flow_rate", "drop_rate"] },
+      { layer: 3, signs: ["signal_to_noise"] },
+      { layer: 4, signs: ["thread_depth"] }
+    ];
+  }
+});
+
+// src/pipeline/divergence.ts
+var init_divergence = __esm({
+  "src/pipeline/divergence.ts"() {
+    "use strict";
+  }
+});
+
+// src/db/schema.ts
+var init_schema = __esm({
+  "src/db/schema.ts"() {
+    "use strict";
+    init_connection();
+  }
+});
+
+// src/baselines/metrics-benchmarks.ts
+var init_metrics_benchmarks = __esm({
+  "src/baselines/metrics-benchmarks.ts"() {
+    "use strict";
+  }
+});
+
+// src/metrics/classify-source.ts
+var init_classify_source = __esm({
+  "src/metrics/classify-source.ts"() {
+    "use strict";
+  }
+});
+
+// src/metrics/helpers.ts
+var init_helpers = __esm({
+  "src/metrics/helpers.ts"() {
+    "use strict";
+    init_metrics_benchmarks();
+  }
+});
+
+// src/metrics/coverage.ts
+var init_coverage = __esm({
+  "src/metrics/coverage.ts"() {
+    "use strict";
+    init_helpers();
+    init_classify_source();
+  }
+});
+
+// src/metrics/context.ts
+var init_context3 = __esm({
+  "src/metrics/context.ts"() {
+    "use strict";
+    init_metrics_benchmarks();
+    init_profile();
+    init_health_score();
+    init_queries();
+    init_classify_source();
+    init_coverage();
+  }
+});
+
+// src/metrics/revenue.ts
+var init_revenue = __esm({
+  "src/metrics/revenue.ts"() {
+    "use strict";
+    init_helpers();
+    init_formatters();
+  }
+});
+
+// src/metrics/retention.ts
+var init_retention = __esm({
+  "src/metrics/retention.ts"() {
+    "use strict";
+    init_revenue();
+    init_helpers();
+    init_metrics_benchmarks();
+  }
+});
+
+// src/metrics/pipeline.ts
+var init_pipeline = __esm({
+  "src/metrics/pipeline.ts"() {
+    "use strict";
+    init_helpers();
+    init_formatters();
+    init_metrics_benchmarks();
+  }
+});
+
+// src/metrics/sales-efficiency.ts
+var init_sales_efficiency = __esm({
+  "src/metrics/sales-efficiency.ts"() {
+    "use strict";
+    init_helpers();
+    init_formatters();
+    init_metrics_benchmarks();
+  }
+});
+
+// src/metrics/unit-economics.ts
+var init_unit_economics = __esm({
+  "src/metrics/unit-economics.ts"() {
+    "use strict";
+    init_formatters();
+  }
+});
+
+// src/metrics/confidence.ts
+var init_confidence = __esm({
+  "src/metrics/confidence.ts"() {
+    "use strict";
+  }
+});
+
+// src/metrics/periods.ts
+var init_periods = __esm({
+  "src/metrics/periods.ts"() {
+    "use strict";
+    init_helpers();
+  }
+});
+
+// src/metrics/compute.ts
+var init_compute = __esm({
+  "src/metrics/compute.ts"() {
+    "use strict";
+    init_segments();
+    init_queries();
+    init_context3();
+    init_revenue();
+    init_retention();
+    init_pipeline();
+    init_sales_efficiency();
+    init_unit_economics();
+    init_confidence();
+    init_periods();
+    init_context3();
+  }
+});
+
+// src/metrics/insights.ts
+var init_insights = __esm({
+  "src/metrics/insights.ts"() {
+    "use strict";
+    init_coverage();
+  }
+});
+
+// src/ai/llm/models-cache.ts
+var CACHE_TTL_MS;
+var init_models_cache = __esm({
+  "src/ai/llm/models-cache.ts"() {
+    "use strict";
+    init_store();
+    CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/ai/llm/catalog.ts
+var ENTRIES, byId;
+var init_catalog = __esm({
+  "src/ai/llm/catalog.ts"() {
+    "use strict";
+    init_models_cache();
+    ENTRIES = [
+      {
+        id: "claude-opus-4-6",
+        provider: "anthropic",
+        tier: "high",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 2e5,
+        display_name: "Claude Opus 4.6",
+        relative_cost: 3
+      },
+      {
+        id: "claude-sonnet-4-5-20250929",
+        provider: "anthropic",
+        tier: "medium",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 2e5,
+        display_name: "Claude Sonnet 4.5",
+        relative_cost: 2
+      },
+      {
+        id: "claude-haiku-4-5-20251001",
+        provider: "anthropic",
+        tier: "low",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 2e5,
+        display_name: "Claude Haiku 4.5",
+        relative_cost: 1
+      },
+      {
+        id: "gpt-4.1",
+        provider: "openai",
+        tier: "high",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 1047576,
+        display_name: "GPT-4.1",
+        relative_cost: 3
+      },
+      {
+        id: "gpt-4.1-mini",
+        provider: "openai",
+        tier: "medium",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 1047576,
+        display_name: "GPT-4.1 Mini",
+        relative_cost: 2
+      },
+      {
+        id: "gpt-4.1-nano",
+        provider: "openai",
+        tier: "low",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 1047576,
+        display_name: "GPT-4.1 Nano",
+        relative_cost: 1
+      }
+    ];
+    byId = new Map(ENTRIES.map((e) => [e.id, e]));
+  }
+});
+
+// src/ai/llm/surfaces.ts
+var init_surfaces = __esm({
+  "src/ai/llm/surfaces.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/llm/session-state.ts
+var init_session_state = __esm({
+  "src/ai/llm/session-state.ts"() {
+    "use strict";
+    init_llm_config();
+    init_catalog();
+    init_surfaces();
+  }
+});
+
+// src/conversation/phase.ts
+import chalk3 from "chalk";
+function sessionHasData(ctx) {
+  const counts = ctx.dataset?.counts ?? {};
+  return Object.values(counts).some((n) => (n ?? 0) > 0);
+}
+function resolveConversationPhase(ctx) {
+  if (ctx.deliverIntent) return "deliver";
+  if (ctx.computeInProgress) return "compute";
+  if (ctx.strategistState && ctx.strategistState.step !== "awaiting_analysis") {
+    return "strategize";
+  }
+  if (isAnalysisReady(ctx)) return "explore";
+  const scope = ctx.scope;
+  if (scope?.confirmed_at) {
+    if (!sessionHasData(ctx)) return "awaiting_data";
+    if (ctx.stage !== "analyzed") return "awaiting_data";
+  }
+  if (scope?.intent_summary && !scope.confirmed_at) return "scope";
+  return "orient";
+}
+var init_phase = __esm({
+  "src/conversation/phase.ts"() {
+    "use strict";
+    init_context2();
+    init_session_state();
+    init_theme();
+  }
+});
+
+// src/conversation/gap-audit.ts
+var init_gap_audit = __esm({
+  "src/conversation/gap-audit.ts"() {
+    "use strict";
+    init_connection();
+    init_queries();
+    init_profile();
+    init_compute();
+    init_insights();
+    init_phase();
+  }
+});
+
+// src/strategies/library.ts
+import { writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
+import { stringify as stringifyYaml } from "yaml";
+var init_library = __esm({
+  "src/strategies/library.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// src/io/types.ts
+var init_types = __esm({
+  "src/io/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/io/errors.ts
+var init_errors = __esm({
+  "src/io/errors.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/services/strategist.ts
+import { createHash } from "crypto";
+var init_strategist = __esm({
+  "src/services/strategist.ts"() {
+    "use strict";
+    init_schema();
+    init_queries();
+    init_health_score();
+    init_divergence();
+    init_gap_audit();
+    init_library();
+    init_errors();
+    init_types();
+    init_formatters();
+    init_formatters();
+  }
+});
+
+// src/config/install.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { join as join6 } from "path";
+var init_install = __esm({
+  "src/config/install.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// src/config/progress-migrate.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync6 } from "fs";
+import { join as join7 } from "path";
+var init_progress_migrate = __esm({
+  "src/config/progress-migrate.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// src/whimsy/usage-backfill.ts
+var init_usage_backfill = __esm({
+  "src/whimsy/usage-backfill.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/progress.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
+import { join as join8 } from "path";
+var init_progress = __esm({
+  "src/config/progress.ts"() {
+    "use strict";
+    init_install();
+    init_progress_migrate();
+    init_store();
+    init_usage_backfill();
+  }
+});
+
+// src/whimsy/usage-stats.ts
+var init_usage_stats = __esm({
+  "src/whimsy/usage-stats.ts"() {
+    "use strict";
+    init_progress();
+  }
+});
+
+// src/ai/llm/types.ts
+var init_types2 = __esm({
+  "src/ai/llm/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/llm/errors.ts
+var init_errors2 = __esm({
+  "src/ai/llm/errors.ts"() {
+    "use strict";
+    init_types2();
+  }
+});
+
+// src/ai/llm/adapters/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var init_anthropic = __esm({
+  "src/ai/llm/adapters/anthropic.ts"() {
+    "use strict";
+    init_errors2();
+  }
+});
+
+// src/ai/llm/adapters/openai-compat.ts
+import OpenAI from "openai";
+var init_openai_compat = __esm({
+  "src/ai/llm/adapters/openai-compat.ts"() {
+    "use strict";
+    init_errors2();
+  }
+});
+
+// src/ai/llm/http.ts
+var init_http = __esm({
+  "src/ai/llm/http.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/llm/ranking.ts
+var init_ranking = __esm({
+  "src/ai/llm/ranking.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/llm/discovery.ts
+var init_discovery = __esm({
+  "src/ai/llm/discovery.ts"() {
+    "use strict";
+    init_llm_config();
+    init_http();
+    init_models_cache();
+    init_providers();
+    init_ranking();
+  }
+});
+
+// src/ai/llm/heal.ts
+var init_heal = __esm({
+  "src/ai/llm/heal.ts"() {
+    "use strict";
+    init_store();
+    init_discovery();
+    init_models_cache();
+  }
+});
+
+// src/ai/llm/resolver.ts
+var init_resolver = __esm({
+  "src/ai/llm/resolver.ts"() {
+    "use strict";
+    init_llm_config();
+    init_catalog();
+    init_session_state();
+  }
+});
+
+// src/ai/llm/failover.ts
+var init_failover = __esm({
+  "src/ai/llm/failover.ts"() {
+    "use strict";
+    init_usage_stats();
+    init_anthropic();
+    init_openai_compat();
+    init_catalog();
+    init_discovery();
+    init_errors2();
+    init_heal();
+    init_models_cache();
+    init_providers();
+    init_types2();
+    init_resolver();
+  }
+});
+
+// src/ai/web-search.ts
+var init_web_search = __esm({
+  "src/ai/web-search.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// src/ai/tool-schemas.ts
+var init_tool_schemas = __esm({
+  "src/ai/tool-schemas.ts"() {
+    "use strict";
+    init_web_search();
+  }
+});
+
+// src/ai/privacy.ts
+import { homedir as homedir3 } from "os";
+import { join as join9 } from "path";
+var AUDIT_DIR;
+var init_privacy = __esm({
+  "src/ai/privacy.ts"() {
+    "use strict";
+    AUDIT_DIR = join9(homedir3(), ".ntrp", "audit");
+  }
+});
+
+// src/ai/tool-handlers.ts
+var init_tool_handlers = __esm({
+  "src/ai/tool-handlers.ts"() {
+    "use strict";
+    init_connection();
+    init_privacy();
+    init_web_search();
+  }
+});
+
+// src/data/playbook.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7, appendFileSync } from "fs";
+import { join as join10 } from "path";
+function playsPath() {
+  return join10(getMemoryDir(), PLAYS_FILE);
+}
+function getCustomPlays() {
+  const path = playsPath();
+  if (!existsSync7(path)) return [];
+  const out = [];
+  for (const line of readFileSync7(path, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const play = JSON.parse(trimmed);
+      out.push({ ...play, source: "learned" });
+    } catch {
+    }
+  }
+  return out;
+}
+function getAllPlays() {
+  return [...PLAYBOOK, ...getCustomPlays()];
+}
+function getPlaybook() {
+  return getAllPlays();
+}
+function matchTriggeredPlays(vitals2, layers) {
+  const bySign = new Map(vitals2.map((v) => [v.vital_sign, v]));
+  const out = [];
+  for (const layer of layers) {
+    for (const sign of layer.signs) {
+      const vital = bySign.get(sign);
+      if (!vital) continue;
+      const fires = vital.status === "red" || vital.score < VITAL_TRIGGER_THRESHOLDS[sign];
+      if (!fires) continue;
+      for (const play of getAllPlays()) {
+        if (play.trigger_vital_sign === sign) {
+          out.push({ play, vital, layer: layer.layer });
+        }
+      }
+    }
+  }
+  return out;
+}
+var PLAYBOOK, PLAYS_FILE, VITAL_TRIGGER_THRESHOLDS;
+var init_playbook = __esm({
+  "src/data/playbook.ts"() {
+    "use strict";
+    init_store();
+    PLAYBOOK = [
+      {
+        id: "multi-thread-deals",
+        name: "Multi-Thread Your Deals",
+        trigger_vital_sign: "thread_depth",
+        trigger_condition: "thread_depth score < 2 (most deals have \u22641 active contact)",
+        why: "Single-threaded deals die when your one contact goes dark, changes roles, or loses budget authority. Every deal needs at least 2 active contacts to survive.",
+        steps: [
+          "Pull the list of single-threaded deals from entity_details",
+          "For each deal, identify the existing contact and their role",
+          "Research the account org chart for a second entry point (champion, economic buyer, or technical evaluator)",
+          "Send a warm intro or multi-thread via your existing contact",
+          "Log the new contact as an activity linked to the opportunity"
+        ],
+        tools_that_help: ["LinkedIn Sales Navigator", "Org chart tools", "CRM contact roles"],
+        expected_outcome: "Thread depth score rises above threshold; single-threaded deal count drops by 50%+ within 2 weeks"
+      },
+      {
+        id: "clean-dead-pipeline",
+        name: "Clean Dead Pipeline",
+        trigger_vital_sign: "freshness",
+        trigger_condition: "freshness score < 60",
+        why: "Stale accounts and zombie deals inflate your pipeline number but deliver zero revenue. They waste forecasting accuracy and hide the real health of your business.",
+        steps: [
+          "Export the stale opportunities list from entity_details",
+          "For each stale deal: contact the prospect within 48 hours or move to Closed Lost",
+          "For stale contacts: send a re-engagement sequence or archive",
+          "For stale organizations: verify they still match your ICP; archive if not",
+          "Set a recurring pipeline hygiene review (weekly 15-min scrub)"
+        ],
+        tools_that_help: ["CRM bulk update", "Email sequences", "Pipeline review meeting template"],
+        expected_outcome: "Freshness score jumps 20+ points; pipeline accuracy improves; forecast confidence increases"
+      },
+      {
+        id: "fix-handoff-gap",
+        name: "Fix the Handoff Gap",
+        trigger_vital_sign: "drop_rate",
+        trigger_condition: "drop_rate score indicates >30% of marketing leads not reaching sales",
+        why: "Every lead that marketing generates but sales never sees is wasted budget and lost revenue. The marketing\u2192sales handoff is the #1 leak in most GTM motions.",
+        steps: [
+          "Audit the marketing\u2192sales handoff: which leads exist only in marketing systems?",
+          "Check lead routing rules \u2014 are MQLs being assigned to active reps?",
+          "Verify SLA: how quickly are handed-off leads being touched by sales?",
+          "Fix routing gaps: unassigned territories, inactive rep queues, missing automation",
+          "Set up a weekly handoff report showing marketing-only leads"
+        ],
+        tools_that_help: ["Lead routing audit", "SLA dashboard", "Marketing\u2192Sales sync tool"],
+        expected_outcome: "Drop rate improves 15+ points; marketing-only lead count drops by 60%+"
+      },
+      {
+        id: "retarget-effort",
+        name: "Retarget Misdirected Effort",
+        trigger_vital_sign: "signal_to_noise",
+        trigger_condition: "signal_to_noise score < 50% (majority of activities not linked to pipeline)",
+        why: "When reps spend more than half their time on activities unconnected to open pipeline, they're burning hours that could be closing deals. Every noisy activity is time stolen from revenue.",
+        steps: [
+          "Review the noisy activities from entity_details \u2014 what types dominate?",
+          "Identify root cause: are reps prospecting dead accounts? Logging admin tasks? Working closed deals?",
+          "Create a 'focus list' of pipeline-linked accounts for each rep",
+          "Set activity targets: 80% of weekly activities should touch open pipeline",
+          "Remove or automate low-value activities that generate noise"
+        ],
+        tools_that_help: ["Activity reports by rep", "Focus account lists", "CRM activity rules"],
+        expected_outcome: "Signal-to-noise ratio improves to 70%+; rep productivity increases measurably"
+      },
+      {
+        id: "unstick-pipeline",
+        name: "Unstick the Pipeline",
+        trigger_vital_sign: "flow_rate",
+        trigger_condition: "flow_rate score < 50 (high average deal age or many stuck deals)",
+        why: "Stuck deals block revenue and demoralize reps. A deal that hasn't moved in 14+ days is either dead or needs intervention \u2014 either way, inaction is the worst choice.",
+        steps: [
+          "Pull stuck deals sorted by amount (highest value first)",
+          "For each stuck deal: identify the blocker (no next step? waiting on prospect? internal approval?)",
+          "Create a specific next action with a deadline for each stuck deal",
+          "Escalate deals stuck >30 days to manager review",
+          "Consider past-due deals: update close dates or move to Closed Lost"
+        ],
+        tools_that_help: ["Deal inspection reports", "Next-step templates", "Manager escalation workflow"],
+        expected_outcome: "Flow rate score improves 15+ points; stuck deal count drops by 40%+ within 2 weeks"
+      },
+      {
+        id: "reduce-logo-churn",
+        name: "Reduce Logo Churn",
+        trigger_metric: "grr",
+        trigger_lens: "revenue_metrics",
+        trigger_condition: "GRR below motion benchmark or churned ARR elevated",
+        why: "Revenue leaking from existing customers is the most expensive problem \u2014 you already paid to acquire them.",
+        steps: [
+          "Identify churned and at-risk accounts from retention metrics",
+          "Segment churn by deal size, tenure, and product usage patterns",
+          "Launch save plays for accounts showing contraction signals",
+          "Audit renewal process: timing, stakeholders, and success criteria",
+          "Implement early-warning triggers 90 days before renewal"
+        ],
+        tools_that_help: ["CS platform", "Renewal calendar", "NPS/CSAT surveys"],
+        expected_outcome: "GRR improves toward motion benchmark within 2 quarters"
+      },
+      {
+        id: "accelerate-expansion",
+        name: "Accelerate Expansion",
+        trigger_metric: "nrr",
+        trigger_lens: "revenue_metrics",
+        trigger_condition: "NRR below 100% with low expansion ARR",
+        why: "Growing from installed base is cheaper than new logo acquisition \u2014 low expansion means untapped wallet share.",
+        steps: [
+          "List accounts with single-product adoption and upsell potential",
+          "Map expansion triggers (seat growth, new use cases, tier upgrades)",
+          "Assign expansion targets to CS and AE teams by account tier",
+          "Create packaged upsell offers with clear ROI narratives",
+          "Track expansion pipeline separately from new business"
+        ],
+        tools_that_help: ["Account plans", "Usage analytics", "Expansion playbooks"],
+        expected_outcome: "Expansion ARR grows 20%+ quarter over quarter"
+      },
+      {
+        id: "fix-renewal-process",
+        name: "Fix the Renewal Process",
+        trigger_metric: "contraction_arr",
+        trigger_lens: "revenue_metrics",
+        trigger_condition: "Contraction ARR > 0",
+        why: "Downgrades are usually a process failure \u2014 late engagement, wrong stakeholders, or missing value proof.",
+        steps: [
+          "Pull all contraction events and categorize root cause",
+          "Standardize renewal timeline: 120/90/60/30-day checkpoints",
+          "Ensure economic buyer is engaged before renewal date",
+          "Build ROI recap deck template for every renewal",
+          "Escalate contractions >20% to leadership review"
+        ],
+        tools_that_help: ["Renewal workflow", "QBR templates", "Value realization reports"],
+        expected_outcome: "Contraction ARR drops 50%+ within 2 quarters"
+      },
+      {
+        id: "rebalance-pipeline-mix",
+        name: "Rebalance Pipeline Mix",
+        trigger_metric: "pipeline_coverage",
+        trigger_lens: "revenue_metrics",
+        trigger_condition: "Pipeline coverage red while win rate is healthy",
+        why: "Strong win rate with weak coverage means qualification works but top-of-funnel is starving the machine.",
+        steps: [
+          "Compare pipeline created vs closed-won by source and segment",
+          "Identify segments with coverage below benchmark",
+          "Shift marketing and SDR effort toward under-covered segments",
+          "Set weekly pipeline-created targets by rep",
+          "Review discounting and stage inflation masking thin pipeline"
+        ],
+        tools_that_help: ["Pipeline analytics", "Marketing attribution", "Capacity planning"],
+        expected_outcome: "Pipeline coverage reaches motion benchmark within 90 days"
+      },
+      {
+        id: "compress-sales-cycle",
+        name: "Compress the Sales Cycle",
+        trigger_metric: "avg_sales_cycle",
+        trigger_lens: "revenue_metrics",
+        trigger_condition: "Avg sales cycle exceeds profile sales_cycle_days by 50%+",
+        why: "Deals aging past your motion's norm tie up capacity and push revenue into future quarters.",
+        steps: [
+          "Analyze cycle time by stage \u2014 find where deals stall longest",
+          "Implement stage-exit criteria with required next steps",
+          "Introduce mutual action plans for deals past midpoint",
+          "Escalate deals exceeding 2x median cycle to manager review",
+          "Remove low-probability aged deals to free rep capacity"
+        ],
+        tools_that_help: ["Stage duration reports", "MAP templates", "Deal coaching"],
+        expected_outcome: "Median cycle time drops 20%+ within one quarter"
+      },
+      {
+        id: "improve-magic-number",
+        name: "Improve Magic Number",
+        trigger_metric: "magic_number",
+        trigger_lens: "revenue_metrics",
+        trigger_condition: "Magic number below motion benchmark (when spend data available)",
+        why: "Low S&M efficiency means you're buying growth too expensively \u2014 burn rate outpaces sustainable unit economics.",
+        steps: [
+          "Calculate magic number by channel and segment",
+          "Cut spend on channels with magic number below 0.5",
+          "Double down on highest-efficiency acquisition motions",
+          "Align CAC targets to motion-specific payback thresholds",
+          "Review rep ramp time and quota attainment curves"
+        ],
+        tools_that_help: ["Finance model", "Channel ROI dashboard", "CAC by source"],
+        expected_outcome: "Magic number improves toward benchmark within 2 quarters"
+      }
+    ];
+    PLAYS_FILE = "plays.jsonl";
+    VITAL_TRIGGER_THRESHOLDS = {
+      freshness: 60,
+      flow_rate: 50,
+      drop_rate: 70,
+      signal_to_noise: 50,
+      thread_depth: 60
+    };
+  }
+});
+
+// src/workflows/registry.ts
+var init_registry = __esm({
+  "src/workflows/registry.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/prompt-parts.ts
+var init_prompt_parts = __esm({
+  "src/ai/prompt-parts.ts"() {
+    "use strict";
+    init_profile();
+    init_playbook();
+    init_registry();
+  }
+});
+
+// src/ai/strategist-prompt.ts
+var init_strategist_prompt = __esm({
+  "src/ai/strategist-prompt.ts"() {
+    "use strict";
+    init_prompt_parts();
+  }
+});
+
+// src/ai/json-response.ts
+var init_json_response = __esm({
+  "src/ai/json-response.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/strategist-validate.ts
+function extractNumbers(text) {
+  const out = [];
+  for (const match of text.matchAll(NUMBER_RE)) {
+    const base = Number(match[1].replace(/,/g, ""));
+    if (!Number.isFinite(base)) continue;
+    const suffix = match[2]?.toLowerCase();
+    out.push(suffix ? base * (SUFFIX_MULTIPLIER[suffix] ?? 1) : base);
+  }
+  return out;
+}
+function numbersMatch(a, b) {
+  if (a === b) return true;
+  if (a === 0 || b === 0) return Math.abs(a - b) < 0.5;
+  return Math.abs(a - b) / Math.max(Math.abs(a), Math.abs(b)) <= 0.02;
+}
+function baselineAppearsInEvidence(value, evidenceNumbers) {
+  const valueNumbers = extractNumbers(value);
+  if (valueNumbers.length === 0) return false;
+  return valueNumbers.some((v) => evidenceNumbers.some((e) => numbersMatch(v, e)));
+}
+function isKnownInstrument(measuredBy) {
+  const lower = measuredBy.toLowerCase();
+  return INSTRUMENT_TOKENS.some((token) => lower.includes(token));
+}
+function parseIsoDate(value) {
+  if (typeof value !== "string") return null;
+  const match = value.trim().match(ISO_DATE_RE);
+  if (!match) return null;
+  const date = /* @__PURE__ */ new Date(`${match[1]}-${match[2]}-${match[3]}T00:00:00Z`);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function toIso(date) {
+  return date.toISOString().slice(0, 10);
+}
+function addDays(date, days) {
+  const out = new Date(date);
+  out.setUTCDate(out.getUTCDate() + days);
+  return out;
+}
+function normalizeDate(value, today2, fallbackDays) {
+  const parsed = parseIsoDate(value);
+  if (parsed && parsed.getTime() >= today2.getTime()) {
+    return { iso: toIso(parsed), repaired: false };
+  }
+  return { iso: toIso(addDays(today2, fallbackDays)), repaired: true };
+}
+function str(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function strArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(str).filter(Boolean);
+}
+function num(value, fallback) {
+  const n = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+function enumValue(value, allowed, fallback) {
+  return typeof value === "string" && allowed.includes(value) ? value : fallback;
+}
+function hasNumber(text) {
+  return extractNumbers(text).length > 0;
+}
+function validateOutcome(raw, label, evidenceNumbers, today2, fallbackDays) {
+  if (!raw || typeof raw !== "object") {
+    return { outcome: null, measurable: false, notes: [`${label}: missing \u2014 excluded from targets`] };
+  }
+  const record = raw;
+  const metric = str(record.metric);
+  const baseline = str(record.baseline);
+  const targetRange = str(record.target_range);
+  const measuredBy = str(record.measured_by);
+  if (!metric) {
+    return { outcome: null, measurable: false, notes: [`${label}: no metric named \u2014 excluded from targets`] };
+  }
+  const notes = [];
+  let measurable = true;
+  if (!hasNumber(baseline)) {
+    measurable = false;
+    notes.push(`${label} "${metric}": baseline is not a number \u2014 demoted to assumption`);
+  } else if (!baselineAppearsInEvidence(baseline, evidenceNumbers)) {
+    measurable = false;
+    notes.push(`${label} "${metric}": baseline ${baseline} not found in grounded evidence \u2014 demoted to assumption`);
+  }
+  if (!hasNumber(targetRange)) {
+    measurable = false;
+    notes.push(`${label} "${metric}": target range has no number \u2014 demoted to assumption`);
+  }
+  if (!measuredBy || !isKnownInstrument(measuredBy)) {
+    measurable = false;
+    notes.push(`${label} "${metric}": measured_by "${measuredBy || "(empty)"}" is not a known instrument \u2014 demoted to assumption`);
+  }
+  const checkDate = normalizeDate(record.check_date, today2, fallbackDays);
+  if (checkDate.repaired) {
+    notes.push(`${label} "${metric}": check date repaired to ${checkDate.iso}`);
+  }
+  return {
+    outcome: {
+      metric,
+      baseline: baseline || "unknown",
+      target_range: targetRange || "unquantified",
+      check_date: checkDate.iso,
+      measured_by: measuredBy || "unspecified"
+    },
+    measurable,
+    notes
+  };
+}
+function validateMilestones(raw, today2, issues, workstreamTitle) {
+  const out = [];
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      if (!item || typeof item !== "object") continue;
+      const record = item;
+      const label = str(record.label);
+      const verification = str(record.verification);
+      if (!label) continue;
+      const due = normalizeDate(record.due, today2, 14);
+      if (due.repaired) {
+        issues.push(`Milestone "${label}" (${workstreamTitle}): due date repaired to ${due.iso}`);
+      }
+      if (!verification) {
+        issues.push(`Milestone "${label}" (${workstreamTitle}): no verification method \u2014 flagged`);
+      }
+      out.push({ label, due: due.iso, verification: verification || "Verification method not specified \u2014 define before activating" });
+    }
+  }
+  return out;
+}
+function validateDeliverables(raw, today2) {
+  const out = [];
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      if (!item || typeof item !== "object") continue;
+      const record = item;
+      const label = str(record.label);
+      if (!label) continue;
+      out.push({
+        label,
+        kind: enumValue(record.kind, ["artifact", "process_change", "decision"], "artifact"),
+        due: normalizeDate(record.due, today2, 21).iso
+      });
+    }
+  }
+  return out;
+}
+function validateContingency(raw, today2) {
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw;
+  const trigger = str(record.trigger);
+  const fallback = str(record.fallback);
+  if (!trigger || !fallback) return null;
+  return {
+    trigger,
+    trigger_check_date: normalizeDate(record.trigger_check_date, today2, 21).iso,
+    fallback
+  };
+}
+function validPlayIds(value) {
+  const allowed = new Set(getPlaybook().map((play) => play.id));
+  return strArray(value).filter((id) => allowed.has(id));
+}
+function validateStrategistPlan(raw, opts) {
+  const today2 = parseIsoDate(opts.todayIso) ?? /* @__PURE__ */ new Date();
+  const evidenceNumbers = extractNumbers(opts.evidenceText);
+  const issues = [];
+  const demotedAssumptions = [];
+  let measurableTargets = 0;
+  let totalTargets = 0;
+  const rawWorkstreams = Array.isArray(raw.workstreams) ? raw.workstreams : [];
+  const workstreams = [];
+  for (const [index, item] of rawWorkstreams.entries()) {
+    if (!item || typeof item !== "object") continue;
+    const record = item;
+    const title = str(record.title) || `Workstream ${index + 1}`;
+    const outcomeCheck = validateOutcome(record.expected_outcome, "Expected outcome", evidenceNumbers, today2, 30);
+    totalTargets += outcomeCheck.outcome ? 1 : 0;
+    if (outcomeCheck.measurable) measurableTargets++;
+    for (const note of outcomeCheck.notes) issues.push(`${title}: ${note}`);
+    if (outcomeCheck.outcome && !outcomeCheck.measurable) {
+      demotedAssumptions.push(
+        `Unverified expectation (${title}): ${outcomeCheck.outcome.metric} ${outcomeCheck.outcome.baseline} -> ${outcomeCheck.outcome.target_range} \u2014 quantify against grounded data before treating as a target`
+      );
+    }
+    const leadingIndicators = [];
+    if (Array.isArray(record.leading_indicators)) {
+      for (const li of record.leading_indicators) {
+        const check = validateOutcome(li, "Leading indicator", evidenceNumbers, today2, 14);
+        if (!check.outcome) continue;
+        totalTargets++;
+        if (check.measurable) {
+          measurableTargets++;
+          leadingIndicators.push(check.outcome);
+        } else {
+          for (const note of check.notes) issues.push(`${title}: ${note}`);
+          demotedAssumptions.push(
+            `Unverified indicator (${title}): ${check.outcome.metric} \u2014 not measurable as stated`
+          );
+        }
+      }
+    }
+    let milestones = validateMilestones(record.milestones, today2, issues, title);
+    if (milestones.length === 0 && outcomeCheck.outcome) {
+      milestones = [{
+        label: `Outcome check: ${outcomeCheck.outcome.metric}`,
+        due: outcomeCheck.outcome.check_date,
+        verification: `${outcomeCheck.outcome.measured_by} shows ${outcomeCheck.outcome.target_range}`
+      }];
+      issues.push(`${title}: no dated milestones \u2014 derived one from the expected outcome`);
+    }
+    if (!outcomeCheck.outcome && milestones.length === 0) {
+      issues.push(`${title}: no measurable outcome and no milestones \u2014 workstream demoted to assumption`);
+      demotedAssumptions.push(`Dropped workstream "${title}" \u2014 had no measurable outcome or dated milestone`);
+      continue;
+    }
+    const contingency = validateContingency(record.contingency, today2);
+    if (!contingency) {
+      issues.push(`${title}: contingency missing or incomplete \u2014 flagged for definition at first review`);
+    }
+    workstreams.push({
+      order: num(record.order, workstreams.length + 1),
+      title,
+      problem: str(record.problem) || "Problem statement not captured",
+      rationale: str(record.rationale) || "Sequence rationale not captured",
+      play_ids: validPlayIds(record.play_ids),
+      actions: strArray(record.actions),
+      effort_hours: Math.max(0, num(record.effort_hours, 8)),
+      milestones,
+      deliverables: validateDeliverables(record.deliverables, today2),
+      expected_outcome: outcomeCheck.outcome ?? {
+        metric: "unspecified",
+        baseline: "unknown",
+        target_range: "unquantified",
+        check_date: toIso(addDays(today2, 30)),
+        measured_by: "unspecified"
+      },
+      leading_indicators: leadingIndicators,
+      contingency: contingency ?? {
+        trigger: "Define trigger at first review",
+        trigger_check_date: toIso(addDays(today2, 21)),
+        fallback: "Define fallback at first review"
+      }
+    });
+  }
+  if (workstreams.length === 0) return null;
+  workstreams.sort((a, b) => a.order - b.order);
+  workstreams.forEach((ws, i) => {
+    ws.order = i + 1;
+  });
+  const capped = workstreams.slice(0, 5);
+  if (workstreams.length > 5) {
+    issues.push(`Plan proposed ${workstreams.length} workstreams \u2014 capped to 5 (focus beats coverage)`);
+  }
+  const rawConfidence = Math.min(1, Math.max(0, num(raw.confidence, 0.6)));
+  const confidence = Math.max(0.2, rawConfidence - demotedAssumptions.length * 0.05);
+  const plan = {
+    title: str(raw.title) || "Untitled Strategy",
+    objective: str(raw.objective) || "Objective not restated",
+    summary_30k: str(raw.summary_30k) || str(raw.hypothesis) || "Executive summary not captured",
+    hypothesis: str(raw.hypothesis) || "If the workstreams execute in order, the objective metrics should move within their target ranges.",
+    target_segment: str(raw.target_segment) || "Whole pipeline",
+    priority: enumValue(raw.priority, ["low", "medium", "high"], "medium"),
+    review_cadence: str(raw.review_cadence) || "Weekly",
+    confidence,
+    constraints: strArray(raw.constraints),
+    assumptions: [...strArray(raw.assumptions), ...demotedAssumptions],
+    risks: strArray(raw.risks),
+    workstreams: capped
+  };
+  return { plan, issues, measurableTargets, totalTargets };
+}
+var NUMBER_RE, SUFFIX_MULTIPLIER, INSTRUMENT_TOKENS, ISO_DATE_RE;
+var init_strategist_validate = __esm({
+  "src/ai/strategist-validate.ts"() {
+    "use strict";
+    init_playbook();
+    init_json_response();
+    NUMBER_RE = /\$?\s*(\d[\d,]*\.?\d*)\s*(m|k|b|million|thousand|billion)?\b/gi;
+    SUFFIX_MULTIPLIER = {
+      k: 1e3,
+      thousand: 1e3,
+      m: 1e6,
+      million: 1e6,
+      b: 1e9,
+      billion: 1e9
+    };
+    INSTRUMENT_TOKENS = [
+      // vital signs + components
+      "freshness",
+      "flow_rate",
+      "flow rate",
+      "drop_rate",
+      "drop rate",
+      "signal_to_noise",
+      "signal-to-noise",
+      "signal to noise",
+      "thread_depth",
+      "thread depth",
+      "health score",
+      "vital",
+      "gating",
+      "score",
+      // SaaS metrics lane
+      "arr",
+      "nrr",
+      "grr",
+      "net revenue retention",
+      "gross revenue retention",
+      "win rate",
+      "pipeline coverage",
+      "weighted pipeline",
+      "velocity",
+      "deal size",
+      "sales cycle",
+      "conversion",
+      "ltv",
+      "cac",
+      "payback",
+      "magic number",
+      "churn",
+      "expansion",
+      "retention",
+      // countable pipeline entities + states
+      "count",
+      "stale",
+      "stuck",
+      "single-threaded",
+      "single threaded",
+      "zombie",
+      "dollar",
+      "pipeline at risk",
+      "opportunit",
+      "deal",
+      "activity",
+      "activities",
+      "contact",
+      "lead",
+      "account",
+      "segment",
+      "handoff",
+      "past-due",
+      "past due",
+      // the review instrument itself
+      "strategy review",
+      "metric_readings",
+      "vital_sign_readings",
+      "entity count"
+    ];
+    ISO_DATE_RE = /^(\d{4})-(\d{2})-(\d{2})/;
+  }
+});
+
+// src/ai/strategist.ts
+var init_strategist2 = __esm({
+  "src/ai/strategist.ts"() {
+    "use strict";
+    init_failover();
+    init_surfaces();
+    init_llm_config();
+    init_repl_api();
+    init_tool_schemas();
+    init_web_search();
+    init_tool_handlers();
+    init_strategist_prompt();
+    init_strategist_validate();
+  }
+});
+
+// src/ui/layout.ts
+var init_layout = __esm({
+  "src/ui/layout.ts"() {
+    "use strict";
+  }
+});
+
+// src/output/strategy-brief.ts
+import chalk4 from "chalk";
+var init_strategy_brief = __esm({
+  "src/output/strategy-brief.ts"() {
+    "use strict";
+    init_theme();
+    init_layout();
+  }
+});
+
+// src/output/llm-attribution.ts
+import chalk5 from "chalk";
+var init_llm_attribution = __esm({
+  "src/output/llm-attribution.ts"() {
+    "use strict";
+    init_catalog();
+  }
+});
+
+// src/whimsy/time-milestones.ts
+var init_time_milestones = __esm({
+  "src/whimsy/time-milestones.ts"() {
+    "use strict";
+  }
+});
+
+// src/whimsy/time-perspectives.ts
+var TIME_PERSPECTIVES;
+var init_time_perspectives = __esm({
+  "src/whimsy/time-perspectives.ts"() {
+    "use strict";
+    TIME_PERSPECTIVES = [
+      { id: "dsotm", category: "music", reference_hours: 0.74, label: "Dark Side of the Moon", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 1, max_ratio: 200 },
+      { id: "rush_2112", category: "music", reference_hours: 0.33, label: "2112", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 2, max_ratio: 200 },
+      { id: "bohemian_rhapsody", category: "music", reference_hours: 0.1, label: "Bohemian Rhapsody", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 5, max_ratio: 500 },
+      { id: "stairway", category: "music", reference_hours: 0.13, label: "Stairway to Heaven", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 5, max_ratio: 400 },
+      { id: "podcast_binge", category: "music", reference_hours: 0.75, label: "hour-long podcast episodes", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 2, max_ratio: 300 },
+      { id: "abbey_road", category: "music", reference_hours: 0.8, label: "Abbey Road", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 1, max_ratio: 200 },
+      { id: "iron_maiden_set", category: "music", reference_hours: 2, label: "an Iron Maiden marathon set", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 50 },
+      { id: "festival_set", category: "music", reference_hours: 1.5, label: "main-stage festival sets", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 100 },
+      { id: "jazz_club", category: "music", reference_hours: 3, label: "late-night jazz sets", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 80 },
+      { id: "ring_cycle", category: "music", reference_hours: 15, label: "Wagner's Ring Cycle", template: "\u2248 {pct}% of {label}", min_ratio: 0.1, max_ratio: 2 },
+      { id: "shrek", category: "film", reference_hours: 1.5, label: "Shrek (the first one)", template: "\u2248 {ratio}\xD7 watching {label}", min_ratio: 1, max_ratio: 150 },
+      { id: "blockbuster", category: "film", reference_hours: 2.1, label: "average blockbusters", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 100 },
+      { id: "dune_two", category: "film", reference_hours: 2.75, label: "Dune: Part Two", template: "\u2248 {ratio}\xD7 in theater for {label}", min_ratio: 1, max_ratio: 100 },
+      { id: "scorsese", category: "film", reference_hours: 3.5, label: "Goodfellas", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 80 },
+      { id: "godfather", category: "film", reference_hours: 6.5, label: "the Godfather saga", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 20 },
+      { id: "lotr_extended", category: "film", reference_hours: 11.4, label: "the LOTR extended trilogy", template: "Longer than all of {label}", min_ratio: 1, max_ratio: 50 },
+      { id: "cooking_brisket", category: "film", reference_hours: 12, label: "low-and-slow brisket cooks", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 30 },
+      { id: "the_office", category: "film", reference_hours: 68, label: "The Office (full series)", template: "\u2248 {ratio}\xD7 bingeing {label}", min_ratio: 5, max_ratio: 200 },
+      { id: "marvel_marathon", category: "film", reference_hours: 50, label: "an MCU Phase One marathon", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 30 },
+      { id: "around_world", category: "film", reference_hours: 1920, label: "Around the World in 80 Days (fictionally)", template: "\u2248 {pct}% of {label}", min_ratio: 0.3, max_ratio: 1 },
+      { id: "soccer_match", category: "sports", reference_hours: 1.75, label: "Premier League matches", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 150 },
+      { id: "marathon", category: "sports", reference_hours: 2, label: "marathons at world-record pace", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 80 },
+      { id: "baseball_game", category: "sports", reference_hours: 3, label: "nine-inning baseball games", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 80 },
+      { id: "superbowl", category: "sports", reference_hours: 3.5, label: "Super Bowls", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 80 },
+      { id: "nfl_game", category: "sports", reference_hours: 3.25, label: "NFL games (with commercials)", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 50 },
+      { id: "wimbledon", category: "sports", reference_hours: 5, label: "Wimbledon finals", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 30 },
+      { id: "tour_stage", category: "sports", reference_hours: 4.5, label: "Tour de France stages", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 60 },
+      { id: "olympics", category: "sports", reference_hours: 250, label: "Summer Olympics broadcast hours", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 2, max_ratio: 10 },
+      { id: "moon_light", category: "cosmos", reference_hours: 1.3 / 3600, label: "a beam of light Earth \u2192 Moon", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1e3, max_ratio: 1e6 },
+      { id: "iss_orbit", category: "cosmos", reference_hours: 1.5, label: "ISS orbits", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 2, max_ratio: 200 },
+      { id: "light_sun", category: "cosmos", reference_hours: 8.3, label: "solar light crossing to Earth", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 200 },
+      { id: "sleep_cycle", category: "cosmos", reference_hours: 8, label: "full nights of sleep", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 150 },
+      { id: "red_eye", category: "cosmos", reference_hours: 5.5, label: "transcontinental red-eyes", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 100 },
+      { id: "mayfly", category: "cosmos", reference_hours: 24, label: "a mayfly's entire adult life", template: "\u2248 {pct}% of {label}", min_ratio: 0.1, max_ratio: 2 },
+      { id: "earth_rotation", category: "cosmos", reference_hours: 24, label: "Earth rotations", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.1, max_ratio: 50 },
+      { id: "jupiter_storm", category: "cosmos", reference_hours: 150, label: "Jupiter's Great Red Spot rotation", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 15 },
+      { id: "lunar_month", category: "cosmos", reference_hours: 708, label: "a lunar cycle", template: "\u2248 {pct}% of {label}", min_ratio: 0.05, max_ratio: 2 },
+      { id: "mars_transit", category: "cosmos", reference_hours: 5110, label: "a one-way Mars transit (optimistic)", template: "\u2248 {pct}% of {label}", min_ratio: 1e-3, max_ratio: 5 },
+      { id: "calendar_year", category: "cosmos", reference_hours: 8760, label: "all the hours in a calendar year", template: "\u2248 {pct}% of {label}", min_ratio: 0.05, max_ratio: 0.2 },
+      { id: "standup", category: "gtm", reference_hours: 0.25, label: "daily standups", template: "\u2248 {ratio}\xD7 skipped {label}", min_ratio: 4, max_ratio: 500 },
+      { id: "quick_sync", category: "gtm", reference_hours: 0.5, label: "avoided 'quick syncs'", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 2, max_ratio: 200 },
+      { id: "pipeline_review", category: "gtm", reference_hours: 1, label: "weekly pipeline reviews", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 200 },
+      { id: "forecast_call", category: "gtm", reference_hours: 1.5, label: "forecast calls", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 150 },
+      { id: "pivot_spiral", category: "gtm", reference_hours: 2, label: "spreadsheet pivot-table spirals", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 100 },
+      { id: "win_loss", category: "gtm", reference_hours: 4, label: "win/loss interview blocks", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 50 },
+      { id: "crm_cleanup", category: "gtm", reference_hours: 6, label: "CRM hygiene sprints", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 40 },
+      { id: "qbr_prep", category: "gtm", reference_hours: 8, label: "QBR prep blocks", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 20 },
+      { id: "board_deck", category: "gtm", reference_hours: 12, label: "board deck builds", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 30 },
+      { id: "semester", category: "gtm", reference_hours: 400, label: "a college semester of analyst coverage", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 5 },
+      { id: "business_year", category: "gtm", reference_hours: 2e3, label: "a full-time analyst year", template: "\u2248 {pct}% of {label}", min_ratio: 0.2, max_ratio: 1 }
+    ];
+  }
+});
+
+// src/whimsy/time-bank-whimsy.ts
+var init_time_bank_whimsy = __esm({
+  "src/whimsy/time-bank-whimsy.ts"() {
+    "use strict";
+  }
+});
+
+// src/whimsy/perspective-rotation.ts
+var PERSPECTIVE_ROTATE_CALENDAR_MS;
+var init_perspective_rotation = __esm({
+  "src/whimsy/perspective-rotation.ts"() {
+    "use strict";
+    PERSPECTIVE_ROTATE_CALENDAR_MS = 7 * 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/whimsy/time-bank.ts
+import chalk6 from "chalk";
+var init_time_bank = __esm({
+  "src/whimsy/time-bank.ts"() {
+    "use strict";
+    init_progress();
+    init_theme();
+    init_time_milestones();
+    init_time_perspectives();
+    init_time_bank_whimsy();
+    init_perspective_rotation();
+    init_usage_stats();
+  }
+});
+
+// src/conversation/strategist-flow.ts
+import ora from "ora";
+import chalk7 from "chalk";
+function isStrategistIntent(input) {
+  const line = input.trim();
+  if (!line) return false;
+  if (isShipIntent(line)) return false;
+  return STRATEGIST_INTENT_RE.test(line);
+}
+function extractObjectiveSeed(input) {
+  const cleaned = input.trim().replace(/^(hey|ok|okay|please|can you|could you|help me|let'?s|i want to|i'?d like to|i need to)\s+/i, "").replace(/^(build|draft|make|create|put together)\s+(me\s+)?(a\s+|the\s+)?(game\s?plan|battle\s?plan|strategy|plan|roadmap)\s*(to|for|around|on)?\s*/i, "").replace(/^strategize\s+(about|around|on|for)?\s*/i, "").trim();
+  return cleaned.length >= 8 ? cleaned : input.trim();
+}
+var STRATEGIST_INTENT_RE;
+var init_strategist_flow = __esm({
+  "src/conversation/strategist-flow.ts"() {
+    "use strict";
+    init_context2();
+    init_handoff_draft();
+    init_repl_api();
+    init_theme();
+    init_prompts();
+    init_health_score();
+    init_divergence();
+    init_strategist();
+    init_strategist2();
+    init_strategy_brief();
+    init_llm_attribution();
+    init_time_bank();
+    init_formatters();
+    STRATEGIST_INTENT_RE = /\b(strateg(y|ize|ic)|game\s?plan|battle\s?plan|roadmap|(build|draft|make|create|put together)\s+(me\s+)?(a\s+|the\s+)?plan\b|plan\s+(to|for)\s+(fix|improv|reduc|recover|hit|reach|get|grow|turn)|how\s+(should|do|can)\s+we\s+(fix|approach|tackle|attack|prioritize|sequence|turn\s+(this|it)\s+around)|what\s+should\s+we\s+(do|fix|tackle|prioritize|focus\s+on)\s+(first|next)|what\s+order\s+should|where\s+(do|should)\s+we\s+start)\b/i;
+  }
+});
+
+// src/strategist/strategist-smoke.ts
+init_strategist_flow();
+init_phase();
+init_context2();
+init_strategist_validate();
+init_playbook();
+init_health_score();
+var failures = [];
+function assert(cond, msg) {
+  if (!cond) failures.push(msg);
+}
+assert(isStrategistIntent("how should we fix drop rate before the board?"), "strategist intent: how should we fix");
+assert(isStrategistIntent("build me a game plan to recover pipeline"), "strategist intent: game plan");
+assert(isStrategistIntent("what should we prioritize first"), "strategist intent: prioritize");
+assert(!isStrategistIntent("ship a board deck"), "ship intent must not match strategist");
+assert(!isStrategistIntent("what is our NRR?"), "descriptive question must not match strategist");
+var seed = extractObjectiveSeed("help me build a plan to fix stale pipeline");
+assert(seed.includes("stale pipeline"), "objective seed strips lead-in verbs");
+function mockCtx(partial) {
+  return {
+    sessionId: "2026-07-03-test",
+    sessionFile: "/tmp/test.json",
+    oneShot: false,
+    execution: { mode: "interactive", output: "terminal", color: true, progress: true, quiet: false },
+    snapshot: { computeResult: null, divergences: [] },
+    messages: [],
+    conversation: [],
+    stage: "analyzed",
+    deliverables: [],
+    analysis: defaultSessionAnalysis(),
+    wizardDepth: 0,
+    attachments: [],
+    deliverIntent: false,
+    computeInProgress: false,
+    dataset: { counts: { opportunities: 10 } },
+    ...partial
+  };
+}
+assert(
+  resolveConversationPhase(mockCtx({ strategistState: { step: "objective_confirm", objective: "fix freshness" } })) === "strategize",
+  "objective_confirm \u2192 strategize phase"
+);
+assert(
+  resolveConversationPhase(
+    mockCtx({
+      strategistState: { step: "awaiting_analysis", objective: "fix pipeline" },
+      stage: "new",
+      scope: { intent_summary: "health", primary_lens: "gtm_health", confirmed_at: (/* @__PURE__ */ new Date()).toISOString() }
+    })
+  ) === "awaiting_data",
+  "awaiting_analysis rides normal funnel (not strategize)"
+);
+var evidence = JSON.stringify({
+  vital_signs: { freshness: { score: 29, dollar_value: 31e5 } }
+});
+var today = "2026-07-03";
+var validPlan = {
+  title: "Q4 Pipeline Recovery",
+  objective: "Cut stale pipeline before board",
+  summary_30k: "Freshness gates everything.",
+  hypothesis: "Cleaning stale deals unlocks flow fixes.",
+  target_segment: "Enterprise pipeline",
+  priority: "high",
+  review_cadence: "Weekly",
+  confidence: 0.7,
+  constraints: ["6 rep-hours/week"],
+  assumptions: [],
+  risks: ["Rep capacity"],
+  workstreams: [
+    {
+      order: 1,
+      title: "Clean dead pipeline",
+      problem: "Stale deals block trust in the pipeline number",
+      rationale: "Freshness is the gating vital sign",
+      play_ids: ["clean-dead-pipeline"],
+      actions: ["Pull stale list", "Re-engage or close"],
+      effort_hours: 12,
+      milestones: [{ label: "Stale list triaged", due: "2026-07-17", verification: "stale count < 40" }],
+      deliverables: [{ label: "Re-engagement sequence", kind: "artifact", due: "2026-07-24" }],
+      expected_outcome: {
+        metric: "freshness score",
+        baseline: "29",
+        target_range: "45\u201355",
+        check_date: "2026-08-01",
+        measured_by: "freshness vital sign score"
+      },
+      leading_indicators: [
+        {
+          metric: "stale deal count",
+          baseline: "120",
+          target_range: "80\u201390",
+          check_date: "2026-07-20",
+          measured_by: "freshness entity_details stale count"
+        }
+      ],
+      contingency: {
+        trigger: "stale count flat by week 2",
+        trigger_check_date: "2026-07-20",
+        fallback: "Descope to top-2 segments only"
+      }
+    }
+  ]
+};
+var validated = validateStrategistPlan(validPlan, { evidenceText: evidence + " score 29 dollar 3100000 stale 120", todayIso: today });
+assert(validated !== null, "valid plan parses");
+assert(validated.plan.workstreams.length === 1, "valid plan keeps workstream");
+assert(validated.measurableTargets >= 1, "valid plan has measurable targets");
+assert(isKnownInstrument("freshness vital sign score"), "freshness is known instrument");
+var vaguePlan = {
+  ...validPlan,
+  workstreams: [
+    {
+      ...validPlan.workstreams[0],
+      expected_outcome: {
+        metric: "team morale",
+        baseline: "low",
+        target_range: "much better",
+        check_date: "2026-08-01",
+        measured_by: "gut feel"
+      }
+    }
+  ]
+};
+var demoted = validateStrategistPlan(vaguePlan, { evidenceText: evidence, todayIso: today });
+assert(demoted !== null, "vague plan still returns structure");
+assert(demoted.plan.assumptions.length > 0, "vague outcome demoted to assumptions");
+var vitals = ["freshness", "flow_rate", "thread_depth"].map((sign) => ({
+  vital_sign: sign,
+  score: sign === "freshness" ? 29 : sign === "flow_rate" ? 40 : 70,
+  status: sign === "freshness" ? "red" : "yellow",
+  dollar_value: sign === "freshness" ? 31e5 : null,
+  dollar_label: sign === "freshness" ? "pipeline at risk" : null
+}));
+var triggered = matchTriggeredPlays(vitals, LAYERS);
+assert(triggered.length >= 1, "keyless skeleton triggers at least one play");
+assert(triggered[0].layer === 1, "first triggered play respects LAYERS order (freshness first)");
+var nums = extractNumbers("$3.1M stale pipeline, 120 deals");
+assert(nums.some((n) => n >= 3e6), "extractNumbers parses $3.1M");
+if (failures.length > 0) {
+  console.error("FAIL strategist-smoke:");
+  for (const f of failures) console.error("  -", f);
+  process.exit(1);
+}
+console.log("PASS strategist-smoke");
+//# sourceMappingURL=strategist-smoke.js.map