@sonnechasser/ntrp 1.5.3 → 1.5.7

package/dist/mcp/server.js

@@ -74,6 +74,17 @@ function formatCurrency(value) {
   if (value >= 1e3) return `$${(value / 1e3).toFixed(0)}K`;
   return `$${value.toFixed(0)}`;
 }
+function formatConstraintLine(aggregate) {
+  if (!aggregate) return void 0;
+  const gating = aggregate.gating_vital_sign;
+  const label = VITAL_SIGN_LABELS[gating] ?? gating;
+  const vital = aggregate.vital_signs.find((v) => v.vital_sign === gating);
+  if (vital?.dollar_value != null && vital.dollar_value > 0) {
+    const dollars = `${formatCurrency(vital.dollar_value)} ${vital.dollar_label ?? ""}`.trim();
+    return `${label} (${dollars})`;
+  }
+  return label;
+}
 function extractPipelineMetrics(vitals) {
   const flowRate = vitals.find((v) => v.vital_sign === "flow_rate");
   if (!flowRate) return null;
@@ -122,6 +133,7 @@ __export(store_exports, {
   getExportsDir: () => getExportsDir,
   getKnowledgeDir: () => getKnowledgeDir,
   getMemoryDir: () => getMemoryDir,
+  getRuminationsDir: () => getRuminationsDir,
   getStrategiesDir: () => getStrategiesDir,
   getWinsDir: () => getWinsDir,
   loadConfig: () => loadConfig,
@@ -265,6 +277,22 @@ from work done outside this platform.
   }
   return dir;
 }
+function getRuminationsDir() {
+  const dir = join(NTRP_DIR, "ruminations");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "README.md"),
+      `# Craft logs
+
+This directory stores overnight strategy craft jobs. Each job has a machine file (\`<id>.json\`) and a short log (\`<id>.md\`).
+
+Resume a job with \`ntrp strategy craft --resume <id>\`.
+`
+    );
+  }
+  return dir;
+}
 function getWinsDir() {
   const dir = join(NTRP_DIR, "wins");
   if (!existsSync(dir)) {
@@ -568,6 +596,14 @@ var init_path_safety = __esm({
 });
 
 // src/services/export-kinds.ts
+function archiveSubdirForKind(kind) {
+  if (kind.startsWith("prompt:")) return "handoffs";
+  if (kind === "report") return "reports";
+  if (kind === "notes") return "notes";
+  if (kind === "csv") return "csv";
+  if (kind === "publish") return "publish";
+  return "handoffs";
+}
 function latestBasenameForKind(kind) {
   if (kind.startsWith("prompt:")) {
     const target = kind.slice("prompt:".length);
@@ -967,6 +1003,9 @@ import {
 } from "fs";
 import { basename as basename2, dirname as dirname2, join as join3, resolve as resolve3, sep as sep2 } from "path";
 import { randomUUID } from "crypto";
+function exportStamp(d = /* @__PURE__ */ new Date()) {
+  return d.toISOString().replace(/T/, "-").replace(/:/g, "").slice(0, 15);
+}
 function ensureExportsLayout(root = getExportsDir()) {
   mkdirSync4(root, { recursive: true });
   mkdirSync4(join3(root, "latest"), { recursive: true });
@@ -985,6 +1024,15 @@ function ensureExportsLayout(root = getExportsDir()) {
   }
   return root;
 }
+function getArchiveKindDir(kind) {
+  const root = ensureExportsLayout();
+  const dir = join3(root, archiveSubdirForKind(kind));
+  mkdirSync4(dir, { recursive: true });
+  return dir;
+}
+function resolveArchivePath(kind, filename) {
+  return join3(getArchiveKindDir(kind), filename);
+}
 function getAiInboxDir() {
   return getConfiguredAiInboxDir();
 }
@@ -1043,6 +1091,16 @@ function listExports(opts = {}) {
   }
   return items.slice(0, limit);
 }
+function updateArchiveLatest(kind, sourcePath, root) {
+  const latestDir = join3(root, "latest");
+  mkdirSync4(latestDir, { recursive: true });
+  const name = latestBasenameForKind(kind);
+  const dest = join3(latestDir, name);
+  copyPath(sourcePath, dest);
+  if (kind.startsWith("prompt:")) {
+    copyPath(sourcePath, join3(latestDir, "handoff.md"));
+  }
+}
 function copyPath(src, dest) {
   mkdirSync4(dirname2(dest), { recursive: true });
   if (existsSync3(dest)) {
@@ -1240,6 +1298,29 @@ function syncRecentToInbox(limit = 10) {
   if (newest) persistHandoffSkillFiles(newest);
   return n;
 }
+function recordExportWrite(opts) {
+  const root = ensureExportsLayout();
+  const path = resolve3(opts.path);
+  if (!existsSync3(path)) {
+    throw new Error(`Export path does not exist: ${path}`);
+  }
+  updateArchiveLatest(opts.kind, path, root);
+  const event = {
+    id: randomUUID().slice(0, 8),
+    op: "write",
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: opts.kind,
+    path,
+    session_id: opts.sessionId,
+    title: opts.title
+  };
+  persistHandoffSkillFiles(event);
+  const inboxPath = syncAiInbox({ kind: opts.kind, path });
+  if (inboxPath) event.inbox_path = inboxPath;
+  appendManifestEvent(event, root);
+  regenerateIndex(root);
+  return event;
+}
 function archiveIndexPath() {
   return join3(ensureExportsLayout(), "INDEX.md");
 }
@@ -1380,6 +1461,8 @@ function buildSessionContextDoc(file, opts = {}) {
       lines.push(`- Constraints: ${file.strategist.constraintsNote}`);
     }
     if (file.strategist.origin) lines.push(`- Origin: ${file.strategist.origin}`);
+    if (file.strategist.mode) lines.push(`- Mode: ${file.strategist.mode}`);
+    if (file.strategist.ruminationId) lines.push(`- Craft job: ${file.strategist.ruminationId}`);
     lines.push("");
   }
   if (file.think) {
@@ -5106,6 +5189,7 @@ var init_surfaces = __esm({
       strategy: { defaultTier: "medium", allowUserTier: false },
       strategist: { defaultTier: "high", allowUserTier: true },
       strategist_stress: { defaultTier: "high", allowUserTier: false },
+      strategist_critic: { defaultTier: "high", allowUserTier: false },
       option_eval: { defaultTier: "low", allowUserTier: false }
     };
   }
@@ -7267,12 +7351,51 @@ import { stringify as stringifyYaml } from "yaml";
 function strategyLibraryPath(slug) {
   return join16(getStrategiesDir(), `${slug}.md`);
 }
-function writeStrategyMarkdown(strategy) {
+function writeStrategyMarkdown(strategy, extras) {
   const path = strategyLibraryPath(strategy.slug);
-  writeFileSync11(path, renderStrategyMarkdown(strategy), "utf-8");
+  writeFileSync11(path, renderStrategyMarkdown(strategy, extras), "utf-8");
   return path;
 }
-function renderStrategyMarkdown(strategy) {
+function formatEffortSum(workstreams) {
+  const sum = workstreams.reduce(
+    (acc, ws) => acc + (Number.isFinite(ws.effort_hours) ? ws.effort_hours : 0),
+    0
+  );
+  const count = workstreams.length;
+  return `~${Math.round(sum)} team-hours across ${count} workstream${count === 1 ? "" : "s"}`;
+}
+function renderConstraintHeading(constraintLine) {
+  return `## Constraint
+${constraintLine?.trim() || "none stated"}
+`;
+}
+function renderScopeHeading(constraints, outOfScope) {
+  const inLines = constraints.length > 0 ? formatList(constraints) : "- none stated";
+  const outItems = (outOfScope ?? []).map((s) => s.trim()).filter(Boolean);
+  const outLines = outItems.length > 0 ? formatList(outItems) : "- none stated";
+  return `## In scope / out of scope
+In scope:
+${inLines}
+
+Out of scope:
+${outLines}
+`;
+}
+function renderKilledAlternativeLine(killedAlternative) {
+  return `Killed alternative: ${killedAlternative?.trim() || "none stated"}`;
+}
+function renderEffortHeading(workstreams) {
+  return `## Effort
+${formatEffortSum(workstreams)}
+`;
+}
+function renderReviewHeading(opts) {
+  const cmd = opts.slug?.trim() ? `/strategy review ${opts.slug.trim()}` : "/strategy review";
+  return `## Review
+Cadence: ${opts.cadence}. Check progress with ${cmd}.
+`;
+}
+function renderStrategyMarkdown(strategy, extras) {
   const frontmatter = stringifyYaml({
     id: strategy.id,
     slug: strategy.slug,
@@ -7287,6 +7410,9 @@ function renderStrategyMarkdown(strategy) {
     ...strategy.baseline_batch_id ? { baseline_batch_id: strategy.baseline_batch_id } : {},
     updated_at: strategy.updated_at
   }).trim();
+  if (strategy.origin === "strategist") {
+    return renderStrategistLibraryMarkdown(strategy, extras, frontmatter);
+  }
   const objectiveSection = strategy.objective ? `
 ## Objective
 ${strategy.objective}
@@ -7333,6 +7459,67 @@ ${formatList(strategy.risks)}
 ## Experiment Design
 ${strategy.experiment_design}
 
+## Source Excerpt
+${strategy.raw_excerpt || "_No excerpt captured._"}
+`;
+}
+function renderStrategistLibraryMarkdown(strategy, extras, frontmatter) {
+  const callSection = strategy.raw_excerpt ? `
+## The Call
+${strategy.raw_excerpt}
+` : "";
+  const objectiveSection = strategy.objective ? `
+## Locked objective
+${strategy.objective}
+` : "";
+  const workstreamSection = strategy.workstreams.length > 0 ? `
+## Workstreams
+${strategy.workstreams.map(formatWorkstream).join("\n")}
+` : "";
+  const assumptionsSection = strategy.assumptions.length > 0 ? `
+## Assumptions (unverified)
+${formatList(strategy.assumptions)}
+` : "";
+  const craftLogSection = extras?.craftLogPath ? `
+## Craft log
+See \`${extras.craftLogPath}\`.
+` : "";
+  return `---
+${frontmatter}
+---
+
+# ${strategy.title}
+${callSection}${objectiveSection}
+${renderConstraintHeading(extras?.constraintLine)}
+## Goal
+${strategy.goal}
+
+${renderScopeHeading(strategy.constraints, extras?.outOfScope)}
+## Hypothesis
+${strategy.hypothesis}
+
+${renderKilledAlternativeLine(extras?.killedAlternative)}
+
+## Target Segment
+${strategy.target_segment}
+
+${renderEffortHeading(strategy.workstreams)}${workstreamSection}
+## Success Metrics
+${formatMetrics(strategy.success_metrics)}
+
+## Leading Indicators
+${formatMetrics(strategy.leading_indicators)}
+
+## Recommended Actions
+${formatList(strategy.recommended_actions)}
+${assumptionsSection}
+## Risks
+${formatList(strategy.risks)}
+
+## Experiment Design
+${strategy.experiment_design}
+
+${renderReviewHeading({ cadence: strategy.review_cadence, slug: strategy.slug })}${craftLogSection}
 ## Source Excerpt
 ${strategy.raw_excerpt || "_No excerpt captured._"}
 `;
@@ -8203,6 +8390,7 @@ function buildSessionFileSnapshot(ctx) {
   if (ctx.strategistState) file.strategist = ctx.strategistState;
   if (ctx.thinkState) file.think = ctx.thinkState;
   if (ctx.pendingAsk) file.pending_ask = ctx.pendingAsk;
+  if (ctx.lastCraftJobId) file.last_craft_job_id = ctx.lastCraftJobId;
   return file;
 }
 function defaultSessionAnalysis(primary = "gtm_health") {
@@ -8557,6 +8745,9 @@ async function finalizeSession(ctx, stage) {
   if (ctx.pendingAsk) {
     file.pending_ask = ctx.pendingAsk;
   }
+  if (ctx.lastCraftJobId) {
+    file.last_craft_job_id = ctx.lastCraftJobId;
+  }
   try {
     writeFileSync13(ctx.sessionFile, JSON.stringify(file, null, 2) + "\n");
   } catch {
@@ -8628,6 +8819,7 @@ function resetContextForSwitch(ctx, opts) {
   ctx.strategistState = opts.strategistState;
   ctx.thinkState = opts.thinkState;
   ctx.pendingAsk = opts.pendingAsk;
+  ctx.lastCraftJobId = opts.lastCraftJobId;
   ctx.gapAudit = void 0;
   ctx.deliverIntent = false;
   ctx.computeInProgress = false;
@@ -10254,7 +10446,7 @@ This command is hidden. Type \`/ingest --demo\` instead. That command calls this
 name: strategy
 description: Make a measured strategy from your data
 section: More
-args: [objective] | [list|show|review|ingest|add|sync|sources] [args]
+args: [objective] | [list|show|review|ingest|add|sync|sources|craft] [args]
 handler: ../commands/strategy.ts
 ---
 
@@ -10263,6 +10455,8 @@ NTRP uses live data. It works back from the objective.
 The result is sequenced workstreams with dated milestones, deliverables, outcome ranges, and a contingency per workstream.
 Saved plans go to the strategy library. Later answers use them.
 Type \`/strategy review [slug]\` to check the plan against live data when new batches arrive.
+Type \`keep going\` at the confirm card to keep working until the plan is ready.
+One-shot: \`ntrp strategy craft <objective>\`. Resume with \`ntrp strategy craft --resume <id>\`.
 
 Library commands: \`/strategy list\`, \`/strategy show <slug>\`.
 Type \`/strategy ingest <file>\` for markdown, YAML, PDF, text, or \`-\` for stdin.
@@ -14229,14 +14423,140 @@ var init_registry2 = __esm({
   }
 });
 
+// src/ruminations/store.ts
+import { existsSync as existsSync24, readFileSync as readFileSync21, writeFileSync as writeFileSync15 } from "fs";
+import { join as join24 } from "path";
+import { randomUUID as randomUUID8 } from "crypto";
+function makeRuminationId(now2 = /* @__PURE__ */ new Date()) {
+  const day = now2.toISOString().slice(0, 10).replace(/-/g, "");
+  return `${day}-${randomUUID8().slice(0, 4)}`;
+}
+function ruminationJsonPath(id) {
+  return join24(getRuminationsDir(), `${id}.json`);
+}
+function ruminationLogPath(id) {
+  return join24(getRuminationsDir(), `${id}.md`);
+}
+function unfinishedCraftJob(id) {
+  if (!id?.trim()) return null;
+  const job = loadRuminationJob(id);
+  if (!job || job.status === "ready") return null;
+  return job;
+}
+function loadRuminationJob(id) {
+  const path = ruminationJsonPath(id);
+  if (!existsSync24(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync21(path, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || parsed.id !== id) return null;
+    if (parsed.best_plan === void 0) parsed.best_plan = parsed.plan ?? null;
+    if (parsed.best_score === void 0) parsed.best_score = parsed.last_critic?.score ?? null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function createRuminationJob(opts) {
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: opts.id ?? makeRuminationId(),
+    objective: opts.objective,
+    constraints_note: opts.constraintsNote,
+    baseline_batch_id: opts.baselineBatchId ?? null,
+    snapshot_hash: opts.snapshotHash,
+    plan: null,
+    best_plan: null,
+    best_score: null,
+    last_critic: null,
+    rubric_gaps: [],
+    iterations: [],
+    cumulative_input_tokens: 0,
+    cumulative_output_tokens: 0,
+    status: "running",
+    from_fallback: false,
+    revised_once: false,
+    extra_ground_used: false,
+    min_score: opts.minScore,
+    max_rounds: opts.maxRounds,
+    max_tokens: opts.maxTokens,
+    created_at: now2,
+    updated_at: now2,
+    no_improve_streak: 0,
+    last_critic_score: null
+  };
+}
+function renderRuminationLog(job) {
+  const lines = [];
+  lines.push(`# Craft log \u2014 ${job.id}`);
+  lines.push("");
+  lines.push(`Objective: ${job.objective}`);
+  lines.push(`Status: ${job.status}${job.stop_reason ? ` (${job.stop_reason})` : ""}`);
+  lines.push(
+    `Tokens: ${job.cumulative_input_tokens + job.cumulative_output_tokens} total (${job.cumulative_input_tokens} in / ${job.cumulative_output_tokens} out)`
+  );
+  if (job.library_path) lines.push(`Strategy: ${job.library_path}`);
+  if (job.handoff_path) lines.push(`Handoff: ${job.handoff_path}`);
+  lines.push("");
+  lines.push("## Rounds");
+  lines.push("");
+  if (job.iterations.length === 0) {
+    lines.push("_No rounds yet._");
+  } else {
+    for (const it of job.iterations) {
+      const codes = it.blocking_codes.length > 0 ? it.blocking_codes.join(", ") : "none";
+      lines.push(
+        `- Round ${it.round}: score ${it.critic_score ?? "\u2014"} \xB7 ${it.decision} \xB7 blocking ${codes} \xB7 ${it.tokens_in + it.tokens_out} tok`
+      );
+    }
+  }
+  if (job.last_critic?.partner_pushback) {
+    lines.push("");
+    lines.push("## Partner pushback");
+    lines.push("");
+    lines.push(job.last_critic.partner_pushback);
+  }
+  if (job.last_critic?.killed_alternative) {
+    lines.push("");
+    lines.push("## Killed alternative");
+    lines.push("");
+    lines.push(job.last_critic.killed_alternative);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function saveRuminationJob(job) {
+  job.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  getRuminationsDir();
+  writeFileSync15(ruminationJsonPath(job.id), JSON.stringify(job, null, 2) + "\n", "utf-8");
+  writeFileSync15(ruminationLogPath(job.id), renderRuminationLog(job), "utf-8");
+}
+function addRuminationIteration(job, iteration) {
+  job.iterations.push({ ...iteration, at: (/* @__PURE__ */ new Date()).toISOString() });
+  job.cumulative_input_tokens += iteration.tokens_in;
+  job.cumulative_output_tokens += iteration.tokens_out;
+}
+var init_store3 = __esm({
+  "src/ruminations/store.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
 // src/conversation/recommended-action.ts
 function resolveRecommendedAction(ctx) {
   if (!hasValidLicense()) return { submit: "/activate", hint: "/activate" };
   const phase = resolveConversationPhase(ctx);
   switch (phase) {
     case "explore":
+      if (!canUseReplAi(ctx)) {
+        if (ctx.stage === "delivered") return { submit: "/end", hint: "home" };
+        return { submit: "/connect", hint: "/connect" };
+      }
+      if (unfinishedCraftJob(ctx.lastCraftJobId)) {
+        return { submit: "keep going", hint: "keep going" };
+      }
       if (ctx.stage === "delivered") return { submit: "/end", hint: "home" };
-      return canUseReplAi(ctx) ? null : { submit: "/connect", hint: "/connect" };
+      return null;
     case "awaiting_data":
       if (ctx.gapAudit?.can_compute) return { submit: "go ahead", hint: "go ahead" };
       if (!sessionHasData(ctx)) return { submit: "use demo data", hint: "use demo data" };
@@ -14260,6 +14580,7 @@ var init_recommended_action = __esm({
     init_activation();
     init_registry2();
     init_phase();
+    init_store3();
   }
 });
 
@@ -15966,11 +16287,11 @@ function jsonSafe(value) {
   }
   return value;
 }
-function envelope(command, data, warnings) {
+function envelope(command, data, warnings, status = "ok") {
   return {
     schema_version: HEADLESS_SCHEMA_VERSION,
     command,
-    status: "ok",
+    status,
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     data,
     ...warnings && warnings.length > 0 ? { warnings } : {}
@@ -15986,8 +16307,8 @@ function errorEnvelope(command, err) {
     error: ntrpError.toHeadlessError()
   };
 }
-function emitResult(command, data, warnings) {
-  console.log(JSON.stringify(jsonSafe(envelope(command, data, warnings)), null, 2));
+function emitResult(command, data, warnings, status = "ok") {
+  console.log(JSON.stringify(jsonSafe(envelope(command, data, warnings, status)), null, 2));
 }
 function emitError(command, err) {
   const ntrpError = err instanceof NtrpError ? err : toNtrpError(err);
@@ -17587,7 +17908,13 @@ async function persistStrategistPlan(plan, opts = {}) {
   if (!strategy) {
     throw new NtrpError("strategy_persist_failed", "Strategy was not found after saving.", 1 /* RuntimeError */);
   }
-  const writtenPath = writeStrategyMarkdown(strategy);
+  const extras = {
+    craftLogPath: opts.craftLogPath,
+    constraintLine: opts.constraintLine,
+    killedAlternative: opts.killedAlternative,
+    outOfScope: opts.outOfScope
+  };
+  const writtenPath = writeStrategyMarkdown(strategy, extras);
   await insertStrategySource({
     strategy_id: strategy.id,
     source_type: "agent",
@@ -17615,7 +17942,6 @@ var init_strategist = __esm({
     init_errors2();
     init_types2();
     init_formatters();
-    init_formatters();
   }
 });
 
@@ -17901,6 +18227,52 @@ ${AAR_BLOCK}
 
 Then respond with the FINAL revised plan as strict JSON in the same schema \u2014 no markdown fences, no prose. Fold what you learned into constraints, assumptions, risks, and confidence. This version is the one that gets saved and reviewed against, so make every number one you are willing to be checked on.`;
 }
+function buildCriticMessage(input) {
+  return `CRAFT CRITIC. You are a skeptical partner reviewing a GTM plan before it ships to a client. The objective is locked and must be echoed verbatim.
+
+ARMED OBJECTIVE (byte-identical; do not rewrite):
+"${input.objective}"
+
+CODE RUBRIC GAPS (already blocking \u2014 you cannot ship until these are gone):
+${input.rubricGaps || "(none)"}
+
+LIVE SNAPSHOT (cite these numbers only):
+${input.healthSnapshot}
+
+CURRENT PLAN JSON:
+${input.planJson}
+
+${HEILMEIER_GATE}
+
+${AAR_BLOCK}
+
+Decide whether a partner would ship this. Respond with STRICT JSON only:
+{
+  "ship": false,
+  "score": 0,
+  "objective_echo": ${JSON.stringify(input.objective)},
+  "gaps": [{ "code": "bottleneck", "severity": "blocking", "note": "...", "fix": "..." }],
+  "killed_alternative": "one approach that failed newness/stake/exams",
+  "partner_pushback": "one paragraph a partner would actually say"
+}
+
+ship may be true only when objective_echo matches, blocking gaps are empty, and you would defend this plan in the room. Advisory gaps do not block. Score 0-100.`;
+}
+function buildReviseMessage(input) {
+  return `CRAFT REVISE. Keep the objective verbatim. Patch only the listed gap codes. Copy baselines from the current plan / snapshot exactly \u2014 do not invent numbers.
+
+ARMED OBJECTIVE (must appear unchanged as "objective"):
+"${input.objective}"
+
+GAPS TO CLOSE:
+${input.gapsJson}
+
+CURRENT PLAN:
+${input.planJson}
+
+Respond with ONLY the full plan JSON object in this schema \u2014 no prose, no fences:
+${STRATEGIST_PLAN_SCHEMA_BLOCK}`;
+}
 var STRATEGIST_PLAN_SCHEMA_BLOCK;
 var init_strategist_prompt = __esm({
   "src/ai/strategist-prompt.ts"() {
@@ -18428,6 +18800,297 @@ var init_strategist_validate = __esm({
   }
 });
 
+// src/ai/strategist-rubric.ts
+function numbersMatch2(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 parseIsoDate2(value) {
+  const match = value.trim().match(/^(\d{4})-(\d{2})-(\d{2})/);
+  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 addDays2(date, days) {
+  const out = new Date(date);
+  out.setUTCDate(out.getUTCDate() + days);
+  return out;
+}
+function workstreamText(ws) {
+  return [ws.title, ws.problem, ws.rationale, ws.actions.join(" "), ws.play_ids.join(" ")].join(" ");
+}
+function hasOwnerShape(ws) {
+  const blob = workstreamText(ws).toLowerCase();
+  return OWNER_TOKENS.some((token) => blob.includes(token));
+}
+function firstWorkstreamMovesConstraint(ws, gating) {
+  const plays = getPlaybook();
+  if (ws.play_ids.some((id) => plays.find((p) => p.id === id)?.trigger_vital_sign === gating)) {
+    return true;
+  }
+  const blob = workstreamText(ws).toLowerCase();
+  return VITAL_ALIASES[gating].some((alias) => blob.includes(alias));
+}
+function citesStake(plan, snapshot) {
+  const dollars = [];
+  if (snapshot.aggregate.total_value_at_risk != null && snapshot.aggregate.total_value_at_risk > 0) {
+    dollars.push(snapshot.aggregate.total_value_at_risk);
+  }
+  for (const vs of snapshot.aggregate.vital_signs) {
+    if (vs.dollar_value != null && vs.dollar_value > 0) dollars.push(vs.dollar_value);
+  }
+  if (dollars.length === 0) return true;
+  const blob = `${plan.summary_30k} ${plan.hypothesis} ${plan.workstreams[0]?.problem ?? ""}`;
+  const found = extractNumbers(blob);
+  if (found.some((n) => dollars.some((d) => numbersMatch2(n, d)))) return true;
+  const formatted = dollars.map((d) => formatCurrency(d).toLowerCase());
+  const lower = blob.toLowerCase();
+  return formatted.some((f) => lower.includes(f.toLowerCase()));
+}
+function hasStartWithin48h(plan, todayIso) {
+  const today = parseIsoDate2(todayIso) ?? /* @__PURE__ */ new Date(`${todayIso}T00:00:00Z`);
+  const limit = addDays2(today, 2);
+  const first = plan.workstreams[0];
+  if (!first) return false;
+  if (first.actions.some((action) => START_SOON_RE.test(action))) return true;
+  const dated = [
+    ...first.milestones.map((m) => m.due),
+    ...first.deliverables.map((d) => d.due)
+  ];
+  for (const iso of dated) {
+    const parsed = parseIsoDate2(iso);
+    if (parsed && parsed.getTime() <= limit.getTime()) return true;
+  }
+  return plan.workstreams.some(
+    (ws) => ws.actions.some((action) => START_SOON_RE.test(action))
+  );
+}
+function examsHold(ws) {
+  const o = ws.expected_outcome;
+  return extractNumbers(o.baseline).length > 0 && extractNumbers(o.target_range).length > 0 && isKnownInstrument(o.measured_by);
+}
+function inventedNumbers(plan, evidenceText) {
+  const evidenceNums = extractNumbers(evidenceText);
+  if (evidenceNums.length === 0) return false;
+  for (const ws of plan.workstreams) {
+    const baselines = extractNumbers(ws.expected_outcome.baseline);
+    if (baselines.length === 0) continue;
+    if (!baselines.some((b) => evidenceNums.some((e) => numbersMatch2(b, e)))) return true;
+  }
+  return false;
+}
+function scoreConsultantPlan(plan, opts) {
+  const gaps = [];
+  const gating = opts.snapshot.aggregate.gating_vital_sign;
+  const first = plan.workstreams[0];
+  const evidence = opts.evidenceText ?? JSON.stringify({
+    aggregate: opts.snapshot.aggregate
+  });
+  if (opts.armedObjective && plan.objective !== opts.armedObjective) {
+    gaps.push({
+      code: "objective_drift",
+      severity: "blocking",
+      note: "Plan objective does not match the armed objective.",
+      fix: "Copy the armed objective into plan.objective with no edits."
+    });
+  }
+  if (!first || !firstWorkstreamMovesConstraint(first, gating)) {
+    const label = VITAL_SIGN_LABELS[gating] ?? gating;
+    gaps.push({
+      code: "bottleneck",
+      severity: "blocking",
+      note: `First workstream does not move the gating vital (${label}).`,
+      fix: `Lead with a play or problem that moves ${gating}. Non-constraint work waits.`
+    });
+  }
+  if (!citesStake(plan, opts.snapshot)) {
+    gaps.push({
+      code: "stake",
+      severity: "blocking",
+      note: "30k or hypothesis does not cite snapshot dollars / cost of inaction.",
+      fix: "Open with the gating dollar figure from the live snapshot."
+    });
+  }
+  for (const ws of plan.workstreams) {
+    if (!hasOwnerShape(ws)) {
+      gaps.push({
+        code: "owner",
+        severity: "blocking",
+        note: `Workstream "${ws.title}" has no function-shaped owner.`,
+        fix: "Name RevOps, sales manager, CS lead, marketing ops, or AE lead in the actions."
+      });
+      break;
+    }
+  }
+  if (!hasStartWithin48h(plan, opts.todayIso)) {
+    gaps.push({
+      code: "start_48h",
+      severity: "blocking",
+      note: "No action or milestone is startable within 48 hours.",
+      fix: "Put a dated first action or milestone within two days of today."
+    });
+  }
+  const missingEffort = plan.workstreams.filter(
+    (ws) => !Number.isFinite(ws.effort_hours) || ws.effort_hours <= 0
+  );
+  if (missingEffort.length > 0 || plan.workstreams.length === 0) {
+    gaps.push({
+      code: "effort",
+      severity: "blocking",
+      note: "Each workstream needs a finite effort_hours greater than zero.",
+      fix: "Set effort_hours to a real team-hour estimate per workstream."
+    });
+  }
+  if (opts.constraintsNote?.trim() && plan.constraints.length === 0) {
+    gaps.push({
+      code: "scope",
+      severity: "blocking",
+      note: "Operator stated constraints, but the plan constraints list is empty.",
+      fix: "Copy operator constraints into plan.constraints. Name what is out of scope."
+    });
+  }
+  if (plan.workstreams.some((ws) => !examsHold(ws))) {
+    gaps.push({
+      code: "exams",
+      severity: "blocking",
+      note: "A workstream expected outcome is missing a numeric baseline, range, or known instrument.",
+      fix: "Give every expected_outcome a baseline, target range, and measured_by instrument from live data."
+    });
+  }
+  if (inventedNumbers(plan, evidence)) {
+    gaps.push({
+      code: "invented_numbers",
+      severity: "blocking",
+      note: "An outcome baseline is not in the grounded snapshot.",
+      fix: "Copy baselines from the health snapshot exactly."
+    });
+  }
+  const blocking = gaps.filter((g) => g.severity === "blocking");
+  return { pass: blocking.length === 0, gaps, blocking };
+}
+function asGapCode(value) {
+  return typeof value === "string" && GAP_CODES.includes(value) ? value : null;
+}
+function parseCriticResponse(raw, opts) {
+  if (!raw) {
+    return {
+      ship: false,
+      score: 0,
+      objective_echo: "",
+      gaps: [
+        {
+          code: "thin_evidence",
+          severity: "blocking",
+          note: "Critic reply was not valid JSON.",
+          fix: "Respond with the critic JSON object only."
+        }
+      ],
+      killed_alternative: "",
+      partner_pushback: ""
+    };
+  }
+  const objectiveEcho = typeof raw.objective_echo === "string" ? raw.objective_echo : "";
+  const killed = typeof raw.killed_alternative === "string" ? raw.killed_alternative.trim() : "";
+  const pushback = typeof raw.partner_pushback === "string" ? raw.partner_pushback.trim() : "";
+  const scoreRaw = typeof raw.score === "number" ? raw.score : Number(raw.score);
+  const score = Number.isFinite(scoreRaw) ? Math.max(0, Math.min(100, scoreRaw)) : 0;
+  const gaps = [];
+  if (Array.isArray(raw.gaps)) {
+    for (const item of raw.gaps) {
+      if (!item || typeof item !== "object") continue;
+      const rec = item;
+      const code = asGapCode(rec.code);
+      if (!code) continue;
+      gaps.push({
+        code,
+        severity: rec.severity === "advisory" ? "advisory" : "blocking",
+        note: typeof rec.note === "string" ? rec.note : "",
+        fix: typeof rec.fix === "string" ? rec.fix : ""
+      });
+    }
+  }
+  if (objectiveEcho !== opts.armedObjective) {
+    gaps.push({
+      code: "objective_drift",
+      severity: "blocking",
+      note: "Critic objective_echo does not match the armed objective.",
+      fix: "Echo the armed objective exactly."
+    });
+  }
+  if (!killed) {
+    gaps.push({
+      code: "alternatives_killed",
+      severity: "blocking",
+      note: "Critic did not name an approach that failed newness, stake, or exams.",
+      fix: "Name one killed alternative so the plan is not a restatement of the status quo."
+    });
+  }
+  for (const gap of opts.rubricBlocking) {
+    if (!gaps.some((g) => g.code === gap.code)) gaps.push(gap);
+  }
+  const blocking = gaps.filter((g) => g.severity === "blocking");
+  const modelShip = raw.ship === true;
+  const ship = modelShip && blocking.length === 0 && score >= opts.minScore && objectiveEcho === opts.armedObjective && killed.length > 0;
+  return {
+    ship,
+    score,
+    objective_echo: objectiveEcho,
+    gaps,
+    killed_alternative: killed,
+    partner_pushback: pushback
+  };
+}
+function lockPlanObjective(plan, armedObjective) {
+  return { ...plan, objective: armedObjective };
+}
+var OWNER_TOKENS, VITAL_ALIASES, START_SOON_RE, GAP_CODES;
+var init_strategist_rubric = __esm({
+  "src/ai/strategist-rubric.ts"() {
+    "use strict";
+    init_playbook();
+    init_strategist_validate();
+    init_formatters();
+    OWNER_TOKENS = [
+      "revops",
+      "rev ops",
+      "revenue ops",
+      "sales manager",
+      "sales ops",
+      "cs lead",
+      "customer success",
+      "marketing ops",
+      "ae lead",
+      "account executive lead",
+      "sdr lead",
+      "bdr lead",
+      "demand gen",
+      "enablement"
+    ];
+    VITAL_ALIASES = {
+      freshness: ["freshness", "stale", "zombie", "dead pipeline"],
+      flow_rate: ["flow_rate", "flow rate", "stuck", "velocity", "stage"],
+      drop_rate: ["drop_rate", "drop rate", "handoff", "leak"],
+      signal_to_noise: ["signal_to_noise", "signal-to-noise", "signal to noise", "noise", "misdirected"],
+      thread_depth: ["thread_depth", "thread depth", "single-thread", "single threaded", "multi-thread"]
+    };
+    START_SOON_RE = /\b(48\s*-?hours?|48h|tomorrow|today|monday|this week|within two days|within 2 days)\b/i;
+    GAP_CODES = [
+      "bottleneck",
+      "stake",
+      "owner",
+      "start_48h",
+      "effort",
+      "scope",
+      "exams",
+      "alternatives_killed",
+      "thin_evidence",
+      "invented_numbers",
+      "objective_drift"
+    ];
+  }
+});
+
 // src/ai/strategist.ts
 function buildHealthSnapshot(computeResult, divergences) {
   const { aggregate, segments } = computeResult;
@@ -18650,6 +19313,15 @@ Respond with ONLY the corrected plan JSON object in the required schema (title,
   for (const issue of validated.issues) {
     yield { type: "notice", text: issue };
   }
+  const rubric = scoreConsultantPlan(validated.plan, {
+    snapshot: options.computeResult,
+    constraintsNote: options.constraintsNote,
+    todayIso,
+    evidenceText
+  });
+  for (const gap of rubric.blocking) {
+    yield { type: "notice", text: `Plan gap (${gap.code}): ${gap.note}` };
+  }
   yield {
     type: "plan",
     plan: validated.plan,
@@ -18701,6 +19373,7 @@ var init_strategist2 = __esm({
     init_thread();
     init_strategist_prompt();
     init_strategist_validate();
+    init_strategist_rubric();
     init_strategist_prompt();
     GROUND_MAX_ROUNDS = 6;
     BACKCAST_MAX_ROUNDS = 4;
@@ -18715,25 +19388,673 @@ var init_strategist2 = __esm({
   }
 });
 
-// src/output/strategy-brief.ts
-import chalk16 from "chalk";
-function printWrapped(text, width, prefix = INDENT, style) {
-  for (const line of wrapWords(text, width)) {
-    console.log(prefix + (style ? style(line) : line));
-  }
+// src/ai/strategist-craft.ts
+import { createHash as createHash3 } from "crypto";
+function snapshotHash(snapshotJson) {
+  return createHash3("sha256").update(snapshotJson).digest("hex").slice(0, 16);
 }
-function outcomeLine(outcome) {
-  return `${chalk16.bold(outcome.metric)}: ${outcome.baseline} ${chalk16.dim("->")} ${chalk16.bold(outcome.target_range)} ${chalk16.dim(`by ${outcome.check_date} \xB7 ${outcome.measured_by}`)}`;
+function totalTokens(job) {
+  return job.cumulative_input_tokens + job.cumulative_output_tokens;
 }
-function printWorkstream(ws, width) {
-  const plays = ws.play_ids.length > 0 ? chalk16.dim(`  Play: ${ws.play_ids.join(", ")}`) : "";
-  console.log(`${INDENT}${paint("accent", `${ws.order}.`)} ${chalk16.bold(ws.title)}${plays}`);
-  printWrapped(ws.problem, width - 5, INDENT + "   ", (s) => chalk16.dim(s));
-  if (ws.rationale) {
-    printWrapped(`Reason: ${ws.rationale}`, width - 5, INDENT + "   ", (s) => chalk16.dim(s));
-  }
-  console.log(`${INDENT}   ${outcomeLine(ws.expected_outcome)}`);
-  for (const li of ws.leading_indicators) {
+function fallbackNotice(text) {
+  return /grounded (playbook )?fallback/i.test(text);
+}
+function canShip(job, critic, rubricBlocking) {
+  if (!critic.ship) return false;
+  if (rubricBlocking.length > 0) return false;
+  if (critic.score < job.min_score) return false;
+  if (job.from_fallback && !job.revised_once) return false;
+  return true;
+}
+function recordScoreStreak(job, score) {
+  if (job.last_critic_score != null && score <= job.last_critic_score) {
+    job.no_improve_streak += 1;
+  } else {
+    job.no_improve_streak = 0;
+  }
+  job.last_critic_score = score;
+}
+async function* strategistCraftSession(options) {
+  assertReplAi(options.ctx);
+  const todayIso = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const healthSnapshot = buildHealthSnapshot(options.computeResult, options.divergences);
+  const maxRounds = options.maxRounds ?? DEFAULT_CRAFT_MAX_ROUNDS;
+  const minScore = options.minScore ?? DEFAULT_CRAFT_MIN_SCORE;
+  const complete = options.complete ?? completeWithFailover;
+  const runIteration0 = options.runIteration0 ?? strategistPlanSession;
+  const job = options.job ?? createRuminationJob({
+    objective: options.objective,
+    constraintsNote: options.constraintsNote,
+    baselineBatchId: options.baselineBatchId,
+    snapshotHash: snapshotHash(healthSnapshot),
+    minScore,
+    maxRounds,
+    maxTokens: options.maxTokens
+  });
+  if (!options.job) job.objective = options.objective;
+  job.min_score = minScore;
+  job.max_rounds = maxRounds;
+  if (options.maxTokens != null) job.max_tokens = options.maxTokens;
+  saveRuminationJob(job);
+  options.ctx.lastCraftJobId = job.status === "ready" ? void 0 : job.id;
+  saveSessionState(options.ctx);
+  const evidenceText = healthSnapshot;
+  const armedObjective = job.objective;
+  let lastMeta = { provider_used: "unknown", model_used: "unknown" };
+  let measurable = { measurable_targets: 0, total_targets: 0 };
+  const scorePlan = (plan) => scoreConsultantPlan(plan, {
+    snapshot: options.computeResult,
+    constraintsNote: options.constraintsNote ?? job.constraints_note,
+    armedObjective,
+    todayIso,
+    evidenceText
+  });
+  const rememberBest = (plan, score) => {
+    if (score == null) {
+      if (!job.best_plan) job.best_plan = plan;
+      return;
+    }
+    if (job.best_score == null || score > job.best_score) {
+      job.best_score = score;
+      job.best_plan = plan;
+    }
+  };
+  try {
+    if (job.status === "ready" && job.plan) {
+      const locked = lockPlanObjective(job.plan, armedObjective);
+      job.plan = locked;
+      saveRuminationJob(job);
+      yield {
+        type: "plan",
+        plan: locked,
+        issues: [],
+        measurable_targets: measurable.measurable_targets,
+        total_targets: measurable.total_targets,
+        baseline_batch_id: options.baselineBatchId ?? null
+      };
+      yield {
+        type: "done",
+        model_used: lastMeta.model_used,
+        provider_used: lastMeta.provider_used,
+        usage: lastMeta
+      };
+      return { job, plan: locked, status: job.status, stop_reason: job.stop_reason };
+    }
+    if (!job.plan) {
+      yield { type: "stage", stage: "ground", label: "Craft \u2014 grounding, sequencing, stress-testing" };
+      for await (const event of runIteration0({ ...options, objective: armedObjective })) {
+        if (options.interrupted?.()) {
+          job.status = "unfinished";
+          job.stop_reason = "interrupt";
+          saveRuminationJob(job);
+          break;
+        }
+        if (event.type === "notice" && fallbackNotice(event.text)) {
+          job.from_fallback = true;
+        }
+        if (event.type === "plan") {
+          const locked = lockPlanObjective(event.plan, armedObjective);
+          job.plan = locked;
+          rememberBest(locked, null);
+          measurable = {
+            measurable_targets: event.measurable_targets,
+            total_targets: event.total_targets
+          };
+          const rubric = scorePlan(locked);
+          job.rubric_gaps = rubric.gaps;
+          yield { ...event, plan: locked, issues: [...event.issues, ...rubric.blocking.map((g) => `Plan gap (${g.code}): ${g.note}`)] };
+        } else if (event.type === "done") {
+          lastMeta = event.usage ?? lastMeta;
+          job.cumulative_input_tokens += event.usage?.input_tokens ?? 0;
+          job.cumulative_output_tokens += event.usage?.output_tokens ?? 0;
+          yield event;
+        } else {
+          yield event;
+        }
+      }
+      saveRuminationJob(job);
+    }
+    if (!job.plan) {
+      job.status = "unfinished";
+      job.stop_reason = job.stop_reason ?? "error";
+      saveRuminationJob(job);
+      yield {
+        type: "done",
+        model_used: lastMeta.model_used,
+        provider_used: lastMeta.provider_used,
+        usage: lastMeta
+      };
+      return { job, plan: null, status: job.status, stop_reason: job.stop_reason };
+    }
+    rememberBest(job.plan, job.best_score);
+    const systemPrompt = buildStrategistSystemPrompt(todayIso);
+    const callText = async (surface, userContent, maxTokens) => {
+      const result = await complete(
+        {
+          surface,
+          messages: [{ role: "user", content: userContent }],
+          system: systemPrompt,
+          max_tokens: maxTokens
+        },
+        { ctx: options.ctx }
+      );
+      lastMeta = result.meta;
+      return {
+        text: result.response.text,
+        input: result.response.token_usage?.input_tokens ?? result.meta.input_tokens ?? 0,
+        output: result.response.token_usage?.output_tokens ?? result.meta.output_tokens ?? 0
+      };
+    };
+    let stop;
+    const startRound = (job.iterations.at(-1)?.round ?? 0) + 1;
+    for (let round = startRound; round <= maxRounds; round++) {
+      if (options.interrupted?.()) {
+        stop = "interrupt";
+        break;
+      }
+      if (job.max_tokens != null && totalTokens(job) >= job.max_tokens) {
+        stop = "budget_tokens";
+        break;
+      }
+      const plan = job.plan;
+      if (!plan) {
+        stop = "error";
+        break;
+      }
+      const rubric = scorePlan(plan);
+      job.rubric_gaps = rubric.gaps;
+      const criticRaw = await callText(
+        "strategist_critic",
+        buildCriticMessage({
+          objective: armedObjective,
+          planJson: JSON.stringify(plan),
+          rubricGaps: rubric.blocking.map((g) => `${g.code}: ${g.note}`).join("\n") || "(none)",
+          healthSnapshot
+        }),
+        CRITIC_MAX_TOKENS
+      );
+      const critic = parseCriticResponse(parseJsonObjectFromText(criticRaw.text), {
+        armedObjective,
+        minScore,
+        rubricBlocking: rubric.blocking
+      });
+      job.last_critic = critic;
+      recordScoreStreak(job, critic.score);
+      rememberBest(plan, critic.score);
+      const tokensThisRound = criticRaw.input + criticRaw.output;
+      let decision = "revise";
+      if (canShip(job, critic, rubric.blocking)) {
+        decision = "ship";
+      } else if (job.no_improve_streak >= 2) {
+        decision = "no-delta";
+      }
+      addRuminationIteration(job, {
+        round,
+        critic_score: critic.score,
+        ship: critic.ship,
+        blocking_codes: critic.gaps.filter((g) => g.severity === "blocking").map((g) => g.code),
+        tokens_in: criticRaw.input,
+        tokens_out: criticRaw.output,
+        decision
+      });
+      yield {
+        type: "craft_round",
+        round,
+        max: maxRounds,
+        score: critic.score,
+        tokensThisRound,
+        tokensTotal: totalTokens(job),
+        decision
+      };
+      yield {
+        type: "notice",
+        text: `craft ${round}/${maxRounds} \xB7 score ${critic.score} \xB7 ${tokensThisRound} tok this round \xB7 ${totalTokens(job)} total`
+      };
+      saveRuminationJob(job);
+      if (decision === "ship") {
+        stop = "ship";
+        break;
+      }
+      if (decision === "no-delta") {
+        stop = "no_delta";
+        break;
+      }
+      const needsGround = critic.gaps.some((g) => g.code === "thin_evidence") && !job.extra_ground_used;
+      if (needsGround) {
+        job.extra_ground_used = true;
+        yield { type: "notice", text: "Critic asked for thinner evidence \u2014 one extra ground pass." };
+        for await (const event of runIteration0({ ...options, objective: armedObjective })) {
+          if (event.type === "notice" && fallbackNotice(event.text)) {
+            job.from_fallback = true;
+          } else if (event.type === "plan") {
+            job.plan = lockPlanObjective(event.plan, armedObjective);
+            rememberBest(job.plan, null);
+            measurable = {
+              measurable_targets: event.measurable_targets,
+              total_targets: event.total_targets
+            };
+          } else if (event.type !== "done") {
+            yield event;
+          }
+        }
+        saveRuminationJob(job);
+        continue;
+      }
+      if (options.interrupted?.()) {
+        stop = "interrupt";
+        break;
+      }
+      if (job.max_tokens != null && totalTokens(job) >= job.max_tokens) {
+        stop = "budget_tokens";
+        break;
+      }
+      const reviseRaw = await callText(
+        "strategist",
+        buildReviseMessage({
+          objective: armedObjective,
+          planJson: JSON.stringify(plan),
+          gapsJson: JSON.stringify(critic.gaps)
+        }),
+        REVISE_MAX_TOKENS
+      );
+      job.cumulative_input_tokens += reviseRaw.input;
+      job.cumulative_output_tokens += reviseRaw.output;
+      const parsed = parseJsonObjectFromText(reviseRaw.text);
+      const validated = parsed ? validateStrategistPlan(parsed, { evidenceText, todayIso }) : null;
+      if (validated) {
+        job.plan = lockPlanObjective(validated.plan, armedObjective);
+        job.revised_once = true;
+        job.from_fallback = false;
+        measurable = {
+          measurable_targets: validated.measurableTargets,
+          total_targets: validated.totalTargets
+        };
+        const nextRubric = scorePlan(job.plan);
+        job.rubric_gaps = nextRubric.gaps;
+      } else {
+        yield { type: "notice", text: "Revise JSON invalid \u2014 keeping prior plan." };
+      }
+      saveRuminationJob(job);
+    }
+    if (!stop) stop = "budget_rounds";
+    if (stop !== "ship" && job.best_plan) {
+      job.plan = lockPlanObjective(job.best_plan, armedObjective);
+    }
+    job.stop_reason = stop;
+    job.status = stop === "ship" ? "ready" : "unfinished";
+    saveRuminationJob(job);
+    if (job.plan) {
+      const rubric = scorePlan(job.plan);
+      yield {
+        type: "plan",
+        plan: job.plan,
+        issues: rubric.blocking.map((g) => `Plan gap (${g.code}): ${g.note}`),
+        measurable_targets: measurable.measurable_targets,
+        total_targets: measurable.total_targets,
+        baseline_batch_id: options.baselineBatchId ?? null
+      };
+    }
+    yield {
+      type: "done",
+      model_used: lastMeta.model_used,
+      provider_used: lastMeta.provider_used,
+      failover: lastMeta.failover,
+      usage: {
+        ...lastMeta,
+        input_tokens: job.cumulative_input_tokens,
+        output_tokens: job.cumulative_output_tokens
+      }
+    };
+    return { job, plan: job.plan, status: job.status, stop_reason: job.stop_reason };
+  } catch (err) {
+    job.status = "unfinished";
+    job.stop_reason = "error";
+    if (job.best_plan) job.plan = lockPlanObjective(job.best_plan, armedObjective);
+    saveRuminationJob(job);
+    throw err;
+  }
+}
+function formatCraftRoundLine(event) {
+  const score = event.score == null ? "\u2014" : String(event.score);
+  const tok = event.tokensThisRound >= 1e3 ? `${Math.round(event.tokensThisRound / 1e3)}k` : String(event.tokensThisRound);
+  const total = event.tokensTotal >= 1e3 ? `${Math.round(event.tokensTotal / 1e3)}k` : String(event.tokensTotal);
+  return `craft ${event.round}/${event.max} \xB7 score ${score} \xB7 ${tok} tok this round \xB7 ${total} total`;
+}
+var CRITIC_MAX_TOKENS, REVISE_MAX_TOKENS, DEFAULT_CRAFT_MAX_ROUNDS, DEFAULT_CRAFT_MIN_SCORE;
+var init_strategist_craft = __esm({
+  "src/ai/strategist-craft.ts"() {
+    "use strict";
+    init_failover();
+    init_repl_api();
+    init_context2();
+    init_strategist2();
+    init_strategist_validate();
+    init_strategist_rubric();
+    init_strategist_prompt();
+    init_store3();
+    CRITIC_MAX_TOKENS = 2048;
+    REVISE_MAX_TOKENS = 8192;
+    DEFAULT_CRAFT_MAX_ROUNDS = 5;
+    DEFAULT_CRAFT_MIN_SCORE = 85;
+  }
+});
+
+// src/ruminations/handoff.ts
+function renderCraftHandoffMarkdown(opts) {
+  const { plan } = opts;
+  const lines = [];
+  lines.push("# Action plan \u2014 NTRP craft");
+  lines.push("");
+  lines.push("Use this file as a prompt for another agent or as a morning brief.");
+  lines.push("");
+  lines.push("## The Call");
+  lines.push("");
+  lines.push(plan.summary_30k);
+  lines.push("");
+  lines.push("## Locked objective");
+  lines.push("");
+  lines.push(plan.objective);
+  lines.push("");
+  lines.push(renderConstraintHeading(opts.constraintLine).trimEnd());
+  lines.push("");
+  lines.push(renderScopeHeading(plan.constraints, opts.outOfScope).trimEnd());
+  lines.push("");
+  lines.push("## Hypothesis");
+  lines.push("");
+  lines.push(plan.hypothesis);
+  lines.push("");
+  lines.push(renderKilledAlternativeLine(opts.killedAlternative));
+  lines.push("");
+  lines.push(renderEffortHeading(plan.workstreams).trimEnd());
+  lines.push("");
+  lines.push("## Workstreams");
+  lines.push("");
+  for (const ws of plan.workstreams) {
+    lines.push(`### ${ws.order}. ${ws.title}`);
+    lines.push("");
+    lines.push(`- Problem: ${ws.problem}`);
+    lines.push(`- Why this order: ${ws.rationale}`);
+    if (ws.actions[0]) lines.push(`- First action (48h): ${ws.actions[0]}`);
+    lines.push(`- Effort: ~${Math.round(ws.effort_hours)} team-hours`);
+    lines.push(
+      `- Exam: ${ws.expected_outcome.metric} ${ws.expected_outcome.baseline} -> ${ws.expected_outcome.target_range} by ${ws.expected_outcome.check_date} (${ws.expected_outcome.measured_by})`
+    );
+    lines.push(
+      `- Contingency: if ${ws.contingency.trigger} (check ${ws.contingency.trigger_check_date}) -> ${ws.contingency.fallback}`
+    );
+    lines.push("");
+  }
+  if (plan.risks.length > 0) {
+    lines.push("## Risks");
+    lines.push("");
+    for (const r of plan.risks) lines.push(`- ${r}`);
+    lines.push("");
+  }
+  if (plan.assumptions.length > 0) {
+    lines.push("## Assumptions");
+    lines.push("");
+    for (const a of plan.assumptions) lines.push(`- ${a}`);
+    lines.push("");
+  }
+  lines.push(renderReviewHeading({ cadence: plan.review_cadence, slug: opts.slug }).trimEnd());
+  lines.push("");
+  if (opts.journalPath) {
+    lines.push("## Craft log");
+    lines.push("");
+    lines.push(`Status: ${opts.status}`);
+    lines.push(`Log: ${opts.journalPath}`);
+    if (opts.libraryPath) lines.push(`Strategy library: ${opts.libraryPath}`);
+    lines.push("");
+  } else if (opts.libraryPath) {
+    lines.push("## Strategy library");
+    lines.push("");
+    lines.push(opts.libraryPath);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function writeCraftPlanHandoff(opts) {
+  const journalPath = opts.jobId ? ruminationLogPath(opts.jobId) : void 0;
+  const markdown = renderCraftHandoffMarkdown({
+    plan: opts.plan,
+    journalPath,
+    libraryPath: opts.libraryPath,
+    status: opts.status,
+    constraintLine: opts.constraintLine,
+    killedAlternative: opts.killedAlternative,
+    outOfScope: opts.outOfScope,
+    slug: opts.slug
+  });
+  const path = resolveArchivePath("prompt:plan", `handoff-plan-${exportStamp()}.md`);
+  writeRedactedText(path, markdown);
+  const event = recordExportWrite({
+    kind: "prompt:plan",
+    path,
+    sessionId: opts.sessionId,
+    title: `${opts.plan.title} craft plan`
+  });
+  return { path, inboxPath: event.inbox_path };
+}
+var init_handoff = __esm({
+  "src/ruminations/handoff.ts"() {
+    "use strict";
+    init_exports_registry();
+    init_redact_write();
+    init_library();
+    init_store3();
+  }
+});
+
+// src/services/strategist-run.ts
+async function assertComputableData() {
+  await initSchema();
+  let counts = {};
+  try {
+    counts = await getEntityCounts();
+  } catch {
+    counts = {};
+  }
+  if (!Object.values(counts).some((n) => (n ?? 0) > 0)) {
+    throw new NtrpError(
+      "strategy_no_data",
+      "No pipeline data loaded. Ingest a CSV, run demo data, then craft a plan.",
+      4 /* NoData */
+    );
+  }
+}
+function rememberCraftJob(ctx, job) {
+  if (!job) return;
+  ctx.lastCraftJobId = job.status === "ready" ? void 0 : job.id;
+  saveSessionState(ctx);
+}
+async function executeStrategistJob(req) {
+  if (!canUseReplAi(req.ctx)) {
+    throw new NtrpError(
+      "strategy_no_key",
+      "No LLM API key configured. Run /connect and paste a key, then retry craft.",
+      3 /* Auth */
+    );
+  }
+  const resumeJob = req.resumeId ? loadRuminationJob(req.resumeId) : null;
+  if (req.resumeId && !resumeJob) {
+    throw new NtrpError(
+      "strategy_resume_missing",
+      `No craft job "${req.resumeId}". Check ~/.ntrp/ruminations/.`,
+      2 /* Usage */
+    );
+  }
+  if (resumeJob) rememberCraftJob(req.ctx, resumeJob);
+  const objective = resumeJob?.objective || req.objective;
+  if (!objective.trim()) {
+    throw new NtrpError(
+      "strategy_objective_required",
+      'strategy craft requires an objective. Example: ntrp strategy craft "cut stale pipeline before Q4"',
+      2 /* Usage */
+    );
+  }
+  await assertComputableData();
+  const inputs = await prepareStrategistInputs(req.ctx, objective);
+  const notices = [];
+  let plan = resumeJob?.plan ?? null;
+  let stats = { measurable_targets: 0, total_targets: 0 };
+  let meta = {};
+  let job = resumeJob ?? void 0;
+  const sessionOpts = {
+    objective,
+    computeResult: inputs.snapshot,
+    divergences: inputs.divergences,
+    includeMetrics: inputs.includeMetrics,
+    memoryBlock: inputs.memoryBlock,
+    gapAuditBlock: inputs.gapAuditBlock,
+    constraintsNote: req.constraintsNote ?? resumeJob?.constraints_note,
+    baselineBatchId: inputs.baselineBatchId,
+    ctx: req.ctx
+  };
+  const useCraft = req.mode === "craft" && req.untilReady !== false;
+  const handleEvent = (event) => {
+    req.onEvent?.(event);
+    if (event.type === "notice") notices.push(event.text);
+    if (event.type === "plan") {
+      plan = event.plan;
+      stats = {
+        measurable_targets: event.measurable_targets,
+        total_targets: event.total_targets
+      };
+    }
+    if (event.type === "done") {
+      meta = event.usage ?? { model_used: event.model_used, provider_used: event.provider_used };
+    }
+    if (event.type === "craft_round") {
+      notices.push(formatCraftRoundLine(event));
+    }
+  };
+  if (useCraft) {
+    const gen = strategistCraftSession({
+      ...sessionOpts,
+      maxRounds: req.maxRounds ?? resumeJob?.max_rounds ?? DEFAULT_CRAFT_MAX_ROUNDS,
+      maxTokens: req.maxTokens ?? resumeJob?.max_tokens,
+      minScore: req.minScore ?? resumeJob?.min_score ?? DEFAULT_CRAFT_MIN_SCORE,
+      job: resumeJob ?? void 0,
+      interrupted: req.interrupted
+    });
+    let next = await gen.next();
+    while (!next.done) {
+      handleEvent(next.value);
+      next = await gen.next();
+    }
+    job = next.value.job;
+    plan = next.value.plan;
+  } else {
+    for await (const event of strategistPlanSession(sessionOpts)) {
+      handleEvent(event);
+    }
+  }
+  const blocking = job?.rubric_gaps.filter((g) => g.severity === "blocking").map((g) => g.code) ?? [];
+  const status = job?.status === "unfinished" || !plan ? "unfinished" : "ready";
+  const result = {
+    plan,
+    status,
+    stop_reason: job?.stop_reason,
+    objective,
+    critic_score: job?.last_critic?.score ?? null,
+    rounds: job?.iterations.length ?? 0,
+    usage: meta,
+    journal_path: job ? ruminationLogPath(job.id) : void 0,
+    blocking_gaps: blocking,
+    measurable_targets: stats.measurable_targets,
+    total_targets: stats.total_targets,
+    notices,
+    job
+  };
+  const constraintLine = formatConstraintLine(inputs.snapshot.aggregate);
+  const killedAlternative = job?.last_critic?.killed_alternative;
+  if (plan && req.save) {
+    const persisted = await persistStrategistPlan(plan, {
+      baselineBatchId: inputs.baselineBatchId,
+      craftLogPath: job ? ruminationLogPath(job.id) : void 0,
+      constraintLine,
+      killedAlternative
+    });
+    result.slug = persisted.strategy.slug;
+    result.library_path = persisted.library_path;
+    req.ctx.deliverables.push({
+      kind: "strategy",
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      path: persisted.library_path,
+      note: plan.title
+    });
+    if (job) {
+      job.library_path = persisted.library_path;
+    }
+  }
+  if (plan && req.handoff) {
+    const written = writeCraftPlanHandoff({
+      plan,
+      jobId: job?.id,
+      status: result.status,
+      libraryPath: result.library_path,
+      sessionId: req.ctx.sessionId,
+      constraintLine,
+      killedAlternative,
+      slug: result.slug
+    });
+    result.handoff_path = written.path;
+    result.inbox_path = written.inboxPath;
+    if (job) {
+      job.handoff_path = written.path;
+      job.inbox_path = written.inboxPath;
+    }
+    req.ctx.deliverables.push({
+      kind: "prompt:plan",
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      path: written.path,
+      note: plan.title
+    });
+  }
+  if (job) {
+    if (req.ctx.strategistState) req.ctx.strategistState.ruminationId = job.id;
+    saveRuminationJob(job);
+    rememberCraftJob(req.ctx, job);
+  }
+  return result;
+}
+var init_strategist_run = __esm({
+  "src/services/strategist-run.ts"() {
+    "use strict";
+    init_context2();
+    init_errors2();
+    init_types2();
+    init_repl_api();
+    init_strategist2();
+    init_strategist_craft();
+    init_formatters();
+    init_strategist();
+    init_queries();
+    init_schema();
+    init_store3();
+    init_handoff();
+  }
+});
+
+// src/output/strategy-brief.ts
+import chalk16 from "chalk";
+function printWrapped(text, width, prefix = INDENT, style) {
+  for (const line of wrapWords(text, width)) {
+    console.log(prefix + (style ? style(line) : line));
+  }
+}
+function outcomeLine(outcome) {
+  return `${chalk16.bold(outcome.metric)}: ${outcome.baseline} ${chalk16.dim("->")} ${chalk16.bold(outcome.target_range)} ${chalk16.dim(`by ${outcome.check_date} \xB7 ${outcome.measured_by}`)}`;
+}
+function printWorkstream(ws, width) {
+  const plays = ws.play_ids.length > 0 ? chalk16.dim(`  Play: ${ws.play_ids.join(", ")}`) : "";
+  console.log(`${INDENT}${paint("accent", `${ws.order}.`)} ${chalk16.bold(ws.title)}${plays}`);
+  printWrapped(ws.problem, width - 5, INDENT + "   ", (s) => chalk16.dim(s));
+  if (ws.rationale) {
+    printWrapped(`Reason: ${ws.rationale}`, width - 5, INDENT + "   ", (s) => chalk16.dim(s));
+  }
+  console.log(`${INDENT}   ${outcomeLine(ws.expected_outcome)}`);
+  for (const li of ws.leading_indicators) {
     console.log(`${INDENT}   ${chalk16.dim("Lead:")} ${outcomeLine(li)}`);
   }
   if (ws.milestones.length > 0) {
@@ -18806,6 +20127,40 @@ function printStrategyBrief(plan, stats) {
   console.log(`${INDENT}${coverageStyled}${chalk16.dim(` \xB7 ~${Math.round(totalHours)} total team hours across ${plan.workstreams.length} workstream${plan.workstreams.length === 1 ? "" : "s"}`)}`);
   console.log();
 }
+function printCraftWrapUp(opts) {
+  console.log();
+  if (opts.status === "ready") {
+    console.log(INDENT + paint("accent", "Plan ready"));
+    if (opts.library_path) console.log(INDENT + chalk16.dim(opts.library_path));
+    if (opts.slug) {
+      console.log(
+        INDENT + chalk16.dim("Type ") + paint("accent", `/strategy review ${opts.slug}`) + chalk16.dim(" to check progress.")
+      );
+    }
+    const handoff = opts.inbox_path ?? opts.handoff_path;
+    if (handoff) console.log(INDENT + chalk16.dim(handoff));
+  } else {
+    console.log(INDENT + paint("accent", "Best so far."));
+    const path = opts.library_path ?? opts.handoff_path ?? opts.inbox_path;
+    if (path) console.log(INDENT + chalk16.dim(path));
+    if (opts.oneShot && opts.jobId) {
+      console.log(
+        INDENT + chalk16.dim("Resume: ") + paint("accent", `ntrp strategy craft --resume ${opts.jobId}`)
+      );
+    } else {
+      console.log(
+        INDENT + chalk16.dim("Type ") + chalk16.cyan("keep going") + chalk16.dim(" to continue.")
+      );
+    }
+  }
+  if (opts.oneShot && opts.journal_path) {
+    console.log(INDENT + chalk16.dim(`Craft log: ${opts.journal_path}`));
+  }
+  console.log();
+}
+function isCraftRoundNotice(text) {
+  return /^craft \d+\/\d+/.test(text);
+}
 var INDENT;
 var init_strategy_brief = __esm({
   "src/output/strategy-brief.ts"() {
@@ -18820,7 +20175,9 @@ var init_strategy_brief = __esm({
 var strategist_flow_exports = {};
 __export(strategist_flow_exports, {
   extractObjectiveSeed: () => extractObjectiveSeed,
+  handleKeepGoingLine: () => handleKeepGoingLine,
   handleStrategizeFlow: () => handleStrategizeFlow,
+  isKeepGoingIntent: () => isKeepGoingIntent,
   isStrategistIntent: () => isStrategistIntent,
   promptQueuedAiStrategist: () => promptQueuedAiStrategist,
   queueStrategistForAnalysis: () => queueStrategistForAnalysis,
@@ -18843,7 +20200,8 @@ function queueStrategistForAnalysis(ctx, opts) {
   ctx.strategistState = {
     step: "awaiting_analysis",
     objective: opts.seed,
-    origin: opts.origin
+    origin: opts.origin,
+    mode: opts.mode
   };
   saveSessionState(ctx);
   console.log();
@@ -18868,7 +20226,7 @@ async function startStrategistFlow(ctx, opts) {
     objective = (snapshot ? proposeObjectiveFromSnapshot(snapshot) : null) ?? "";
   }
   if (!objective) {
-    ctx.strategistState = { step: "objective_input", origin: opts.origin };
+    ctx.strategistState = { step: "objective_input", origin: opts.origin, mode: opts.mode };
     saveSessionState(ctx);
     console.log();
     console.log("  " + chalk17.dim('What is the objective? State a finish line. Example: "cut stale pipeline in half before Q4".'));
@@ -18876,7 +20234,7 @@ async function startStrategistFlow(ctx, opts) {
     recordMessage(ctx, "agent", "Strategist: asked for objective");
     return "Awaiting objective";
   }
-  ctx.strategistState = { step: "objective_confirm", objective, origin: opts.origin };
+  ctx.strategistState = { step: "objective_confirm", objective, origin: opts.origin, mode: opts.mode };
   saveSessionState(ctx);
   printObjectiveCard(ctx, objective, !opts.seed);
   recordMessage(ctx, "agent", `Strategist objective proposed: ${objective}`);
@@ -18889,7 +20247,8 @@ async function resumeStrategistAfterCompute(ctx) {
   console.log("  " + paint("accent", "Analysis is ready. The strategy session continues."));
   await startStrategistFlow(ctx, {
     seed: state2.objective,
-    origin: state2.origin ?? "nl"
+    origin: state2.origin ?? "nl",
+    mode: state2.mode
   });
 }
 function promptQueuedAiStrategist(ctx) {
@@ -18899,6 +20258,64 @@ function promptQueuedAiStrategist(ctx) {
   }
   printObjectiveCard(ctx, state2.objective, true);
 }
+function isKeepGoingIntent(input) {
+  return CRAFT_RE.test(input.trim());
+}
+async function handleKeepGoingLine(ctx, input) {
+  const line = input.trim();
+  recordMessage(ctx, "user", line);
+  const job = unfinishedCraftJob(ctx.lastCraftJobId);
+  if (!job) {
+    console.log();
+    console.log(
+      "  " + chalk17.dim("No plan in progress. Type ") + chalk17.cyan("how should we fix this?") + chalk17.dim(" to start one.")
+    );
+    console.log();
+    recordMessage(ctx, "agent", "No plan in progress");
+    return "No plan in progress";
+  }
+  if (!canUseReplAi(ctx)) {
+    console.log();
+    console.log(
+      "  " + chalk17.dim("Type ") + chalk17.cyan("/connect") + chalk17.dim(" to connect a key. Then type keep going.")
+    );
+    console.log();
+    recordMessage(ctx, "agent", "Keep going needs a key");
+    return "Keep going needs a key";
+  }
+  const spinner = makeSpinner("Working the plan\u2026");
+  try {
+    const result = await executeStrategistJob({
+      ctx,
+      objective: job.objective,
+      constraintsNote: job.constraints_note,
+      mode: "craft",
+      untilReady: true,
+      save: true,
+      handoff: true,
+      resumeId: job.id,
+      onEvent: (event) => {
+        if (event.type === "thinking") {
+          spinner.stop();
+          console.log("  " + chalk17.dim.italic(event.text));
+          spinner.start();
+          spinner.text = "Working the plan\u2026";
+        }
+      }
+    });
+    spinner.stop();
+    printCraftReplResult(ctx, result, job.objective);
+    ctx.strategistState = void 0;
+    saveSessionState(ctx);
+    return result.status === "ready" ? `Strategy crafted: ${result.plan?.title}` : "Strategy craft unfinished";
+  } catch (err) {
+    spinner.fail("Strategy craft failed");
+    console.error("  " + chalk17.red(String(err.message ?? err)));
+    ctx.strategistState = void 0;
+    saveSessionState(ctx);
+    return;
+  }
+}
 async function handleStrategizeFlow(input, ctx) {
   const state2 = ctx.strategistState;
   if (!state2) return;
@@ -18925,6 +20342,11 @@ async function handleStrategizeFlow(input, ctx) {
     printObjectiveCard(ctx, state2.objective, false);
     return "Objective proposed";
   }
+  if (CRAFT_RE.test(line)) {
+    state2.mode = "craft";
+    saveSessionState(ctx);
+    return runStrategistSession(ctx);
+  }
   if (CONFIRM_RE.test(line)) {
     return runStrategistSession(ctx);
   }
@@ -18975,7 +20397,7 @@ async function runStrategistSession(ctx) {
     saveSessionState(ctx);
     return "Skeleton plan (awaiting connect)";
   }
-  if (ctx.rl && !state2.constraintsNote) {
+  if (ctx.rl && !state2.constraintsNote && state2.mode !== "craft") {
     const prompts = createPromptSession(ctx.rl, ctx);
     try {
       const note = await prompts.ask(
@@ -18989,7 +20411,39 @@ async function runStrategistSession(ctx) {
     }
   }
   console.log();
-  const spinner = makeSpinner("Reading live data\u2026");
+  const spinner = makeSpinner(state2.mode === "craft" ? "Working the plan\u2026" : "Reading live data\u2026");
+  if (state2.mode === "craft") {
+    try {
+      const result = await executeStrategistJob({
+        ctx,
+        objective,
+        constraintsNote: state2.constraintsNote,
+        mode: "craft",
+        untilReady: true,
+        save: true,
+        handoff: true,
+        onEvent: (event) => {
+          if (event.type === "thinking") {
+            spinner.stop();
+            console.log("  " + chalk17.dim.italic(event.text));
+            spinner.start();
+            spinner.text = "Working the plan\u2026";
+          }
+        }
+      });
+      spinner.stop();
+      printCraftReplResult(ctx, result, objective);
+      ctx.strategistState = void 0;
+      saveSessionState(ctx);
+      return result.status === "ready" ? `Strategy crafted: ${result.plan?.title}` : "Strategy craft unfinished";
+    } catch (err) {
+      spinner.fail("Strategy craft failed");
+      console.error("  " + chalk17.red(String(err.message ?? err)));
+      ctx.strategistState = void 0;
+      saveSessionState(ctx);
+      return;
+    }
+  }
   let plan = null;
   let stats = { measurable_targets: 0, total_targets: 0 };
   let baselineBatchId = null;
@@ -19073,7 +20527,10 @@ async function runStrategistSession(ctx) {
   }
   if (saved) {
     try {
-      const persisted = await persistStrategistPlan(plan, { baselineBatchId });
+      const persisted = await persistStrategistPlan(plan, {
+        baselineBatchId,
+        constraintLine: formatConstraintLine(ctx.snapshot.computeResult?.aggregate)
+      });
       ctx.deliverables.push({
         kind: "strategy",
         at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -19121,19 +20578,54 @@ async function ensureSnapshot(ctx) {
     return null;
   }
 }
+function printCraftReplResult(ctx, result, objective) {
+  if (result.plan) {
+    printStrategyBrief(result.plan, {
+      measurable_targets: result.measurable_targets,
+      total_targets: result.total_targets
+    });
+  } else {
+    console.log("  " + chalk17.dim("(No plan produced)"));
+  }
+  for (const notice of result.notices.slice(0, 8)) {
+    if (!isCraftRoundNotice(notice)) console.log("  " + chalk17.dim(notice));
+  }
+  printLlmAttribution(result.usage);
+  if (result.library_path) creditStrategySession(ctx);
+  printCraftWrapUp({
+    status: result.status,
+    library_path: result.library_path,
+    inbox_path: result.inbox_path,
+    handoff_path: result.handoff_path,
+    slug: result.slug,
+    jobId: result.job?.id,
+    oneShot: false
+  });
+  if (result.library_path || result.handoff_path) {
+    recordMessage(ctx, "agent", `Strategy crafted: ${result.plan?.title ?? objective} (${result.status})`);
+  }
+}
 function printObjectiveCard(ctx, objective, proposed) {
+  const craftMode = ctx.strategistState?.mode === "craft";
   console.log();
   console.log("  " + chalk17.bold("Strategy session"));
   console.log(
     "  " + chalk17.dim(proposed ? "Proposed objective: " : "Objective: ") + paint("accent", objective)
   );
   console.log(
-    "  " + chalk17.dim("NTRP uses your live data. It sequences the work and sets measured milestones. It then stress-tests the plan.")
+    "  " + chalk17.dim(
+      craftMode ? "NTRP uses your live data. It keeps working until the plan is ready, then saves it and writes a handoff." : "NTRP uses your live data. It sequences the work and sets measured milestones. It then stress-tests the plan."
+    )
   );
   console.log();
   console.log(
     "  " + chalk17.dim("Confirm? ") + chalk17.cyan("\u23CE yes") + chalk17.dim(" \xB7 ") + chalk17.cyan("b back") + chalk17.dim(" \xB7 ") + chalk17.cyan("adjust") + chalk17.dim(" \xB7 ") + chalk17.cyan("cancel")
   );
+  if (!craftMode) {
+    console.log(
+      "  " + chalk17.dim("or type ") + chalk17.cyan("keep going") + chalk17.dim(" to keep working until the plan is ready")
+    );
+  }
   console.log();
 }
 async function printKeylessSkeletonPlan(ctx, objective) {
@@ -19195,7 +20687,7 @@ async function resumeStrategistAfterConnect(ctx) {
   printObjectiveCard(ctx, state2.objective, true);
   return true;
 }
-var STRATEGIST_INTENT_RE, CANCEL_RE, CONFIRM_RE, ADJUST_RE, QUESTION_RE;
+var STRATEGIST_INTENT_RE, CANCEL_RE, CONFIRM_RE, ADJUST_RE, QUESTION_RE, CRAFT_RE;
 var init_strategist_flow = __esm({
   "src/conversation/strategist-flow.ts"() {
     "use strict";
@@ -19209,15 +20701,18 @@ var init_strategist_flow = __esm({
     init_divergence();
     init_strategist();
     init_strategist2();
+    init_strategist_run();
     init_strategy_brief();
     init_llm_attribution();
     init_time_bank();
     init_formatters();
+    init_store3();
     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;
     CANCEL_RE = /^(cancel|stop|quit|abort|never\s?mind|nevermind|forget it)\s*[.!]?\s*$/i;
     CONFIRM_RE = /^(y|yes|yep|yeah|confirm|go|go ahead|do it|proceed|sounds good|looks good|lgtm|ok|okay)\b/i;
     ADJUST_RE = /^(n|no|adjust|change|edit|different|not quite|refine)\b/i;
     QUESTION_RE = /(\?\s*$)|^(what|why|how|when|which|where|who)\b/i;
+    CRAFT_RE = /^(craft|keep going|until tight|keep working)\b/i;
   }
 });
 
@@ -20247,8 +21742,8 @@ var init_bundle = __esm({
 });
 
 // src/repositories/markdown.ts
-import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
-import { basename as basename5, dirname as dirname5, join as join24, resolve as resolve8 } from "path";
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync16 } from "fs";
+import { basename as basename5, dirname as dirname5, join as join25, resolve as resolve8 } from "path";
 import { stringify as stringifyYaml2 } from "yaml";
 function renderMarkdownFiles(pkg) {
   const bundleJson = JSON.stringify(pkg, null, 2) + "\n";
@@ -20471,9 +21966,9 @@ var init_markdown2 = __esm({
         mkdirSync13(root, { recursive: true });
         const written = [];
         for (const file of files) {
-          const absolutePath = join24(root, file.relativePath);
+          const absolutePath = join25(root, file.relativePath);
           mkdirSync13(dirname5(absolutePath), { recursive: true });
-          writeFileSync15(absolutePath, file.contents, "utf-8");
+          writeFileSync16(absolutePath, file.contents, "utf-8");
           written.push(absolutePath);
         }
         return {
@@ -20576,7 +22071,7 @@ var init_publish = __esm({
 });
 
 // src/services/smoke-protocol.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function isSmokeProtocolTrigger(input) {
   return normalize(input).includes(SMOKE_TRIGGER_PHRASE);
 }
@@ -20612,7 +22107,7 @@ async function runSmokeProtocol(_input, ctx) {
   });
   const proposalResult = await proposeRepositoryExport({
     target: "markdown",
-    directory: join25(getExportsDir(), "repository-smoke"),
+    directory: join26(getExportsDir(), "repository-smoke"),
     source: "smoke_protocol",
     modelOrFixture: "smoke-protocol-v1"
   });
@@ -21352,7 +22847,7 @@ var init_scenario_fit = __esm({
 });
 
 // src/conversation/onboard-tiers.ts
-import { existsSync as existsSync24, statSync as statSync4 } from "fs";
+import { existsSync as existsSync25, statSync as statSync4 } from "fs";
 function flagSet(tier) {
   return Boolean(getConfigValue(TIER_CONFIG_KEYS[tier]));
 }
@@ -23975,18 +25470,18 @@ var init_generator = __esm({
 });
 
 // src/demo/taxonomy-cache.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync16, existsSync as existsSync25, mkdirSync as mkdirSync14, unlinkSync as unlinkSync4 } from "fs";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync17, existsSync as existsSync26, mkdirSync as mkdirSync14, unlinkSync as unlinkSync4 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function ensureDir6() {
-  if (!existsSync25(NTRP_DIR4)) {
+  if (!existsSync26(NTRP_DIR4)) {
     mkdirSync14(NTRP_DIR4, { recursive: true });
   }
 }
 function loadCachedTaxonomy(profile) {
-  if (!existsSync25(TAXONOMY_PATH)) return null;
+  if (!existsSync26(TAXONOMY_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync21(TAXONOMY_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync22(TAXONOMY_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     if (parsed.profile_updated_at !== profile.updated_at) return null;
     return parsed;
@@ -23996,14 +25491,14 @@ function loadCachedTaxonomy(profile) {
 }
 function saveCachedTaxonomy(taxonomy) {
   ensureDir6();
-  writeFileSync16(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
+  writeFileSync17(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
 }
 var NTRP_DIR4, TAXONOMY_PATH;
 var init_taxonomy_cache = __esm({
   "src/demo/taxonomy-cache.ts"() {
     "use strict";
-    NTRP_DIR4 = join26(homedir7(), ".ntrp");
-    TAXONOMY_PATH = join26(NTRP_DIR4, "demo-taxonomy.json");
+    NTRP_DIR4 = join27(homedir7(), ".ntrp");
+    TAXONOMY_PATH = join27(NTRP_DIR4, "demo-taxonomy.json");
   }
 });
 
@@ -24461,7 +25956,7 @@ __export(inbox_setup_exports, {
   shouldOfferInboxSkillSetup: () => shouldOfferInboxSkillSetup
 });
 import chalk27 from "chalk";
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 function markDemoOffered() {
   setConfigValue("ai-inbox-nudge-seen", "true");
 }
@@ -24493,7 +25988,7 @@ function printSkipHint(beat) {
 async function reuseInboxFolderIfPresent(session, beat, folderPath) {
   if (getAiInboxDir()) return false;
   const candidates = folderPath ? [folderPath] : [.../* @__PURE__ */ new Set([defaultAiInboxDir(), legacyAiInboxDir()])];
-  const existing = candidates.find((p) => existsSync26(p));
+  const existing = candidates.find((p) => existsSync27(p));
   if (!existing) return false;
   console.log("  " + chalk27.dim("Pickup folder still on disk: ") + existing);
   const reuse = await session.confirm("Reuse this pickup folder?", true);
@@ -24599,7 +26094,7 @@ __export(ingest_exports, {
   handler: () => handler3
 });
 import chalk28 from "chalk";
-import { readFileSync as readFileSync22, existsSync as existsSync27 } from "fs";
+import { readFileSync as readFileSync23, existsSync as existsSync28 } from "fs";
 import { basename as basename6 } from "path";
 async function handler3(args, ctx) {
   const { positional, flags } = parseArgs(args, [
@@ -24623,7 +26118,7 @@ async function handler3(args, ctx) {
     console.error(chalk28.dim("         /ingest --demo [--scenario <name>]"));
     process.exit(1);
   }
-  if (!existsSync27(file)) {
+  if (!existsSync28(file)) {
     console.error(chalk28.red(`  File not found: ${file}`));
     process.exit(1);
   }
@@ -24641,7 +26136,7 @@ async function handler3(args, ctx) {
   try {
     await initSchema();
     spinner.text = "Parsing CSV\u2026";
-    const content = readFileSync22(file, "utf-8");
+    const content = readFileSync23(file, "utf-8");
     const { rows, headers } = parseCSV(content);
     if (rows.length === 0) {
       spinner.fail("CSV is empty");
@@ -25011,8 +26506,8 @@ __export(ingest_chat_exports, {
   loadDemoFromChat: () => loadDemoFromChat,
   looksLikeFilePath: () => looksLikeFilePath
 });
-import { existsSync as existsSync28, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
-import { basename as basename7, join as join27, resolve as resolve9 } from "path";
+import { existsSync as existsSync29, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { basename as basename7, join as join28, resolve as resolve9 } from "path";
 import { homedir as homedir8 } from "os";
 import chalk30 from "chalk";
 function extractFilePath(input) {
@@ -25034,7 +26529,7 @@ function extractFilePath(input) {
     if (!candidate) continue;
     if (!looksLikePathToken(candidate)) continue;
     const p = expandPath(candidate);
-    if (existsSync28(p)) {
+    if (existsSync29(p)) {
       try {
         const st = statSync5(p);
         if (st.isFile() || st.isDirectory()) return p;
@@ -25063,7 +26558,7 @@ function looksLikeFilePath(input) {
 function listCsvsInFolder(dir) {
   try {
     if (!statSync5(dir).isDirectory()) return [];
-    return readdirSync6(dir).filter((name) => name.toLowerCase().endsWith(".csv")).map((name) => join27(dir, name)).sort();
+    return readdirSync6(dir).filter((name) => name.toLowerCase().endsWith(".csv")).map((name) => join28(dir, name)).sort();
   } catch {
     return [];
   }
@@ -25145,12 +26640,12 @@ async function ingestFromChat(ctx, filePath) {
   }
   const { handler: ingest } = await Promise.resolve().then(() => (init_ingest(), ingest_exports));
   const { detectEntityType: detectEntityType2 } = await Promise.resolve().then(() => (init_csv_detect(), csv_detect_exports));
-  const { readFileSync: readFileSync24 } = await import("fs");
+  const { readFileSync: readFileSync25 } = await import("fs");
   const { parseCSV: parseCSV2 } = await Promise.resolve().then(() => (init_csv_parse(), csv_parse_exports));
   const { getStoredApiKey } = await Promise.resolve().then(() => (init_repl_api(), repl_api_exports));
   let headerCheckFailed = false;
   try {
-    const raw = readFileSync24(filePath, "utf-8");
+    const raw = readFileSync25(filePath, "utf-8");
     const { headers } = parseCSV2(raw);
     const detected = detectEntityType2(headers, "unknown");
     if (!detected) headerCheckFailed = true;
@@ -26063,9 +27558,9 @@ async function handleGetSessionBrief(input) {
   if (!target) {
     return { error: `No session matching "${raw}".` };
   }
-  const { existsSync: existsSync30, readFileSync: readFileSync24 } = await import("fs");
+  const { existsSync: existsSync31, readFileSync: readFileSync25 } = await import("fs");
   const briefPath = contextDocPathForSession2(target.id);
-  if (!existsSync30(briefPath)) {
+  if (!existsSync31(briefPath)) {
     return {
       session_id: target.id,
       error: "No context brief on disk for this session (created before brief storage existed).",
@@ -26076,7 +27571,7 @@ async function handleGetSessionBrief(input) {
   return {
     session_id: target.id,
     security_notice: UNTRUSTED_CONTENT_NOTICE,
-    brief: wrapUntrustedContent(readFileSync24(briefPath, "utf-8"))
+    brief: wrapUntrustedContent(readFileSync25(briefPath, "utf-8"))
   };
 }
 function auditDenied(name, input, resultJson, start) {
@@ -27080,15 +28575,15 @@ var init_ask = __esm({
 });
 
 // src/services/setup.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync15, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync15, readFileSync as readFileSync24, writeFileSync as writeFileSync18 } from "fs";
+import { join as join29 } from "path";
 function setupCheck() {
   const home = ntrpHome();
   let writable = false;
   try {
     mkdirSync15(home, { recursive: true });
-    const probe = join28(home, ".write-check");
-    writeFileSync17(probe, "ok\n");
+    const probe = join29(home, ".write-check");
+    writeFileSync18(probe, "ok\n");
     writable = true;
   } catch {
     writable = false;