@sonnechasser/ntrp 0.2.2 → 0.3.0

package/dist/strategist/strategist-smoke.js

@@ -0,0 +1,1873 @@
+#!/usr/bin/env node
+process.noDeprecation = true;
+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/output/formatters.ts
+var init_formatters = __esm({
+  "src/output/formatters.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/terminal-capture.ts
+var init_terminal_capture = __esm({
+  "src/services/terminal-capture.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/context-doc.ts
+import { writeFileSync } from "fs";
+var init_context_doc = __esm({
+  "src/services/context-doc.ts"() {
+    "use strict";
+    init_context2();
+    init_formatters();
+    init_terminal_capture();
+  }
+});
+
+// src/services/transcript.ts
+import { existsSync, readFileSync, writeFileSync as writeFileSync2, rmSync } from "fs";
+import { join } from "path";
+var init_transcript = __esm({
+  "src/services/transcript.ts"() {
+    "use strict";
+    init_context2();
+    init_terminal_capture();
+  }
+});
+
+// src/cli/context.ts
+import { basename, join as join2, resolve, sep } from "path";
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync3, readFileSync as readFileSync2, readdirSync, statSync, rmSync as rmSync2 } 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 STALE_SESSION_MS;
+var init_context2 = __esm({
+  "src/cli/context.ts"() {
+    "use strict";
+    init_thread_compat();
+    init_context();
+    init_context_doc();
+    init_transcript();
+    STALE_SESSION_MS = 14 * 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/config/store.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve2 } from "path";
+function ntrpHome() {
+  return NTRP_DIR;
+}
+function getMemoryDir() {
+  const dir = join3(NTRP_DIR, "memory");
+  if (!existsSync3(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) : join3(homedir2(), ".ntrp");
+    CONFIG_PATH = join3(NTRP_DIR, "config.json");
+  }
+});
+
+// src/config/profile.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync5, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+var NTRP_DIR2, PROFILE_PATH;
+var init_profile = __esm({
+  "src/config/profile.ts"() {
+    "use strict";
+    init_store();
+    NTRP_DIR2 = ntrpHome();
+    PROFILE_PATH = join4(NTRP_DIR2, "profile.json");
+  }
+});
+
+// src/db/connection.ts
+import { dirname, join as join5, 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) : join5(process.env.HOME ?? "", ".ntrp");
+    DEFAULT_DB_PATH = process.env.NTRP_DB_PATH ? resolve3(process.env.NTRP_DB_PATH) : join5(NTRP_DIR3, "ntrp.duckdb");
+    DB_PATH_PINNED = !!process.env.NTRP_DB_PATH;
+  }
+});
+
+// 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/explore-mode.ts
+var init_explore_mode = __esm({
+  "src/ai/explore-mode.ts"() {
+    "use strict";
+    init_context2();
+  }
+});
+
+// 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_repl_api();
+    init_explore_mode();
+    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 writeFileSync6 } from "fs";
+import { join as join6 } 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/ai/llm/types.ts
+var init_types2 = __esm({
+  "src/ai/llm/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/install.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
+import { join as join7 } from "path";
+var init_install = __esm({
+  "src/config/install.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// src/config/progress-migrate.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync8 } from "fs";
+import { join as join8 } 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 existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "fs";
+import { join as join9 } 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/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();
+    init_types2();
+  }
+});
+
+// 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();
+    init_types2();
+  }
+});
+
+// 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 join10 } from "path";
+var AUDIT_DIR;
+var init_privacy = __esm({
+  "src/ai/privacy.ts"() {
+    "use strict";
+    AUDIT_DIR = join10(homedir3(), ".ntrp", "audit");
+  }
+});
+
+// src/ai/untrusted.ts
+var UNTRUSTED_MARKER_NAME, UNTRUSTED_MARKER_END_NAME, MARKER_SPOOF_PATTERN;
+var init_untrusted = __esm({
+  "src/ai/untrusted.ts"() {
+    "use strict";
+    UNTRUSTED_MARKER_NAME = "EXTERNAL_UNTRUSTED_CONTENT";
+    UNTRUSTED_MARKER_END_NAME = "END_EXTERNAL_UNTRUSTED_CONTENT";
+    MARKER_SPOOF_PATTERN = new RegExp(
+      `<{2,}\\s*/?\\s*(?:${UNTRUSTED_MARKER_NAME}|${UNTRUSTED_MARKER_END_NAME})[^>]*>{2,}`,
+      "gi"
+    );
+  }
+});
+
+// src/ai/tool-handlers.ts
+var init_tool_handlers = __esm({
+  "src/ai/tool-handlers.ts"() {
+    "use strict";
+    init_connection();
+    init_privacy();
+    init_web_search();
+    init_untrusted();
+  }
+});
+
+// src/ai/loop-guard.ts
+var init_loop_guard = __esm({
+  "src/ai/loop-guard.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/thread.ts
+var PRUNED_TOOL_RESULT;
+var init_thread = __esm({
+  "src/ai/thread.ts"() {
+    "use strict";
+    PRUNED_TOOL_RESULT = JSON.stringify({
+      pruned: true,
+      note: "Old tool result cleared to free context \u2014 call the tool again if you still need it."
+    });
+  }
+});
+
+// src/data/playbook.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8, appendFileSync } from "fs";
+import { join as join11 } from "path";
+function playsPath() {
+  return join11(getMemoryDir(), PLAYS_FILE);
+}
+function getCustomPlays() {
+  const path = playsPath();
+  if (!existsSync8(path)) return [];
+  const out = [];
+  for (const line of readFileSync8(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 \u2014 and late-stage single-threading is a leading indicator of a slipped quarter.",
+        steps: [
+          "Pull single-threaded deals weighted by amount \u2014 one exposed mega-deal outranks ten small ones",
+          "Enrich the buying committee for each: map champion, economic buyer, and technical evaluator (enrichment waterfall or manual research)",
+          "Multi-thread through the existing contact first \u2014 a warm internal referral beats a cold second thread",
+          "Log every new contact with a role against the opportunity so thread depth is measured, not remembered",
+          "Install the mechanism: an alert when any deal past mid-stage has one active contact, and a job-change signal on champions so you hear about departures before the deal goes quiet"
+        ],
+        tools_that_help: ["Buying-committee enrichment (waterfall)", "Job-change signal tracking", "CRM contact roles", "Single-thread alerts"],
+        expected_outcome: "Thread depth score rises above threshold; single-threaded deal count drops by 50%+ within 2 weeks; zero late-stage deals with one thread"
+      },
+      {
+        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 corrupt the forecast, and they hide the real coverage math \u2014 you can't fix what the CRM is lying about. Clearing them is also the cheapest pipeline you'll ever source: those records are already paid for.",
+        steps: [
+          "Split the stale pool into saveable vs already-dead: contacted-recently-enough-to-revive vs fiction to clear",
+          "Saveable deals: contact within 48 hours with a specific reason to talk, or move to Closed Lost \u2014 inaction is the worst choice",
+          "Dead-but-paid-for records: route into a signal-triggered reactivation track (funding, hiring, job-change, site-visit triggers) instead of deleting them",
+          "Stale organizations: re-verify ICP fit before re-working; archive what no longer fits so reps stop fishing in dead water",
+          "Install the mechanism: a stale-deal alert at N quiet days (calibrated to this motion's cycle), a weekly 15-minute hygiene scrub, and enrichment refresh on records that go quiet"
+        ],
+        tools_that_help: ["CRM bulk update", "Signal-based reactivation triggers", "Enrichment refresh (waterfall)", "Pipeline hygiene cadence"],
+        expected_outcome: "Freshness score jumps 20+ points; forecast reflects reality; reactivation track produces meetings at a fraction of cold-acquisition cost"
+      },
+      {
+        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 \u2014 and it is almost always a systems failure (routing, sync, dead queues), not a people failure.",
+        steps: [
+          "Audit the leak by source: which lead sources exist only in marketing systems and never reach the CRM or a rep queue? The leak usually concentrates in one or two sources",
+          "Trace the routing path end-to-end: assignment rules, territory coverage, inactive-rep queues, and the marketing\u2192CRM sync itself \u2014 find where records fall on the floor",
+          "Fix the pipes: repair routing gaps, reassign orphaned queues, and dedupe/enrich records so routing has the fields it needs to route",
+          "Set the SLA and instrument it: time-to-first-touch on handed-off leads, with a report someone owns",
+          "Install the mechanism: an automated weekly marketing-only-leads report and an alert when any source's handoff rate degrades \u2014 so the leak can't quietly reopen"
+        ],
+        tools_that_help: ["Lead routing audit", "Enrichment waterfall (routing fields)", "SLA dashboard", "Handoff-degradation alerts"],
+        expected_outcome: "Drop rate improves 15+ points; marketing-only lead count drops by 60%+; time-to-first-touch inside SLA"
+      },
+      {
+        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. Persistent noise is a targeting-system problem \u2014 reps fish in the pond they can see because the account lists are stale \u2014 not a coaching problem.",
+        steps: [
+          "Cut noisy activity by rep and account status: dead accounts, closed deals, unlinked admin \u2014 name what dominates",
+          "Fix the pond, not the fishing: rebuild rep focus lists from ICP fit and live signals (intent, hiring, funding, usage) instead of memory",
+          "Route signals to reps in the channel they already work in, so the next action is the scored account, not the familiar one",
+          "Set the ratio target and instrument it: 80% of weekly activities touch open pipeline or scored accounts, on a per-rep report",
+          "Automate or delete the noise-generating busywork (logging, list building, manual research) so the time actually moves to pipeline"
+        ],
+        tools_that_help: ["Activity reports by rep", "ICP/propensity scoring", "Signal routing to rep channels", "Enrichment automation"],
+        expected_outcome: "Signal-to-noise ratio improves to 70%+; rep hours shift measurably from dead accounts to scored pipeline"
+      },
+      {
+        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 (calibrate to this motion's cycle) is either dead or needs intervention \u2014 and stuck deals with past-due close dates are a forecast-credibility problem before they're a revenue problem.",
+        steps: [
+          "Pull stuck deals sorted by amount, and find the stage where they cluster \u2014 there is usually one stage where deals go to die",
+          "For each stuck deal: name the blocker (no next step, waiting on prospect, internal approval, missing stakeholder) \u2014 'stuck' is a symptom, the blocker is the work",
+          "Create a specific next action with a deadline for each; deals with no plausible next action get triaged to Closed Lost so the forecast tells the truth",
+          "Fix the stage, not just the deals: add exit criteria and a required-next-step field to the stage where deals cluster",
+          "Install the mechanism: an aging alert at the motion-calibrated threshold and automatic manager escalation past 2x median stage duration"
+        ],
+        tools_that_help: ["Deal inspection reports", "Stage exit criteria", "Aging alerts", "Manager escalation workflow"],
+        expected_outcome: "Flow rate score improves 15+ points; stuck deal count drops by 40%+ within 2 weeks; the die-stage conversion measurably improves"
+      },
+      {
+        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/memory/play-outcomes.ts
+import { existsSync as existsSync9, readFileSync as readFileSync9, appendFileSync as appendFileSync2 } from "fs";
+import { join as join12 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+var init_play_outcomes = __esm({
+  "src/memory/play-outcomes.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// src/workflows/registry.ts
+var init_registry = __esm({
+  "src/workflows/registry.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/prompt-parts.ts
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { join as join13 } from "path";
+var init_prompt_parts = __esm({
+  "src/ai/prompt-parts.ts"() {
+    "use strict";
+    init_profile();
+    init_store();
+    init_playbook();
+    init_play_outcomes();
+    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_types2();
+    init_failover();
+    init_surfaces();
+    init_llm_config();
+    init_repl_api();
+    init_tool_schemas();
+    init_web_search();
+    init_tool_handlers();
+    init_loop_guard();
+    init_thread();
+    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