@sonnechasser/ntrp 1.5.2 → 1.5.7

package/dist/index.js

@@ -194,6 +194,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;
@@ -286,6 +297,7 @@ __export(store_exports, {
   getExportsDir: () => getExportsDir,
   getKnowledgeDir: () => getKnowledgeDir,
   getMemoryDir: () => getMemoryDir,
+  getRuminationsDir: () => getRuminationsDir,
   getStrategiesDir: () => getStrategiesDir,
   getWinsDir: () => getWinsDir,
   loadConfig: () => loadConfig,
@@ -429,6 +441,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)) {
@@ -1720,6 +1748,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) {
@@ -5622,6 +5652,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 }
     };
   }
@@ -7934,12 +7965,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,
@@ -7954,6 +8024,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}
@@ -8000,6 +8073,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._"}
 `;
@@ -8870,6 +9004,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") {
@@ -9224,6 +9359,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 {
@@ -9295,6 +9433,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;
@@ -12340,7 +12479,9 @@ var init_guide_slides = __esm({
       playbook: "loop",
       remember: "loop",
       sessions: "loop",
-      progress: "loop"
+      progress: "loop",
+      "keep-going": "loop",
+      keepgoing: "loop"
     };
     TALK = {
       id: "talk",
@@ -12391,7 +12532,7 @@ var init_guide_slides = __esm({
         "",
         '"what is our ARR?" or "why is this red?" need a loaded dataset. Narrative findings and /ask need a stored key \u2014 /connect pastes any provider key and we detect it.',
         "",
-        "Replay this tour with /deepdive, jump to one slide with /deepdive freshness (or nrr, arr, \u2026), or /deepdive guide for this how-to section. When the prompt shows a dim \u23CE hint (yes, use demo data, go ahead, /connect), bare Enter submits it \u2014 and b / back steps back one confirm gate (or the previous tour slide while you're in /deepdive)."
+        "Replay this tour with /deepdive, jump to one slide with /deepdive freshness (or nrr, arr, \u2026), or /deepdive guide for this how-to section. When the prompt shows a dim \u23CE hint (yes, use demo data, go ahead, /connect, keep going), bare Enter submits it \u2014 and b / back steps back one confirm gate (or the previous tour slide while you're in /deepdive)."
       ],
       deepdive: [
         "/connect ollama for a keyless local model. /connect --base-url <url> --id <name> for any OpenAI-compatible endpoint.",
@@ -12437,13 +12578,15 @@ var init_guide_slides = __esm({
         caption: "Stethoscope, not hospital \u2014 we observe and recommend; you decide the surgery.",
         layers: [
           { label: "Listen  (/diagnose, /metrics)" },
-          { label: 'Plan  ("how should we fix this?" / /strategy)', highlight: true },
+          { label: 'Plan  ("how should we fix this?" \xB7 keep going)', highlight: true },
           { label: "Review  (/strategy review, /playbook)" },
           { label: "Remember  (/remember, /rate, ANALYST.md)" }
         ]
       },
       lines: [
-        'The learning loop is how we stay useful after the first diagnose. "how should we fix this?" or /strategy builds a measurable plan with milestones and dollar-anchored ranges; /strategy review checks those against later vital signs.',
+        `After a diagnose we don't stop at the score. "how should we fix this?" or /strategy opens a strategy session: we work back from an objective into sequenced workstreams with dated milestones and dollar-anchored ranges.`,
+        "",
+        "At the confirm card, \u23CE yes builds that plan once. Type keep going to keep working until the plan is ready \u2014 the same armed-Enter pattern as use demo data and go ahead. If you see Best so far, the prompt returns to \u203A and \u23CE keep going continues. Plan ready? Type /strategy review later to check milestones against new vitals.",
         "",
         "When a vital is red, /playbook names a matching play \u2014 and outcomes from reviews annotate the catalog with what actually hit here. /remember stores a durable fact; /rate bad <reason> writes a calibration. Optional ~/.ntrp/ANALYST.md is standing voice and priorities (it never overrides safety rules).",
         "",
@@ -12451,6 +12594,7 @@ var init_guide_slides = __esm({
       ],
       deepdive: [
         '"build me a game plan" before analysis queues the strategist and resumes after compute.',
+        "An unfinished plan arms \u23CE keep going on \u203A. No plan in progress? Type how should we fix this? to start one.",
         "Interactive sessions distill 5 or fewer durable facts on close when an LLM key is stored. One-shot commands do not bank hours or distill.",
         "/scratch factory-resets data and config. progress.json and install.json survive unless you pass --include-progress.",
         "Credits in /progress accrue in interactive ntrp only."
@@ -12880,7 +13024,7 @@ var init_metric_tour = __esm({
       "/metrics   \u2014 SaaS scorecard (ARR, NRR, coverage\u2026)",
       "/deepdive  \u2014 replay this tour  \xB7  /deepdive guide  how-to only",
       "/handoff   \u2014 ship a file; teach the inbox once (/inbox skill)",
-      "/strategy  \u2014 measurable plan  \xB7  /help  shortcuts",
+      "/strategy  \u2014 measurable plan  \xB7  keep going until it's ready  \xB7  /help  shortcuts",
       "",
       "Fourteen more SaaS metrics sit behind /deepdive list \u2014 including unit economics that unlock when spend data lands.",
       "",
@@ -15499,14 +15643,324 @@ var init_explore_mode = __esm({
   }
 });
 
+// src/config/update-check.ts
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync17, unlinkSync as unlinkSync4, writeFileSync as writeFileSync14 } from "fs";
+import { join as join21 } from "path";
+function cachePath2() {
+  return join21(ntrpHome(), "update-check.json");
+}
+function ensureDir6() {
+  const dir = ntrpHome();
+  if (!existsSync21(dir)) {
+    mkdirSync12(dir, { recursive: true });
+  }
+}
+function loadUpdateCheckCache() {
+  const path = cachePath2();
+  if (!existsSync21(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync17(path, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || typeof parsed.lastCheck !== "number" || typeof parsed.latestVersion !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveUpdateCheckCache(cache2) {
+  ensureDir6();
+  writeFileSync14(cachePath2(), JSON.stringify(cache2, null, 2) + "\n");
+}
+function isCacheFresh(cache2, ttlMs = CACHE_TTL_MS2) {
+  if (!cache2) return false;
+  return Date.now() - cache2.lastCheck < ttlMs;
+}
+function invalidateUpdateCheckCache() {
+  const path = cachePath2();
+  if (existsSync21(path)) {
+    unlinkSync4(path);
+  }
+}
+var CACHE_TTL_MS2;
+var init_update_check = __esm({
+  "src/config/update-check.ts"() {
+    "use strict";
+    init_store();
+    CACHE_TTL_MS2 = 864e5;
+  }
+});
+
+// src/version.ts
+import { existsSync as existsSync22, readFileSync as readFileSync18 } from "fs";
+import { dirname as dirname4, join as join22 } from "path";
+import { fileURLToPath } from "url";
+function readVersionFromPackageJson(packageJsonPath) {
+  if (!existsSync22(packageJsonPath)) return null;
+  try {
+    const pkg = JSON.parse(readFileSync18(packageJsonPath, "utf-8"));
+    if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+  } catch {
+  }
+  return null;
+}
+function readVersionNearEntry(entryPath) {
+  const start = dirname4(entryPath);
+  for (const rel of [join22(start, "..", "package.json"), join22(start, "../..", "package.json")]) {
+    const version = readVersionFromPackageJson(rel);
+    if (version) return version;
+  }
+  return null;
+}
+function readInstalledVersionFromDisk() {
+  return readVersionNearEntry(fileURLToPath(import.meta.url));
+}
+function getInstalledVersion() {
+  if (cachedVersion) return cachedVersion;
+  cachedVersion = readInstalledVersionFromDisk() ?? "0.0.0";
+  return cachedVersion;
+}
+var cachedVersion;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+  }
+});
+
+// src/update/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  NPM_PACKAGE: () => NPM_PACKAGE,
+  applyUpdateCheckResult: () => applyUpdateCheckResult,
+  checkForUpdate: () => checkForUpdate,
+  fetchLatestVersion: () => fetchLatestVersion,
+  formatUpdateNudge: () => formatUpdateNudge,
+  hasAvailableUpdate: () => hasAvailableUpdate,
+  hydrateUpdateAvailableFromCache: () => hydrateUpdateAvailableFromCache,
+  isNewerVersion: () => isNewerVersion,
+  startBackgroundUpdateCheck: () => startBackgroundUpdateCheck
+});
+function registryUrl() {
+  return process.env.NTRP_REGISTRY_URL ?? "https://registry.npmjs.org/@sonnechasser/ntrp/latest";
+}
+function parseVersionParts(version) {
+  const cleaned = version.trim().replace(/^v/i, "");
+  const core = cleaned.split("-")[0] ?? cleaned;
+  const parts = core.split(".").map((p) => parseInt(p, 10));
+  return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+function isNewerVersion(latest, current) {
+  const [lMaj, lMin, lPatch] = parseVersionParts(latest);
+  const [cMaj, cMin, cPatch] = parseVersionParts(current);
+  if (lMaj !== cMaj) return lMaj > cMaj;
+  if (lMin !== cMin) return lMin > cMin;
+  return lPatch > cPatch;
+}
+function formatUpdateNudge(current, latest) {
+  return `\u26A1 NTRP v${latest} available (running v${current}) \u2014 \u23CE /update`;
+}
+function hasAvailableUpdate(update) {
+  return Boolean(update && isNewerVersion(update.latest, update.current));
+}
+function hydrateUpdateAvailableFromCache(current) {
+  const cached2 = loadUpdateCheckCache();
+  if (!cached2?.latestVersion) return void 0;
+  if (!isNewerVersion(cached2.latestVersion, current)) return void 0;
+  return { current, latest: cached2.latestVersion };
+}
+function applyUpdateCheckResult(ctx, result) {
+  if (result?.updateAvailable) {
+    ctx.updateAvailable = { current: result.current, latest: result.latest };
+    return;
+  }
+  if (result && !result.updateAvailable) {
+    ctx.updateAvailable = void 0;
+  }
+}
+function startBackgroundUpdateCheck(ctx) {
+  const pending = checkForUpdate({ force: true, timeoutMs: 5e3 });
+  ctx.pendingUpdateCheck = pending;
+  void pending.then((result) => applyUpdateCheckResult(ctx, result)).catch(() => void 0);
+}
+async function fetchLatestVersion(timeoutMs = 5e3) {
+  try {
+    const res = await fetch(registryUrl(), { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" && data.version.length > 0 ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+function buildResult(current, latest) {
+  return {
+    current,
+    latest,
+    updateAvailable: isNewerVersion(latest, current)
+  };
+}
+async function checkForUpdate(options) {
+  const current = getInstalledVersion();
+  const timeoutMs = options?.timeoutMs ?? 5e3;
+  const cached2 = loadUpdateCheckCache();
+  if (!options?.force && isCacheFresh(cached2)) {
+    return buildResult(current, cached2.latestVersion);
+  }
+  const latest = await fetchLatestVersion(timeoutMs);
+  if (!latest) {
+    if (cached2?.latestVersion) {
+      return buildResult(current, cached2.latestVersion);
+    }
+    return null;
+  }
+  const nextCache = { lastCheck: Date.now(), latestVersion: latest };
+  saveUpdateCheckCache(nextCache);
+  return buildResult(current, latest);
+}
+var NPM_PACKAGE;
+var init_registry = __esm({
+  "src/update/registry.ts"() {
+    "use strict";
+    init_update_check();
+    init_version();
+    NPM_PACKAGE = "@sonnechasser/ntrp";
+  }
+});
+
+// src/ruminations/store.ts
+import { existsSync as existsSync23, readFileSync as readFileSync19, writeFileSync as writeFileSync15 } from "fs";
+import { join as join23 } from "path";
+import { randomUUID as randomUUID7 } from "crypto";
+function makeRuminationId(now2 = /* @__PURE__ */ new Date()) {
+  const day = now2.toISOString().slice(0, 10).replace(/-/g, "");
+  return `${day}-${randomUUID7().slice(0, 4)}`;
+}
+function ruminationJsonPath(id) {
+  return join23(getRuminationsDir(), `${id}.json`);
+}
+function ruminationLogPath(id) {
+  return join23(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 (!existsSync23(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync19(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" };
@@ -15517,6 +15971,8 @@ function resolveRecommendedAction(ctx) {
       return ctx.strategistState?.step === "objective_confirm" ? { submit: "yes", hint: "yes" } : null;
     case "think":
       return null;
+    case "orient":
+      return hasAvailableUpdate(ctx.updateAvailable) ? { submit: "/update", hint: "/update" } : null;
     default:
       return null;
   }
@@ -15526,7 +15982,9 @@ var init_recommended_action = __esm({
     "use strict";
     init_repl_api();
     init_activation();
+    init_registry();
     init_phase();
+    init_store3();
   }
 });
 
@@ -16324,17 +16782,17 @@ __export(play_outcomes_exports, {
   listPlayOutcomes: () => listPlayOutcomes,
   recordPlayOutcomes: () => recordPlayOutcomes
 });
-import { existsSync as existsSync21, readFileSync as readFileSync17, appendFileSync as appendFileSync6 } from "fs";
-import { join as join21 } from "path";
-import { randomUUID as randomUUID7 } from "crypto";
+import { existsSync as existsSync24, readFileSync as readFileSync20, appendFileSync as appendFileSync6 } from "fs";
+import { join as join24 } from "path";
+import { randomUUID as randomUUID8 } from "crypto";
 function outcomesPath() {
-  return join21(getMemoryDir(), OUTCOMES_FILE);
+  return join24(getMemoryDir(), OUTCOMES_FILE);
 }
 function listPlayOutcomes() {
   const path = outcomesPath();
-  if (!existsSync21(path)) return [];
+  if (!existsSync24(path)) return [];
   const out = [];
-  for (const line of readFileSync17(path, "utf-8").split("\n")) {
+  for (const line of readFileSync20(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -16364,7 +16822,7 @@ function recordPlayOutcomes(strategy, outcomes, batchId) {
       if (seen.has(key)) continue;
       seen.add(key);
       const record = {
-        id: randomUUID7(),
+        id: randomUUID8(),
         play_id: playId,
         strategy_slug: strategy.slug,
         workstream_order: outcome.workstream_order,
@@ -16427,11 +16885,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 } : {}
@@ -16447,8 +16905,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);
@@ -19801,18 +20259,18 @@ var init_terminal = __esm({
 });
 
 // src/demo/taxonomy-cache.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync14, existsSync as existsSync22, mkdirSync as mkdirSync12, unlinkSync as unlinkSync4 } from "fs";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync16, existsSync as existsSync25, mkdirSync as mkdirSync13, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join22 } from "path";
-function ensureDir6() {
-  if (!existsSync22(NTRP_DIR4)) {
-    mkdirSync12(NTRP_DIR4, { recursive: true });
+import { join as join25 } from "path";
+function ensureDir7() {
+  if (!existsSync25(NTRP_DIR4)) {
+    mkdirSync13(NTRP_DIR4, { recursive: true });
   }
 }
 function loadCachedTaxonomy(profile) {
-  if (!existsSync22(TAXONOMY_PATH)) return null;
+  if (!existsSync25(TAXONOMY_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync18(TAXONOMY_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync21(TAXONOMY_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     if (parsed.profile_updated_at !== profile.updated_at) return null;
     return parsed;
@@ -19821,13 +20279,13 @@ function loadCachedTaxonomy(profile) {
   }
 }
 function saveCachedTaxonomy(taxonomy) {
-  ensureDir6();
-  writeFileSync14(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
+  ensureDir7();
+  writeFileSync16(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
 }
 function invalidateTaxonomy() {
-  if (existsSync22(TAXONOMY_PATH)) {
+  if (existsSync25(TAXONOMY_PATH)) {
     try {
-      unlinkSync4(TAXONOMY_PATH);
+      unlinkSync5(TAXONOMY_PATH);
     } catch {
     }
   }
@@ -19836,8 +20294,8 @@ var NTRP_DIR4, TAXONOMY_PATH;
 var init_taxonomy_cache = __esm({
   "src/demo/taxonomy-cache.ts"() {
     "use strict";
-    NTRP_DIR4 = join22(homedir7(), ".ntrp");
-    TAXONOMY_PATH = join22(NTRP_DIR4, "demo-taxonomy.json");
+    NTRP_DIR4 = join25(homedir7(), ".ntrp");
+    TAXONOMY_PATH = join25(NTRP_DIR4, "demo-taxonomy.json");
   }
 });
 
@@ -20295,7 +20753,7 @@ __export(inbox_setup_exports, {
   shouldOfferInboxSkillSetup: () => shouldOfferInboxSkillSetup
 });
 import chalk19 from "chalk";
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 function markDemoOffered() {
   setConfigValue("ai-inbox-nudge-seen", "true");
 }
@@ -20327,7 +20785,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) => existsSync23(p));
+  const existing = candidates.find((p) => existsSync26(p));
   if (!existing) return false;
   console.log("  " + chalk19.dim("Pickup folder still on disk: ") + existing);
   const reuse = await session.confirm("Reuse this pickup folder?", true);
@@ -20433,7 +20891,7 @@ __export(ingest_exports, {
   handler: () => handler2
 });
 import chalk20 from "chalk";
-import { readFileSync as readFileSync19, existsSync as existsSync24 } from "fs";
+import { readFileSync as readFileSync22, existsSync as existsSync27 } from "fs";
 import { basename as basename6 } from "path";
 async function handler2(args, ctx) {
   const { positional, flags } = parseArgs2(args, [
@@ -20457,7 +20915,7 @@ async function handler2(args, ctx) {
     console.error(chalk20.dim("         /ingest --demo [--scenario <name>]"));
     process.exit(1);
   }
-  if (!existsSync24(file)) {
+  if (!existsSync27(file)) {
     console.error(chalk20.red(`  File not found: ${file}`));
     process.exit(1);
   }
@@ -20475,7 +20933,7 @@ async function handler2(args, ctx) {
   try {
     await initSchema();
     spinner.text = "Parsing CSV\u2026";
-    const content = readFileSync19(file, "utf-8");
+    const content = readFileSync22(file, "utf-8");
     const { rows, headers } = parseCSV(content);
     if (rows.length === 0) {
       spinner.fail("CSV is empty");
@@ -22842,9 +23300,9 @@ async function handleGetSessionBrief(input) {
   if (!target) {
     return { error: `No session matching "${raw}".` };
   }
-  const { existsSync: existsSync38, readFileSync: readFileSync24 } = await import("fs");
+  const { existsSync: existsSync39, readFileSync: readFileSync25 } = await import("fs");
   const briefPath = contextDocPathForSession2(target.id);
-  if (!existsSync38(briefPath)) {
+  if (!existsSync39(briefPath)) {
     return {
       session_id: target.id,
       error: "No context brief on disk for this session (created before brief storage existed).",
@@ -22855,7 +23313,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) {
@@ -23388,7 +23846,9 @@ function buildSituationalAwarenessBlock(ctx, opts = {}) {
     );
   } else if (phase === "orient") {
     lines.push("Already done: nothing locked yet");
-    lines.push("Available now: help the user name a focus; CLI will propose scope from their words");
+    lines.push(
+      "Available now: help the user name a focus; CLI will propose scope from their words. If \u23CE /update is armed, the CLI owns the install confirm \u2014 do not re-ask about updating"
+    );
   } else if (phase === "think") {
     lines.push("Already done: analysis complete; think channel open");
     lines.push("Available now: socratic exploration; draft_strategy / draft_handoff when ready to graduate");
@@ -25159,7 +25619,7 @@ __export(onboard_tiers_exports, {
   resetOnboardTierProgress: () => resetOnboardTierProgress,
   resolveNextOnboardTier: () => resolveNextOnboardTier
 });
-import { existsSync as existsSync25, statSync as statSync4 } from "fs";
+import { existsSync as existsSync28, statSync as statSync4 } from "fs";
 function flagSet(tier) {
   return Boolean(getConfigValue(TIER_CONFIG_KEYS[tier]));
 }
@@ -25186,7 +25646,7 @@ function hasProductionDataset(ctx) {
     if (source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source) || source.startsWith("~")) {
       return true;
     }
-    if (!source.includes(":") && existsSync25(source)) return true;
+    if (!source.includes(":") && existsSync28(source)) return true;
     if (source.startsWith("csv:") || source.startsWith("file:") || source.startsWith("folder:")) {
       return true;
     }
@@ -25245,7 +25705,7 @@ function markDemoDataSeen() {
 }
 function pathLooksPresent(raw) {
   try {
-    return existsSync25(raw) && (statSync4(raw).isFile() || statSync4(raw).isDirectory());
+    return existsSync28(raw) && (statSync4(raw).isFile() || statSync4(raw).isDirectory());
   } catch {
     return false;
   }
@@ -25650,7 +26110,7 @@ __export(onboard_exports, {
   profileExists: () => profileExists
 });
 import chalk25 from "chalk";
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { basename as basename7 } from "path";
 async function handler5(args, ctx) {
   const { flags } = parseArgs2(args, ["force", "skip-brand"]);
@@ -25925,7 +26385,7 @@ async function runProductionTier(session, ctx) {
     return "Production data skipped";
   }
   const resolved = resolveUserPath(trimmed);
-  if (!existsSync26(resolved)) {
+  if (!existsSync29(resolved)) {
     console.log("  " + chalk25.red(`Path not found: ${resolved}`));
     console.log("  " + chalk25.dim("Try again with /onboard, or drop the path into the REPL."));
     return "Production path not found";
@@ -26332,7 +26792,7 @@ __export(new_exports, {
   handler: () => handler6
 });
 import chalk26 from "chalk";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import { basename as basename8 } from "path";
 async function handler6(args, ctx) {
   const { positional, flags } = parseArgs2(args, ["demo", "empty", "list-scenarios", "regen-taxonomy"]);
@@ -26354,7 +26814,7 @@ async function handler6(args, ctx) {
     console.error(chalk26.red("  Usage: /new <file.csv> | --demo [--scenario <name>] | --empty [--lens health|metrics]"));
     return;
   }
-  if (source.kind === "file" && !existsSync27(source.path)) {
+  if (source.kind === "file" && !existsSync30(source.path)) {
     console.error(chalk26.red(`  File not found: ${source.path}`));
     return;
   }
@@ -26581,7 +27041,7 @@ __export(end_exports, {
   handler: () => handler7
 });
 import chalk27 from "chalk";
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 async function handler7(args, ctx) {
   if (args.length > 0) {
     console.error(chalk27.red("  Usage: /end"));
@@ -26618,10 +27078,10 @@ async function handler7(args, ctx) {
   if (summary) {
     console.log("  " + chalk27.dim(summary));
   }
-  if (existsSync28(transcriptPathForSession(endedId))) {
+  if (existsSync31(transcriptPathForSession(endedId))) {
     console.log("  " + chalk27.dim("Transcript: ") + chalk27.dim(transcriptPathForSession(endedId)));
   }
-  if (existsSync28(contextDocPathForSession(endedId))) {
+  if (existsSync31(contextDocPathForSession(endedId))) {
     console.log("  " + chalk27.dim("Context brief: ") + chalk27.dim(contextDocPathForSession(endedId)));
   }
   console.log();
@@ -26642,8 +27102,8 @@ __export(session_exports, {
   handler: () => handler8
 });
 import chalk28 from "chalk";
-import { join as join23 } from "path";
-import { existsSync as existsSync29 } from "fs";
+import { join as join26 } from "path";
+import { existsSync as existsSync32 } from "fs";
 async function handler8(args, ctx) {
   const sub = args[0];
   if (!sub) return listSessionsView(ctx);
@@ -26746,7 +27206,7 @@ async function pickUp(idArg, ctx) {
   }
   resetContextForSwitch(ctx, {
     sessionId: target.id,
-    sessionFile: join23(getSessionsDir(), `${target.id}.json`),
+    sessionFile: join26(getSessionsDir(), `${target.id}.json`),
     sessionName: session.name,
     messages: [...session.messages],
     conversation: session.thread ? [...session.thread] : [],
@@ -26761,7 +27221,8 @@ async function pickUp(idArg, ctx) {
     llm: session.llm ? { ...session.llm } : void 0,
     strategistState: session.strategist,
     thinkState: session.think,
-    pendingAsk: session.pending_ask
+    pendingAsk: session.pending_ask,
+    lastCraftJobId: session.last_craft_job_id
   });
   ctx.datasetPath = datasetPathForSession(target.id);
   await setActiveDbPath(ctx.datasetPath);
@@ -26779,7 +27240,11 @@ async function pickUp(idArg, ctx) {
   if (session.strategist && session.strategist.step !== "awaiting_analysis") {
     const objective = session.strategist.objective;
     console.log(
-      "  " + chalk28.yellow("Resuming mid-strategy") + (objective ? chalk28.dim(`: "${objective}"`) : "") + chalk28.dim(" \u2014 Confirm? ") + chalk28.cyan("\u23CE yes") + chalk28.dim(" \xB7 ") + chalk28.cyan("cancel") + chalk28.dim(" to drop it.")
+      "  " + chalk28.yellow("Resuming mid-strategy") + (objective ? chalk28.dim(`: "${objective}"`) : "") + chalk28.dim(" \u2014 Confirm? ") + chalk28.cyan("\u23CE yes") + (session.strategist.mode === "craft" ? chalk28.dim(" \xB7 keep going") : "") + chalk28.dim(" \xB7 ") + chalk28.cyan("cancel") + chalk28.dim(" to drop it.")
+    );
+  } else if (unfinishedCraftJob(session.last_craft_job_id)) {
+    console.log(
+      "  " + chalk28.dim("Plan in progress \u2014 type ") + chalk28.cyan("keep going") + chalk28.dim(" to continue.")
     );
   }
   if (session.think && session.think.step === "active") {
@@ -26789,7 +27254,7 @@ async function pickUp(idArg, ctx) {
     );
   }
   const contextPath = contextDocPathForSession(target.id);
-  if (existsSync29(contextPath)) {
+  if (existsSync32(contextPath)) {
     console.log("  " + chalk28.dim("Context brief: ") + chalk28.dim(contextPath));
   }
   console.log();
@@ -26804,6 +27269,7 @@ var init_session = __esm({
     init_connection();
     init_theme();
     init_layout();
+    init_store3();
     GENERIC_DATASET_RE = /^(demo dataset|.*\bdemo)$/i;
   }
 });
@@ -27080,8 +27546,8 @@ __export(report_exports, {
   handler: () => handler9
 });
 import chalk29 from "chalk";
-import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname4 } from "path";
+import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname5 } from "path";
 async function handler9(args, ctx) {
   const { flags } = parseArgs2(args);
   const format = getString(flags, "format", "f") ?? getConfigValue("default-format") ?? "terminal";
@@ -27174,10 +27640,10 @@ async function handler9(args, ctx) {
     if (output) {
       const resolvedOutput = resolveUserPath(output);
       if (!isInsideNtrp(resolvedOutput)) {
-        console.warn(chalk29.yellow(`  Warning: writing report outside NTRP home (${dirname4(resolvedOutput)})`));
+        console.warn(chalk29.yellow(`  Warning: writing report outside NTRP home (${dirname5(resolvedOutput)})`));
       }
-      mkdirSync13(dirname4(resolvedOutput), { recursive: true });
-      writeFileSync15(resolvedOutput, rendered);
+      mkdirSync14(dirname5(resolvedOutput), { recursive: true });
+      writeFileSync17(resolvedOutput, rendered);
       console.log(chalk29.green(`  Report written to ${resolvedOutput}`));
     } else if (rendered) {
       console.log(rendered);
@@ -27208,8 +27674,8 @@ var init_report2 = __esm({
 });
 
 // src/output/notes-export.ts
-import { mkdirSync as mkdirSync14 } from "fs";
-import { join as join24 } from "path";
+import { mkdirSync as mkdirSync15 } from "fs";
+import { join as join27 } from "path";
 function exportToNotes(data) {
   const { computeResult, divergences, findings, exchanges } = data;
   const { aggregate, segments } = computeResult;
@@ -27218,8 +27684,8 @@ function exportToNotes(data) {
   const timeStr = formatTime(now2);
   const filename = `${dateStr}-${timeStr}-gtm-health.md`;
   const dir = data.dir ?? getArchiveKindDir("notes");
-  mkdirSync14(dir, { recursive: true });
-  const filepath = join24(dir, filename);
+  mkdirSync15(dir, { recursive: true });
+  const filepath = join27(dir, filename);
   const severityTags = /* @__PURE__ */ new Set();
   for (const f of findings) severityTags.add(f.severity);
   const tags = ["ntrp", "gtm-health", ...severityTags];
@@ -27464,8 +27930,8 @@ __export(backmeup_exports, {
 });
 import chalk31 from "chalk";
 import Papa5 from "papaparse";
-import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync16 } from "fs";
-import { join as join25 } from "path";
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync18 } from "fs";
+import { join as join28 } from "path";
 function sanitizeCsvValue(value) {
   if (typeof value !== "string") return value;
   return CSV_FORMULA_RE.test(value) ? `'${value}` : value;
@@ -27501,8 +27967,8 @@ async function handler11(args, _ctx) {
     if (!isInsideNtrp(baseDir)) {
       console.warn(chalk31.yellow(`  Warning: writing backup outside NTRP home (${baseDir})`));
     }
-    const folder = join25(baseDir, folderName);
-    mkdirSync15(folder, { recursive: true });
+    const folder = join28(baseDir, folderName);
+    mkdirSync16(folder, { recursive: true });
     const generatedAt = now2.toISOString();
     let fileCount = 0;
     const coverRows = health.vital_signs.map((vs) => ({
@@ -27516,7 +27982,7 @@ async function handler11(args, _ctx) {
       "Total At Risk": health.total_value_at_risk != null ? formatCurrency(health.total_value_at_risk) : "N/A",
       "Generated At": generatedAt
     }));
-    writeFileSync16(join25(folder, "cover-sheet.csv"), Papa5.unparse(sanitizeCsvRows(coverRows)), "utf-8");
+    writeFileSync18(join28(folder, "cover-sheet.csv"), Papa5.unparse(sanitizeCsvRows(coverRows)), "utf-8");
     fileCount++;
     if (findings.length > 0) {
       const findingsRows = findings.map((f) => ({
@@ -27526,7 +27992,7 @@ async function handler11(args, _ctx) {
         Finding: f.finding,
         "Recommended Plays": f.recommended_plays ? f.recommended_plays.map((p) => p.play_name).join("; ") : ""
       }));
-      writeFileSync16(join25(folder, "findings.csv"), Papa5.unparse(sanitizeCsvRows(findingsRows)), "utf-8");
+      writeFileSync18(join28(folder, "findings.csv"), Papa5.unparse(sanitizeCsvRows(findingsRows)), "utf-8");
       fileCount++;
     }
     for (const vs of health.vital_signs) {
@@ -27536,7 +28002,7 @@ async function handler11(args, _ctx) {
         ...detail
       }));
       const filename = EVIDENCE_FILENAMES[vs.vital_sign] ?? `${vs.vital_sign}.csv`;
-      writeFileSync16(join25(folder, filename), Papa5.unparse(sanitizeCsvRows(rows)), "utf-8");
+      writeFileSync18(join28(folder, filename), Papa5.unparse(sanitizeCsvRows(rows)), "utf-8");
       fileCount++;
     }
     const event = recordExportWrite({
@@ -27740,8 +28206,8 @@ var init_bundle = __esm({
 });
 
 // src/repositories/markdown.ts
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync17 } from "fs";
-import { basename as basename9, dirname as dirname5, join as join26, resolve as resolve8 } from "path";
+import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync19 } from "fs";
+import { basename as basename9, dirname as dirname6, join as join29, resolve as resolve8 } from "path";
 import { stringify as stringifyYaml2 } from "yaml";
 function renderMarkdownFiles(pkg) {
   const bundleJson = JSON.stringify(pkg, null, 2) + "\n";
@@ -27961,12 +28427,12 @@ var init_markdown3 = __esm({
       write(pkg) {
         const root = getRootPath(pkg.target);
         const files = renderMarkdownFiles(pkg);
-        mkdirSync16(root, { recursive: true });
+        mkdirSync17(root, { recursive: true });
         const written = [];
         for (const file of files) {
-          const absolutePath = join26(root, file.relativePath);
-          mkdirSync16(dirname5(absolutePath), { recursive: true });
-          writeFileSync17(absolutePath, file.contents, "utf-8");
+          const absolutePath = join29(root, file.relativePath);
+          mkdirSync17(dirname6(absolutePath), { recursive: true });
+          writeFileSync19(absolutePath, file.contents, "utf-8");
           written.push(absolutePath);
         }
         return {
@@ -28270,7 +28736,7 @@ __export(handoff_exports, {
   handler: () => handler13
 });
 import chalk33 from "chalk";
-import { join as join27 } from "path";
+import { join as join30 } from "path";
 async function handler13(args, ctx) {
   const sub = args[0];
   if (!sub) {
@@ -28370,7 +28836,7 @@ async function runPublish2(args, ctx) {
   );
   if (sub === "propose" && !hasDir) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const dir = join27(getArchiveKindDir("publish"), `ntrp-repository-${stamp}`);
+    const dir = join30(getArchiveKindDir("publish"), `ntrp-repository-${stamp}`);
     publishArgs.push("--dir", dir);
   }
   const result = await publish(publishArgs, ctx);
@@ -29145,150 +29611,6 @@ var init_segment = __esm({
   }
 });
 
-// src/services/strategist.ts
-import { createHash as createHash2 } from "crypto";
-function serializeGapAudit(audit) {
-  const lines = [`Can compute: ${audit.can_compute} (lens: ${audit.primary_lens})`];
-  for (const item of audit.satisfied) {
-    lines.push(`- HAVE ${item.label}: ${item.detail}`);
-  }
-  for (const item of audit.missing) {
-    lines.push(`- MISSING ${item.label}: ${item.why}`);
-  }
-  for (const item of audit.optional) {
-    lines.push(`- LIMITED ${item.label}: ${item.detail}`);
-  }
-  return lines.join("\n");
-}
-async function prepareStrategistInputs(ctx, objective) {
-  let snapshot = ctx.snapshot.computeResult;
-  if (!snapshot) {
-    snapshot = await computeFullHealth();
-    ctx.snapshot.computeResult = snapshot;
-    const divInput = snapshot.segments.map((s) => ({
-      segmentId: s.segment.id,
-      segmentName: s.segment.name,
-      result: s.result
-    }));
-    ctx.snapshot.divergences = detectDivergences(snapshot.aggregate, divInput).divergences;
-  }
-  const audit = ctx.gapAudit ?? await refreshGapAudit(ctx).catch(() => null);
-  const gapAuditBlock = audit ? serializeGapAudit(audit) : "";
-  const memoryBlock = await Promise.resolve().then(() => (init_store2(), store_exports2)).then((m) => m.buildMemoryBlock(objective)).catch(() => "");
-  let baselineBatchId = null;
-  try {
-    const reading = await getLatestHealthReading();
-    baselineBatchId = reading?.upload_batch_id ?? null;
-  } catch {
-  }
-  return {
-    snapshot,
-    divergences: ctx.snapshot.divergences,
-    gapAuditBlock,
-    memoryBlock,
-    baselineBatchId,
-    includeMetrics: true
-  };
-}
-function proposeObjectiveFromSnapshot(snapshot) {
-  const { aggregate } = snapshot;
-  const gating = aggregate.gating_vital_sign;
-  if (!gating) return null;
-  const vital = aggregate.vital_signs.find((v) => v.vital_sign === gating);
-  if (!vital) return null;
-  const label = VITAL_SIGN_LABELS[gating] ?? gating;
-  const dollar = vital.dollar_value != null && vital.dollar_value > 0 ? ` and recover the ${formatCurrency(vital.dollar_value)} ${vital.dollar_label ?? "at stake"}` : "";
-  return `Move ${label} from ${Math.round(vital.score)} to 60+${dollar} within 60 days`;
-}
-function slugify2(value) {
-  const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
-  return slug || `strategy-${Date.now()}`;
-}
-function outcomeToMetric(outcome) {
-  return {
-    name: outcome.metric,
-    target: outcome.target_range,
-    baseline: outcome.baseline,
-    timeframe: `by ${outcome.check_date}`
-  };
-}
-async function persistStrategistPlan(plan, opts = {}) {
-  await initSchema();
-  const slug = slugify2(plan.title);
-  const libraryPath = strategyLibraryPath(slug);
-  const linkedPlayIds = [...new Set(plan.workstreams.flatMap((ws) => ws.play_ids))];
-  const successMetrics = plan.workstreams.map((ws) => outcomeToMetric(ws.expected_outcome));
-  const leadingIndicators = plan.workstreams.flatMap((ws) => ws.leading_indicators.map(outcomeToMetric));
-  const recommendedActions = plan.workstreams.flatMap((ws) => ws.actions.map((action) => `[WS${ws.order}] ${action}`)).slice(0, 15);
-  const reviewProtocol = [
-    `Review ${plan.review_cadence.toLowerCase()} with /strategy review ${slug}.`,
-    `Check each milestone at its due date against the named verification method.`,
-    `At each outcome check date, compare the measured value to its target range against baseline batch ${opts.baselineBatchId ?? "(latest)"}.`,
-    `If a contingency trigger fires, activate the pre-agreed fallback.`
-  ].join(" ");
-  const id = await upsertStrategy({
-    slug,
-    title: plan.title,
-    status: opts.status ?? "active",
-    source_type: "agent",
-    source_path: null,
-    goal: plan.objective,
-    hypothesis: plan.hypothesis,
-    target_segment: plan.target_segment,
-    priority: plan.priority,
-    linked_play_ids: linkedPlayIds,
-    success_metrics: successMetrics,
-    leading_indicators: leadingIndicators,
-    risks: plan.risks,
-    recommended_actions: recommendedActions,
-    experiment_design: reviewProtocol,
-    review_cadence: plan.review_cadence,
-    confidence: plan.confidence,
-    raw_excerpt: plan.summary_30k,
-    library_path: libraryPath,
-    origin: "strategist",
-    objective: plan.objective,
-    constraints: plan.constraints,
-    workstreams: plan.workstreams,
-    assumptions: plan.assumptions,
-    baseline_batch_id: opts.baselineBatchId ?? null
-  });
-  const strategy = await getStrategyBySlugOrId(id);
-  if (!strategy) {
-    throw new NtrpError("strategy_persist_failed", "Strategy was not found after saving.", 1 /* RuntimeError */);
-  }
-  const writtenPath = writeStrategyMarkdown(strategy);
-  await insertStrategySource({
-    strategy_id: strategy.id,
-    source_type: "agent",
-    source_path: null,
-    content_hash: createHash2("sha256").update(JSON.stringify(plan)).digest("hex"),
-    extracted_text_excerpt: plan.summary_30k.slice(0, 800),
-    metadata: {
-      origin: "strategist",
-      objective: plan.objective,
-      workstream_count: plan.workstreams.length,
-      baseline_batch_id: opts.baselineBatchId ?? null
-    }
-  });
-  return { strategy: { ...strategy, library_path: writtenPath }, library_path: writtenPath };
-}
-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_errors2();
-    init_types2();
-    init_formatters();
-    init_formatters();
-  }
-});
-
 // src/ai/strategist-prompt.ts
 function companyContextSection4() {
   const block = buildCompanyProfileBlock();
@@ -29427,6 +29749,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"() {
@@ -29954,6 +30322,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;
@@ -30176,6 +30835,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,
@@ -30212,7 +30880,7 @@ function describePlanValidationFailure(text, evidenceText, todayIso) {
   return "unknown validation failure";
 }
 var GROUND_MAX_ROUNDS, BACKCAST_MAX_ROUNDS, STRESS_MAX_ROUNDS, STAGE_MAX_TOKENS, PLAN_JSON_MAX_TOKENS, STAGE_LABELS;
-var init_strategist2 = __esm({
+var init_strategist = __esm({
   "src/ai/strategist.ts"() {
     "use strict";
     init_types();
@@ -30227,6 +30895,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;
@@ -30241,6 +30910,803 @@ var init_strategist2 = __esm({
   }
 });
 
+// src/ai/strategist-craft.ts
+import { createHash as createHash2 } from "crypto";
+function snapshotHash(snapshotJson) {
+  return createHash2("sha256").update(snapshotJson).digest("hex").slice(0, 16);
+}
+function totalTokens(job) {
+  return job.cumulative_input_tokens + job.cumulative_output_tokens;
+}
+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_strategist();
+    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/services/strategist.ts
+import { createHash as createHash3 } from "crypto";
+function serializeGapAudit(audit) {
+  const lines = [`Can compute: ${audit.can_compute} (lens: ${audit.primary_lens})`];
+  for (const item of audit.satisfied) {
+    lines.push(`- HAVE ${item.label}: ${item.detail}`);
+  }
+  for (const item of audit.missing) {
+    lines.push(`- MISSING ${item.label}: ${item.why}`);
+  }
+  for (const item of audit.optional) {
+    lines.push(`- LIMITED ${item.label}: ${item.detail}`);
+  }
+  return lines.join("\n");
+}
+async function prepareStrategistInputs(ctx, objective) {
+  let snapshot = ctx.snapshot.computeResult;
+  if (!snapshot) {
+    snapshot = await computeFullHealth();
+    ctx.snapshot.computeResult = snapshot;
+    const divInput = snapshot.segments.map((s) => ({
+      segmentId: s.segment.id,
+      segmentName: s.segment.name,
+      result: s.result
+    }));
+    ctx.snapshot.divergences = detectDivergences(snapshot.aggregate, divInput).divergences;
+  }
+  const audit = ctx.gapAudit ?? await refreshGapAudit(ctx).catch(() => null);
+  const gapAuditBlock = audit ? serializeGapAudit(audit) : "";
+  const memoryBlock = await Promise.resolve().then(() => (init_store2(), store_exports2)).then((m) => m.buildMemoryBlock(objective)).catch(() => "");
+  let baselineBatchId = null;
+  try {
+    const reading = await getLatestHealthReading();
+    baselineBatchId = reading?.upload_batch_id ?? null;
+  } catch {
+  }
+  return {
+    snapshot,
+    divergences: ctx.snapshot.divergences,
+    gapAuditBlock,
+    memoryBlock,
+    baselineBatchId,
+    includeMetrics: true
+  };
+}
+function proposeObjectiveFromSnapshot(snapshot) {
+  const { aggregate } = snapshot;
+  const gating = aggregate.gating_vital_sign;
+  if (!gating) return null;
+  const vital = aggregate.vital_signs.find((v) => v.vital_sign === gating);
+  if (!vital) return null;
+  const label = VITAL_SIGN_LABELS[gating] ?? gating;
+  const dollar = vital.dollar_value != null && vital.dollar_value > 0 ? ` and recover the ${formatCurrency(vital.dollar_value)} ${vital.dollar_label ?? "at stake"}` : "";
+  return `Move ${label} from ${Math.round(vital.score)} to 60+${dollar} within 60 days`;
+}
+function slugify2(value) {
+  const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return slug || `strategy-${Date.now()}`;
+}
+function outcomeToMetric(outcome) {
+  return {
+    name: outcome.metric,
+    target: outcome.target_range,
+    baseline: outcome.baseline,
+    timeframe: `by ${outcome.check_date}`
+  };
+}
+async function persistStrategistPlan(plan, opts = {}) {
+  await initSchema();
+  const slug = slugify2(plan.title);
+  const libraryPath = strategyLibraryPath(slug);
+  const linkedPlayIds = [...new Set(plan.workstreams.flatMap((ws) => ws.play_ids))];
+  const successMetrics = plan.workstreams.map((ws) => outcomeToMetric(ws.expected_outcome));
+  const leadingIndicators = plan.workstreams.flatMap((ws) => ws.leading_indicators.map(outcomeToMetric));
+  const recommendedActions = plan.workstreams.flatMap((ws) => ws.actions.map((action) => `[WS${ws.order}] ${action}`)).slice(0, 15);
+  const reviewProtocol = [
+    `Review ${plan.review_cadence.toLowerCase()} with /strategy review ${slug}.`,
+    `Check each milestone at its due date against the named verification method.`,
+    `At each outcome check date, compare the measured value to its target range against baseline batch ${opts.baselineBatchId ?? "(latest)"}.`,
+    `If a contingency trigger fires, activate the pre-agreed fallback.`
+  ].join(" ");
+  const id = await upsertStrategy({
+    slug,
+    title: plan.title,
+    status: opts.status ?? "active",
+    source_type: "agent",
+    source_path: null,
+    goal: plan.objective,
+    hypothesis: plan.hypothesis,
+    target_segment: plan.target_segment,
+    priority: plan.priority,
+    linked_play_ids: linkedPlayIds,
+    success_metrics: successMetrics,
+    leading_indicators: leadingIndicators,
+    risks: plan.risks,
+    recommended_actions: recommendedActions,
+    experiment_design: reviewProtocol,
+    review_cadence: plan.review_cadence,
+    confidence: plan.confidence,
+    raw_excerpt: plan.summary_30k,
+    library_path: libraryPath,
+    origin: "strategist",
+    objective: plan.objective,
+    constraints: plan.constraints,
+    workstreams: plan.workstreams,
+    assumptions: plan.assumptions,
+    baseline_batch_id: opts.baselineBatchId ?? null
+  });
+  const strategy = await getStrategyBySlugOrId(id);
+  if (!strategy) {
+    throw new NtrpError("strategy_persist_failed", "Strategy was not found after saving.", 1 /* RuntimeError */);
+  }
+  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",
+    source_path: null,
+    content_hash: createHash3("sha256").update(JSON.stringify(plan)).digest("hex"),
+    extracted_text_excerpt: plan.summary_30k.slice(0, 800),
+    metadata: {
+      origin: "strategist",
+      objective: plan.objective,
+      workstream_count: plan.workstreams.length,
+      baseline_batch_id: opts.baselineBatchId ?? null
+    }
+  });
+  return { strategy: { ...strategy, library_path: writtenPath }, library_path: writtenPath };
+}
+var init_strategist2 = __esm({
+  "src/services/strategist.ts"() {
+    "use strict";
+    init_schema();
+    init_queries();
+    init_health_score();
+    init_divergence();
+    init_gap_audit();
+    init_library();
+    init_errors2();
+    init_types2();
+    init_formatters();
+  }
+});
+
+// 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_handoff2 = __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_strategist();
+    init_strategist_craft();
+    init_formatters();
+    init_strategist2();
+    init_queries();
+    init_schema();
+    init_store3();
+    init_handoff2();
+  }
+});
+
 // src/output/strategy-brief.ts
 import chalk36 from "chalk";
 function printWrapped(text, width, prefix = INDENT, style) {
@@ -30332,6 +31798,40 @@ function printStrategyBrief(plan, stats) {
   console.log(`${INDENT}${coverageStyled}${chalk36.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 + chalk36.dim(opts.library_path));
+    if (opts.slug) {
+      console.log(
+        INDENT + chalk36.dim("Type ") + paint("accent", `/strategy review ${opts.slug}`) + chalk36.dim(" to check progress.")
+      );
+    }
+    const handoff = opts.inbox_path ?? opts.handoff_path;
+    if (handoff) console.log(INDENT + chalk36.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 + chalk36.dim(path));
+    if (opts.oneShot && opts.jobId) {
+      console.log(
+        INDENT + chalk36.dim("Resume: ") + paint("accent", `ntrp strategy craft --resume ${opts.jobId}`)
+      );
+    } else {
+      console.log(
+        INDENT + chalk36.dim("Type ") + chalk36.cyan("keep going") + chalk36.dim(" to continue.")
+      );
+    }
+  }
+  if (opts.oneShot && opts.journal_path) {
+    console.log(INDENT + chalk36.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"() {
@@ -30346,7 +31846,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,
@@ -30369,7 +31871,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();
@@ -30394,7 +31897,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("  " + chalk37.dim('What is the objective? State a finish line. Example: "cut stale pipeline in half before Q4".'));
@@ -30402,7 +31905,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}`);
@@ -30415,7 +31918,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) {
@@ -30425,6 +31929,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(
+      "  " + chalk37.dim("No plan in progress. Type ") + chalk37.cyan("how should we fix this?") + chalk37.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(
+      "  " + chalk37.dim("Type ") + chalk37.cyan("/connect") + chalk37.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("  " + chalk37.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("  " + chalk37.red(String(err.message ?? err)));
+    ctx.strategistState = void 0;
+    saveSessionState(ctx);
+    return;
+  }
+}
 async function handleStrategizeFlow(input, ctx) {
   const state2 = ctx.strategistState;
   if (!state2) return;
@@ -30451,6 +32013,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);
   }
@@ -30501,7 +32068,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(
@@ -30515,7 +32082,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("  " + chalk37.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("  " + chalk37.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;
@@ -30599,7 +32198,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(),
@@ -30647,19 +32249,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("  " + chalk37.dim("(No plan produced)"));
+  }
+  for (const notice of result.notices.slice(0, 8)) {
+    if (!isCraftRoundNotice(notice)) console.log("  " + chalk37.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("  " + chalk37.bold("Strategy session"));
   console.log(
     "  " + chalk37.dim(proposed ? "Proposed objective: " : "Objective: ") + paint("accent", objective)
   );
   console.log(
-    "  " + chalk37.dim("NTRP uses your live data. It sequences the work and sets measured milestones. It then stress-tests the plan.")
+    "  " + chalk37.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(
     "  " + chalk37.dim("Confirm? ") + chalk37.cyan("\u23CE yes") + chalk37.dim(" \xB7 ") + chalk37.cyan("b back") + chalk37.dim(" \xB7 ") + chalk37.cyan("adjust") + chalk37.dim(" \xB7 ") + chalk37.cyan("cancel")
   );
+  if (!craftMode) {
+    console.log(
+      "  " + chalk37.dim("or type ") + chalk37.cyan("keep going") + chalk37.dim(" to keep working until the plan is ready")
+    );
+  }
   console.log();
 }
 async function printKeylessSkeletonPlan(ctx, objective) {
@@ -30721,7 +32358,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";
@@ -30733,17 +32370,20 @@ var init_strategist_flow = __esm({
     init_prompts();
     init_health_score();
     init_divergence();
-    init_strategist();
     init_strategist2();
+    init_strategist();
+    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;
   }
 });
 
@@ -30756,8 +32396,8 @@ __export(strategy_review_exports, {
   persistStrategyReview: () => persistStrategyReview,
   resolveReviewableStrategy: () => resolveReviewableStrategy
 });
-import { writeFileSync as writeFileSync18 } from "fs";
-import { join as join28 } from "path";
+import { writeFileSync as writeFileSync20 } from "fs";
+import { join as join31 } from "path";
 function groupByBatch(vitals, metrics) {
   const map = /* @__PURE__ */ new Map();
   const order = [];
@@ -31047,7 +32687,7 @@ async function persistStrategyReview(report, milestoneVerdicts, notes) {
 }
 function logWin(strategy, hits, milestoneWins) {
   const date = isoToday();
-  const path = join28(getWinsDir(), `${strategy.slug}-${date}.md`);
+  const path = join31(getWinsDir(), `${strategy.slug}-${date}.md`);
   const lines = [
     `# Win \u2014 ${strategy.title}`,
     "",
@@ -31064,7 +32704,7 @@ function logWin(strategy, hits, milestoneWins) {
     for (const label of milestoneWins) lines.push(`- ${label}`);
   }
   lines.push("", "_Logged by /strategy review._", "");
-  writeFileSync18(path, lines.join("\n"));
+  writeFileSync20(path, lines.join("\n"));
   return path;
 }
 var VITAL_TOKENS, COMPONENT_TOKENS;
@@ -31296,9 +32936,15 @@ __export(strategy_exports2, {
 });
 import chalk39 from "chalk";
 async function handler16(args, ctx) {
-  const { positional, flags } = parseArgs2(args, ["no-ai"]);
+  const { positional, flags } = parseArgs2(args, ["no-ai", "save", "handoff"]);
   const first = positional[0];
   const interactive = !ctx.oneShot && !isStructuredOutput(ctx.execution);
+  if (interactive && first === "craft") {
+    const seed = positional.slice(1).join(" ").trim() || void 0;
+    const { startStrategistFlow: startStrategistFlow2 } = await Promise.resolve().then(() => (init_strategist_flow(), strategist_flow_exports));
+    await startStrategistFlow2(ctx, { seed, origin: "command", mode: "craft" });
+    return;
+  }
   if (interactive && (!first || !RESERVED_SUBCOMMANDS.has(first))) {
     const seed = positional.join(" ").trim() || void 0;
     const { startStrategistFlow: startStrategistFlow2 } = await Promise.resolve().then(() => (init_strategist_flow(), strategist_flow_exports));
@@ -31309,14 +32955,18 @@ async function handler16(args, ctx) {
   try {
     const result = await runStrategy(sub, positional, flags, ctx);
     if (isStructuredOutput(ctx.execution)) {
+      if (result.action === "craft") {
+        emitResult("strategy.craft", craftJsonData(result), void 0, result.status === "unfinished" ? "unfinished" : "ok");
+        return;
+      }
       emitResult("strategy", result);
       return;
     }
     renderStrategyResult(result);
   } catch (err) {
-    if (isStructuredOutput(ctx.execution)) emitError("strategy", err);
+    if (isStructuredOutput(ctx.execution)) emitError(first === "craft" ? "strategy.craft" : "strategy", err);
     console.error(chalk39.red(`  ${err instanceof Error ? err.message : String(err)}`));
-    process.exit(1);
+    process.exit(err instanceof NtrpError ? err.exitCode : 1);
   }
 }
 async function runStrategy(sub, positional, flags, ctx) {
@@ -31391,6 +33041,8 @@ async function runStrategy(sub, positional, flags, ctx) {
       const { runStrategyReview: runStrategyReview2 } = await Promise.resolve().then(() => (init_strategy_review_cmd(), strategy_review_cmd_exports));
       return { action: "review", ...await runStrategyReview2(ctx, positional[1]) };
     }
+    case "craft":
+      return runCraft(positional, flags, ctx);
     default:
       throw new NtrpError("unknown_strategy_subcommand", `Unknown strategy subcommand: ${sub}`, 2 /* Usage */);
   }
@@ -31398,8 +33050,79 @@ async function runStrategy(sub, positional, flags, ctx) {
 function shouldSpin(ctx) {
   return !isStructuredOutput(ctx.execution) && ctx.execution.progress;
 }
+async function runCraft(positional, flags, ctx) {
+  if (getFalse(flags, "ai")) {
+    throw new NtrpError(
+      "strategy_craft_requires_ai",
+      "strategy craft needs an LLM key. Drop --no-ai, run /connect, then retry.",
+      3 /* Auth */
+    );
+  }
+  const resumeId = getString(flags, "resume");
+  const objective = positional.slice(1).join(" ").trim();
+  const untilReady = !getFalse(flags, "until");
+  const save = !getFalse(flags, "save");
+  const handoff = !getFalse(flags, "handoff");
+  let interrupted = false;
+  const onInt = () => {
+    interrupted = true;
+  };
+  process.on("SIGINT", onInt);
+  const spinner = shouldSpin(ctx) ? makeSpinner("Working the plan\u2026") : null;
+  try {
+    const job = await executeStrategistJob({
+      ctx,
+      objective,
+      mode: "craft",
+      untilReady,
+      save,
+      handoff,
+      maxRounds: getNumber(flags, "max-rounds"),
+      maxTokens: getNumber(flags, "max-tokens"),
+      minScore: getNumber(flags, "min-score"),
+      resumeId,
+      interrupted: () => interrupted,
+      onEvent: (event) => {
+        if (!spinner) return;
+        if (event.type === "thinking") {
+          spinner.stop();
+          console.log("  " + chalk39.dim.italic(event.text));
+          spinner.start();
+          spinner.text = "Working the plan\u2026";
+        }
+      }
+    });
+    spinner?.stop();
+    return { action: "craft", ...job };
+  } catch (err) {
+    spinner?.fail("Strategy craft failed");
+    throw err;
+  } finally {
+    process.off("SIGINT", onInt);
+  }
+}
+function craftJsonData(result) {
+  return {
+    action: "craft",
+    status: result.status,
+    slug: result.slug ?? null,
+    objective: result.objective,
+    critic_score: result.critic_score,
+    rounds: result.rounds,
+    usage: result.usage,
+    library_path: result.library_path ?? null,
+    journal_path: result.journal_path ?? null,
+    inbox_path: result.inbox_path ?? null,
+    handoff_path: result.handoff_path ?? null,
+    blocking_gaps: result.blocking_gaps,
+    stop_reason: result.stop_reason ?? null
+  };
+}
 function renderStrategyResult(result) {
   switch (result.action) {
+    case "craft":
+      renderCraftResult(result);
+      return;
     case "review":
       return;
     case "ingest":
@@ -31432,6 +33155,31 @@ function renderStrategyResult(result) {
       return;
   }
 }
+function renderCraftResult(result) {
+  if (result.plan) {
+    printStrategyBrief(result.plan, {
+      measurable_targets: result.measurable_targets,
+      total_targets: result.total_targets
+    });
+  } else {
+    console.log();
+    console.log("  " + chalk39.dim("(No plan produced)"));
+  }
+  for (const notice of result.notices.slice(0, 8)) {
+    console.log("  " + chalk39.dim(notice));
+  }
+  printLlmAttribution(result.usage);
+  printCraftWrapUp({
+    status: result.status,
+    library_path: result.library_path,
+    inbox_path: result.inbox_path,
+    handoff_path: result.handoff_path,
+    journal_path: result.journal_path,
+    slug: result.slug,
+    jobId: result.job?.id,
+    oneShot: true
+  });
+}
 function printStrategyList(strategies) {
   console.log(chalk39.bold("\n  Strategies\n"));
   if (strategies.length === 0) {
@@ -31542,7 +33290,10 @@ var init_strategy2 = __esm({
     init_types2();
     init_strategy();
     init_repl_api();
-    RESERVED_SUBCOMMANDS = /* @__PURE__ */ new Set(["ingest", "add", "list", "show", "sync", "sources", "review"]);
+    init_strategist_run();
+    init_strategy_brief();
+    init_llm_attribution();
+    RESERVED_SUBCOMMANDS = /* @__PURE__ */ new Set(["ingest", "add", "list", "show", "sync", "sources", "review", "craft"]);
   }
 });
 
@@ -32461,15 +34212,15 @@ var init_checkout = __esm({
 });
 
 // src/services/setup.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync17, readFileSync as readFileSync20, writeFileSync as writeFileSync19 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync18, readFileSync as readFileSync23, writeFileSync as writeFileSync21 } from "fs";
+import { join as join32 } from "path";
 function setupCheck() {
   const home = ntrpHome();
   let writable = false;
   try {
-    mkdirSync17(home, { recursive: true });
-    const probe = join29(home, ".write-check");
-    writeFileSync19(probe, "ok\n");
+    mkdirSync18(home, { recursive: true });
+    const probe = join32(home, ".write-check");
+    writeFileSync21(probe, "ok\n");
     writable = true;
   } catch {
     writable = false;
@@ -32508,7 +34259,7 @@ function setupCheck() {
   };
 }
 function readProfileInput(pathOrDash) {
-  const raw = pathOrDash === "-" ? readFileSync20(0, "utf-8") : readFileSync20(pathOrDash, "utf-8");
+  const raw = pathOrDash === "-" ? readFileSync23(0, "utf-8") : readFileSync23(pathOrDash, "utf-8");
   return JSON.parse(raw);
 }
 function writeAgentProfile(input) {
@@ -33298,7 +35049,7 @@ var init_orchestrator = __esm({
 });
 
 // src/services/smoke-protocol.ts
-import { join as join30 } from "path";
+import { join as join33 } from "path";
 function isSmokeProtocolTrigger(input) {
   return normalize2(input).includes(SMOKE_TRIGGER_PHRASE);
 }
@@ -33334,7 +35085,7 @@ async function runSmokeProtocol(_input, ctx) {
   });
   const proposalResult = await proposeRepositoryExport({
     target: "markdown",
-    directory: join30(getExportsDir(), "repository-smoke"),
+    directory: join33(getExportsDir(), "repository-smoke"),
     source: "smoke_protocol",
     modelOrFixture: "smoke-protocol-v1"
   });
@@ -34266,8 +36017,8 @@ var init_recall = __esm({
 
 // src/memory/feedback.ts
 import { appendFileSync as appendFileSync7 } from "fs";
-import { join as join31 } from "path";
-import { randomUUID as randomUUID8 } from "crypto";
+import { join as join34 } from "path";
+import { randomUUID as randomUUID9 } from "crypto";
 function summarize(text) {
   return text.replace(/[#*`>_]/g, "").replace(/\s+/g, " ").trim().slice(0, 200);
 }
@@ -34289,7 +36040,7 @@ function findCalibrationToSupersede(question, note) {
 }
 function recordFeedback(input) {
   const entry = {
-    id: randomUUID8(),
+    id: randomUUID9(),
     rating: input.rating,
     question: scrubText(input.question).slice(0, 300),
     answer_summary: scrubText(summarize(input.answer)),
@@ -34298,7 +36049,7 @@ function recordFeedback(input) {
     created_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    appendFileSync7(join31(getMemoryDir(), "feedback.jsonl"), JSON.stringify(entry) + "\n");
+    appendFileSync7(join34(getMemoryDir(), "feedback.jsonl"), JSON.stringify(entry) + "\n");
   } catch {
   }
   if (input.rating === "positive") {
@@ -34468,7 +36219,7 @@ __export(sessions_exports, {
   handler: () => handler35
 });
 import chalk62 from "chalk";
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 async function handler35(args, _ctx) {
   const sub = args[0] ?? "list";
   if (sub === "list" || !args[0]) {
@@ -34575,12 +36326,12 @@ function showSession(idArg) {
   console.log();
   const transcriptPath = transcriptPathForSession(session.id);
   const contextPath = contextDocPathForSession(session.id);
-  if (existsSync31(transcriptPath) || existsSync31(contextPath)) {
+  if (existsSync34(transcriptPath) || existsSync34(contextPath)) {
     console.log("  " + chalk62.dim("\u2500".repeat(40)));
-    if (existsSync31(contextPath)) {
+    if (existsSync34(contextPath)) {
       console.log("  " + chalk62.dim("Context brief: ") + chalk62.dim(contextPath));
     }
-    if (existsSync31(transcriptPath)) {
+    if (existsSync34(transcriptPath)) {
       console.log("  " + chalk62.dim("Full transcript: ") + chalk62.dim(transcriptPath));
     }
     console.log();
@@ -34733,7 +36484,7 @@ var switch_exports = {};
 __export(switch_exports, {
   handler: () => handler38
 });
-import { join as join32 } from "path";
+import { join as join35 } from "path";
 import chalk65 from "chalk";
 async function handler38(args, ctx) {
   if (args.length === 0) {
@@ -34763,7 +36514,7 @@ async function handler38(args, ctx) {
     }
     const context = buildSwitchContext(session);
     const newId = makeSessionId();
-    const newFile = join32(getSessionsDir(), `${newId}.json`);
+    const newFile = join35(getSessionsDir(), `${newId}.json`);
     resetContextForSwitch(ctx, {
       sessionId: newId,
       sessionFile: newFile,
@@ -34776,7 +36527,8 @@ async function handler38(args, ctx) {
       stage: session.stage,
       dataset: session.dataset,
       deliverables: session.deliverables,
-      llm: session.llm ? { ...session.llm } : void 0
+      llm: session.llm ? { ...session.llm } : void 0,
+      lastCraftJobId: session.last_craft_job_id
     });
     console.log();
     console.log("  " + paint("accent", `Switched to "${targetName}"`));
@@ -34789,7 +36541,7 @@ async function handler38(args, ctx) {
     return `Switched to "${targetName}"`;
   } else {
     const newId = makeSessionId();
-    const newFile = join32(getSessionsDir(), `${newId}.json`);
+    const newFile = join35(getSessionsDir(), `${newId}.json`);
     resetContextForSwitch(ctx, {
       sessionId: newId,
       sessionFile: newFile,
@@ -35916,186 +37668,6 @@ var init_model = __esm({
   }
 });
 
-// src/config/update-check.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync18, readFileSync as readFileSync21, unlinkSync as unlinkSync5, writeFileSync as writeFileSync20 } from "fs";
-import { join as join33 } from "path";
-function cachePath2() {
-  return join33(ntrpHome(), "update-check.json");
-}
-function ensureDir7() {
-  const dir = ntrpHome();
-  if (!existsSync32(dir)) {
-    mkdirSync18(dir, { recursive: true });
-  }
-}
-function loadUpdateCheckCache() {
-  const path = cachePath2();
-  if (!existsSync32(path)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync21(path, "utf-8"));
-    if (!parsed || typeof parsed !== "object" || typeof parsed.lastCheck !== "number" || typeof parsed.latestVersion !== "string") {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function saveUpdateCheckCache(cache2) {
-  ensureDir7();
-  writeFileSync20(cachePath2(), JSON.stringify(cache2, null, 2) + "\n");
-}
-function isCacheFresh(cache2, ttlMs = CACHE_TTL_MS2) {
-  if (!cache2) return false;
-  return Date.now() - cache2.lastCheck < ttlMs;
-}
-function invalidateUpdateCheckCache() {
-  const path = cachePath2();
-  if (existsSync32(path)) {
-    unlinkSync5(path);
-  }
-}
-var CACHE_TTL_MS2;
-var init_update_check = __esm({
-  "src/config/update-check.ts"() {
-    "use strict";
-    init_store();
-    CACHE_TTL_MS2 = 864e5;
-  }
-});
-
-// src/version.ts
-import { existsSync as existsSync33, readFileSync as readFileSync22 } from "fs";
-import { dirname as dirname6, join as join34 } from "path";
-import { fileURLToPath } from "url";
-function readVersionFromPackageJson(packageJsonPath) {
-  if (!existsSync33(packageJsonPath)) return null;
-  try {
-    const pkg = JSON.parse(readFileSync22(packageJsonPath, "utf-8"));
-    if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
-  } catch {
-  }
-  return null;
-}
-function readVersionNearEntry(entryPath) {
-  const start = dirname6(entryPath);
-  for (const rel of [join34(start, "..", "package.json"), join34(start, "../..", "package.json")]) {
-    const version = readVersionFromPackageJson(rel);
-    if (version) return version;
-  }
-  return null;
-}
-function readInstalledVersionFromDisk() {
-  return readVersionNearEntry(fileURLToPath(import.meta.url));
-}
-function getInstalledVersion() {
-  if (cachedVersion) return cachedVersion;
-  cachedVersion = readInstalledVersionFromDisk() ?? "0.0.0";
-  return cachedVersion;
-}
-var cachedVersion;
-var init_version = __esm({
-  "src/version.ts"() {
-    "use strict";
-  }
-});
-
-// src/update/registry.ts
-var registry_exports = {};
-__export(registry_exports, {
-  NPM_PACKAGE: () => NPM_PACKAGE,
-  applyUpdateCheckResult: () => applyUpdateCheckResult,
-  checkForUpdate: () => checkForUpdate,
-  fetchLatestVersion: () => fetchLatestVersion,
-  formatUpdateNudge: () => formatUpdateNudge,
-  hydrateUpdateAvailableFromCache: () => hydrateUpdateAvailableFromCache,
-  isNewerVersion: () => isNewerVersion,
-  startBackgroundUpdateCheck: () => startBackgroundUpdateCheck
-});
-function registryUrl() {
-  return process.env.NTRP_REGISTRY_URL ?? "https://registry.npmjs.org/@sonnechasser/ntrp/latest";
-}
-function parseVersionParts(version) {
-  const cleaned = version.trim().replace(/^v/i, "");
-  const core = cleaned.split("-")[0] ?? cleaned;
-  const parts = core.split(".").map((p) => parseInt(p, 10));
-  return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
-}
-function isNewerVersion(latest, current) {
-  const [lMaj, lMin, lPatch] = parseVersionParts(latest);
-  const [cMaj, cMin, cPatch] = parseVersionParts(current);
-  if (lMaj !== cMaj) return lMaj > cMaj;
-  if (lMin !== cMin) return lMin > cMin;
-  return lPatch > cPatch;
-}
-function formatUpdateNudge(current, latest) {
-  return `\u26A1 NTRP v${latest} available (running v${current}) \u2014 type /update`;
-}
-function hydrateUpdateAvailableFromCache(current) {
-  const cached2 = loadUpdateCheckCache();
-  if (!cached2?.latestVersion) return void 0;
-  if (!isNewerVersion(cached2.latestVersion, current)) return void 0;
-  return { current, latest: cached2.latestVersion };
-}
-function applyUpdateCheckResult(ctx, result) {
-  if (result?.updateAvailable) {
-    ctx.updateAvailable = { current: result.current, latest: result.latest };
-    return;
-  }
-  if (result && !result.updateAvailable) {
-    ctx.updateAvailable = void 0;
-  }
-}
-function startBackgroundUpdateCheck(ctx) {
-  const pending = checkForUpdate({ force: true, timeoutMs: 5e3 });
-  ctx.pendingUpdateCheck = pending;
-  void pending.then((result) => applyUpdateCheckResult(ctx, result)).catch(() => void 0);
-}
-async function fetchLatestVersion(timeoutMs = 5e3) {
-  try {
-    const res = await fetch(registryUrl(), { signal: AbortSignal.timeout(timeoutMs) });
-    if (!res.ok) return null;
-    const data = await res.json();
-    return typeof data.version === "string" && data.version.length > 0 ? data.version : null;
-  } catch {
-    return null;
-  }
-}
-function buildResult(current, latest) {
-  return {
-    current,
-    latest,
-    updateAvailable: isNewerVersion(latest, current)
-  };
-}
-async function checkForUpdate(options) {
-  const current = getInstalledVersion();
-  const timeoutMs = options?.timeoutMs ?? 5e3;
-  const cached2 = loadUpdateCheckCache();
-  if (!options?.force && isCacheFresh(cached2)) {
-    return buildResult(current, cached2.latestVersion);
-  }
-  const latest = await fetchLatestVersion(timeoutMs);
-  if (!latest) {
-    if (cached2?.latestVersion) {
-      return buildResult(current, cached2.latestVersion);
-    }
-    return null;
-  }
-  const nextCache = { lastCheck: Date.now(), latestVersion: latest };
-  saveUpdateCheckCache(nextCache);
-  return buildResult(current, latest);
-}
-var NPM_PACKAGE;
-var init_registry = __esm({
-  "src/update/registry.ts"() {
-    "use strict";
-    init_update_check();
-    init_version();
-    NPM_PACKAGE = "@sonnechasser/ntrp";
-  }
-});
-
 // src/update/relaunch.ts
 var relaunch_exports = {};
 __export(relaunch_exports, {
@@ -36109,8 +37681,8 @@ __export(relaunch_exports, {
   resolveRelaunchEntry: () => resolveRelaunchEntry,
   updateRestartSummary: () => updateRestartSummary
 });
-import { existsSync as existsSync34 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync35 } from "fs";
+import { join as join36 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { spawnSync } from "child_process";
 function encodeJustUpdated(fromVersion, toVersion) {
@@ -36134,8 +37706,8 @@ function updateRestartSummary(toVersion) {
 function npmGlobalEntry() {
   const listed = spawnSync("npm", ["root", "-g"], { encoding: "utf-8" });
   if (listed.status !== 0) return null;
-  const entry = join35(listed.stdout.trim(), NPM_PACKAGE, "dist/index.js");
-  return existsSync34(entry) ? entry : null;
+  const entry = join36(listed.stdout.trim(), NPM_PACKAGE, "dist/index.js");
+  return existsSync35(entry) ? entry : null;
 }
 function thisBundleEntry() {
   return fileURLToPath2(import.meta.url);
@@ -36145,10 +37717,10 @@ function resolveRelaunchEntry(toVersion) {
     (p) => Boolean(p)
   );
   for (const entry of candidates) {
-    if (!existsSync34(entry)) continue;
+    if (!existsSync35(entry)) continue;
     if (readVersionNearEntry(entry) === toVersion) return entry;
   }
-  return candidates.find((p) => existsSync34(p)) ?? thisBundleEntry();
+  return candidates.find((p) => existsSync35(p)) ?? thisBundleEntry();
 }
 function relaunchArgv(toVersion) {
   return [resolveRelaunchEntry(toVersion)];
@@ -36242,6 +37814,22 @@ async function handler44(_args, ctx) {
     console.log();
     return;
   }
+  if (!ctx.oneShot) {
+    const prompts = createPromptSession(ctx.rl, ctx);
+    let ok2 = false;
+    try {
+      console.log();
+      ok2 = await prompts.confirm(`Install NTRP v${current} \u2192 v${latest}?`, true);
+    } finally {
+      prompts.close();
+    }
+    if (!ok2) {
+      console.log();
+      console.log(chalk73.dim("  Update cancelled."));
+      console.log();
+      return "Update cancelled";
+    }
+  }
   console.log();
   console.log(`  Updating NTRP v${current} \u2192 v${latest}...`);
   const { ok, output } = runGlobalInstall();
@@ -36288,6 +37876,7 @@ var PERMISSIONS_URL;
 var init_update = __esm({
   "src/commands/update.ts"() {
     "use strict";
+    init_prompts();
     init_update_check();
     init_registry();
     init_relaunch();
@@ -36362,10 +37951,10 @@ function renderProgressReport() {
     `${chalk74.dim("Deliverables")}    ${chalk74.bold(String(usage5.deliverables))}`,
     `${chalk74.dim("AI exchanges")}    ${chalk74.bold(String(usage5.nl_exchanges))}`
   ]);
-  const totalTokens = usage5.input_tokens + usage5.output_tokens;
+  const totalTokens2 = usage5.input_tokens + usage5.output_tokens;
   printCard("AI usage", [
     `${chalk74.dim("LLM calls")}       ${chalk74.bold(String(usage5.llm_calls))}`,
-    `${chalk74.dim("Tokens")}          ${chalk74.bold(formatTokens(totalTokens))} in+out (${formatTokens(usage5.input_tokens)} in \xB7 ${formatTokens(usage5.output_tokens)} out)`
+    `${chalk74.dim("Tokens")}          ${chalk74.bold(formatTokens(totalTokens2))} in+out (${formatTokens(usage5.input_tokens)} in \xB7 ${formatTokens(usage5.output_tokens)} out)`
   ]);
   const weeks = [...usage5.weekly].sort((a, b) => a.week.localeCompare(b.week)).slice(-8);
   const weekHours = weeks.map((w) => w.minutes_saved / 60);
@@ -36671,8 +38260,8 @@ __export(exports_exports, {
   handler: () => handler48
 });
 import chalk78 from "chalk";
-import { existsSync as existsSync35 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync36 } from "fs";
+import { join as join37 } from "path";
 function usage4() {
   console.log(chalk78.dim("  Usage:"));
   console.log(chalk78.dim("    /exports list [kind]"));
@@ -36729,7 +38318,7 @@ function printInboxShow() {
     console.log("  " + paint("accent", "AI inbox: ") + inbox);
     const latest = inboxLatestHandoffPath();
     if (latest) console.log("  " + chalk78.dim("Latest handoff: ") + latest);
-    console.log("  " + chalk78.dim("Finder skill:   ") + join36(inbox, "SKILL.md"));
+    console.log("  " + chalk78.dim("Finder skill:   ") + join37(inbox, "SKILL.md"));
     console.log("  " + chalk78.dim("Reprint:        ") + paint("accent", "/inbox skill"));
   } else {
     console.log("  " + chalk78.dim("AI inbox: (not set). Type ") + paint("accent", "/inbox set <folder>"));
@@ -36751,8 +38340,8 @@ function printOpen() {
     console.log("  " + chalk78.dim("AI inbox:       ") + inbox);
     const latest = inboxLatestHandoffPath();
     if (latest) console.log("  " + chalk78.dim("Inbox latest:   ") + latest);
-    console.log("  " + chalk78.dim("Pickup skill:   ") + join36(inbox, "latest-pickup.md"));
-    console.log("  " + chalk78.dim("Finder skill:   ") + join36(inbox, "SKILL.md"));
+    console.log("  " + chalk78.dim("Pickup skill:   ") + join37(inbox, "latest-pickup.md"));
+    console.log("  " + chalk78.dim("Finder skill:   ") + join37(inbox, "SKILL.md"));
   } else {
     console.log("  " + chalk78.dim("AI inbox is not set. Type ") + paint("accent", "/inbox set <folder>"));
     const loc = handoffLocations();
@@ -36830,7 +38419,7 @@ function runMove(args, ctx) {
   }
   try {
     const destDir = resolveUserPath(dest);
-    if (!existsSync35(destDir)) {
+    if (!existsSync36(destDir)) {
     }
     const event = moveExport(idOrName, destDir);
     console.log();
@@ -37247,7 +38836,9 @@ section: Settings
 handler: ../commands/update.ts
 ---
 
-Install the latest global NTRP package via npm.`
+Install the latest global NTRP package via npm.
+Interactive confirms with \u23CE yes, then re-execs onto home.
+One-shot installs immediately and prints a restart hint.`
       },
       {
         name: "resume",
@@ -37474,7 +39065,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
 ---
 
@@ -37483,6 +39074,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.
@@ -37864,8 +39457,8 @@ Remaining nuances merge into a custom_context paragraph that flows into all AI s
 });
 
 // src/ai/prompt-parts.ts
-import { existsSync as existsSync36, readFileSync as readFileSync23 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync24 } from "fs";
+import { join as join38 } from "path";
 function buildCompanyProfileBlock() {
   const p = loadProfile();
   if (!p) return "";
@@ -37883,10 +39476,10 @@ function buildCompanyProfileBlock() {
   return lines.join("\n");
 }
 function loadAnalystFile() {
-  const path = join37(ntrpHome(), ANALYST_FILE_NAME);
+  const path = join38(ntrpHome(), ANALYST_FILE_NAME);
   try {
-    if (!existsSync36(path)) return null;
-    const raw = sanitizeExternalText(readFileSync23(path, "utf-8").trim());
+    if (!existsSync37(path)) return null;
+    const raw = sanitizeExternalText(readFileSync24(path, "utf-8").trim());
     if (!raw) return null;
     if (raw.length <= ANALYST_FILE_MAX_CHARS) return raw;
     const head = raw.slice(0, Math.floor(ANALYST_FILE_MAX_CHARS * 0.75));
@@ -38420,8 +40013,8 @@ __export(ingest_chat_exports, {
   loadDemoFromChat: () => loadDemoFromChat,
   looksLikeFilePath: () => looksLikeFilePath
 });
-import { existsSync as existsSync37, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
-import { basename as basename10, join as join38, resolve as resolve9 } from "path";
+import { existsSync as existsSync38, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { basename as basename10, join as join39, resolve as resolve9 } from "path";
 import { homedir as homedir8 } from "os";
 import chalk80 from "chalk";
 function extractFilePath(input) {
@@ -38443,7 +40036,7 @@ function extractFilePath(input) {
     if (!candidate) continue;
     if (!looksLikePathToken(candidate)) continue;
     const p = expandPath(candidate);
-    if (existsSync37(p)) {
+    if (existsSync38(p)) {
       try {
         const st = statSync5(p);
         if (st.isFile() || st.isDirectory()) return p;
@@ -38472,7 +40065,7 @@ function looksLikeFilePath(input) {
 function listCsvsInFolder(dir) {
   try {
     if (!statSync5(dir).isDirectory()) return [];
-    return readdirSync6(dir).filter((name) => name.toLowerCase().endsWith(".csv")).map((name) => join38(dir, name)).sort();
+    return readdirSync6(dir).filter((name) => name.toLowerCase().endsWith(".csv")).map((name) => join39(dir, name)).sort();
   } catch {
     return [];
   }
@@ -38554,12 +40147,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;
@@ -39557,6 +41150,10 @@ async function conversationRouter(input, ctx) {
     const summary = await handleStrategizeFlow(line, ctx) ?? void 0;
     return { handled: true, summary };
   }
+  if (isKeepGoingIntent(line) && (phase === "explore" || phase === "orient" && isAnalysisReady(ctx))) {
+    const summary = await handleKeepGoingLine(ctx, line) ?? void 0;
+    return { handled: true, summary };
+  }
   if (phase === "think") {
     const summary = await handleThinkFlow(line, ctx) ?? void 0;
     return { handled: true, summary };
@@ -39867,7 +41464,7 @@ var init_loop_guard2 = __esm({
       },
       strategize: {
         mode: "strategy objective confirm",
-        accepts: "\u23CE or yes (build the plan) \xB7 b / back or adjust (restate the objective) \xB7 cancel",
+        accepts: "\u23CE or yes (build the plan) \xB7 keep going (keep working until the plan is ready) \xB7 b / back or adjust (restate the objective) \xB7 cancel",
         leave: "cancel drops the strategy session and returns to Q&A"
       }
     };
@@ -39917,7 +41514,7 @@ function ntrpStatusRow(version, update) {
     return {
       label: "ntrp",
       state: badge("UPDATE", "warning"),
-      detail: `v${update.latest} \xB7 type /update`
+      detail: `v${update.latest} \xB7 \u23CE /update`
     };
   }
   if (disk && isNewerVersion(disk, getInstalledVersion())) {
@@ -40352,7 +41949,8 @@ var init_deepdive_complete = __esm({
       "inbox",
       "claude",
       "skill",
-      "strategy"
+      "strategy",
+      "keep-going"
     ];
   }
 });
@@ -40463,7 +42061,7 @@ __export(repl_exports, {
 import { createInterface as createInterface2 } from "readline/promises";
 import { clearLine as clearLine2, cursorTo as cursorTo2 } from "readline";
 import chalk88 from "chalk";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 function buildPrompt(ctx) {
   return buildConversationPrompt(ctx);
 }
@@ -40791,14 +42389,14 @@ function printHelp() {
   console.log("  " + chalk88.dim("Type the question. You do not need a slash command."));
   console.log("  " + chalk88.dim("Paste a CSV path or type ") + paint("accent", '"use demo data"') + chalk88.dim(" to load data."));
   console.log("  " + chalk88.dim("After analysis, type questions in English."));
-  console.log("  " + chalk88.dim("Type ") + paint("accent", '"how should we fix this?"') + chalk88.dim(" to make a strategy."));
+  console.log("  " + chalk88.dim("Type ") + paint("accent", '"how should we fix this?"') + chalk88.dim(" to make a strategy. Type ") + paint("accent", "keep going") + chalk88.dim(" at confirm to keep working until the plan is ready."));
   console.log("  " + chalk88.dim("Type ") + paint("accent", '"ship a board deck"') + chalk88.dim(" to write a handoff."));
   console.log("  " + chalk88.dim("The ") + paint("accent", "\u203A") + chalk88.dim(" prompt shows brief or deep after analysis. Brief is the default."));
   console.log();
   console.log("  " + sectionHeading("Keys"));
   console.log(
     "  " + paint("accent", "\u23CE") + chalk88.dim(
-      "  Accepts the default. At the main prompt it runs the armed action (yes, use demo data, go ahead, /connect)."
+      "  Accepts the default. At the main prompt it runs the armed action (yes, use demo data, go ahead, /connect, /update, keep going)."
     )
   );
   console.log(
@@ -40849,7 +42447,7 @@ function printHelp() {
     ["/remember <fact>", "Store a fact, a decision, or a preference"],
     ["/recall [topic]", "Show what NTRP stores about your business"],
     ["/rate good|bad <note>", "Correct the last answer. A bad note becomes a calibration"],
-    [`${join39(ntrpHome(), ANALYST_FILE_NAME)}`, "Standing operator instructions (tone, priorities, house rules)"]
+    [`${join40(ntrpHome(), ANALYST_FILE_NAME)}`, "Standing operator instructions (tone, priorities, house rules)"]
   ];
   const teachMaxW = Math.max(...teach.map(([c]) => c.length)) + 2;
   for (const [cmd, desc] of teach) {