@kynver-app/runtime 0.1.34 → 0.1.38

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { mkdirSync as mkdirSync5, realpathSync } from "node:fs";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { mkdirSync as mkdirSync7, realpathSync } from "node:fs";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/config.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -362,7 +362,7 @@ async function runLogin(args) {
 }
 
 // src/dispatch.ts
-import path12 from "node:path";
+import path16 from "node:path";
 
 // src/callback-headers.ts
 function buildHarnessCallbackHeaders(secret) {
@@ -424,12 +424,12 @@ var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
 var DEFAULT_MAX_USED_PERCENT = 80;
 var DEFAULT_HARD_MAX_USED_PERCENT = 90;
 function observeRunnerDiskGate(input = {}) {
-  const path25 = input.diskPath?.trim() || "/";
+  const path32 = input.diskPath?.trim() || "/";
   const warnBelowBytes = input.diskFreeWarnBytes ?? DEFAULT_WARN_FREE_BYTES;
   const criticalBelowBytes = input.diskFreeCriticalBytes ?? DEFAULT_CRITICAL_FREE_BYTES;
   const maxUsedPercent = input.diskMaxUsedPercent ?? DEFAULT_MAX_USED_PERCENT;
   const hardMaxUsedPercent = input.diskHardMaxUsedPercent ?? DEFAULT_HARD_MAX_USED_PERCENT;
-  const stats = statfsSync(path25);
+  const stats = statfsSync(path32);
   const freeBytes = Number(stats.bavail) * Number(stats.bsize);
   const totalBytes = Number(stats.blocks) * Number(stats.bsize);
   const usedPercent = totalBytes > 0 ? (totalBytes - freeBytes) / totalBytes * 100 : 100;
@@ -449,7 +449,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path25,
+    path: path32,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -538,6 +538,7 @@ function runDirectory(id) {
 
 // src/heartbeat.ts
 import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+var HEARTBEAT_FUTURE_SKEW_MS = 6e4;
 function isTerminalHeartbeatPhase(phase) {
   return phase === "complete";
 }
@@ -552,16 +553,31 @@ function parseHeartbeat(file) {
     lastHeartbeatAt: null,
     lastHeartbeatPhase: null,
     lastHeartbeatSummary: null,
-    heartbeatBlocker: null
+    heartbeatBlocker: null,
+    timestampAnomalies: []
   };
   if (!existsSync5(file)) return result;
+  const maxFutureMs = Date.now() + HEARTBEAT_FUTURE_SKEW_MS;
+  const clampedTo = new Date(maxFutureMs).toISOString();
   const lines = readFileSync3(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const entry = safeJson(line);
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
     const row = entry;
     result.heartbeatCount++;
-    if (row.ts) result.lastHeartbeatAt = String(row.ts);
+    if (row.ts) {
+      const ts = String(row.ts);
+      const tsMs = Date.parse(ts);
+      if (Number.isFinite(tsMs) && tsMs > maxFutureMs) {
+        result.timestampAnomalies.push({
+          kind: "future_heartbeat_timestamp",
+          observedAt: ts,
+          clampedTo
+        });
+      } else {
+        result.lastHeartbeatAt = ts;
+      }
+    }
     if (row.phase !== void 0 && row.phase !== null) result.lastHeartbeatPhase = String(row.phase);
     if (row.summary !== void 0 && row.summary !== null) result.lastHeartbeatSummary = String(row.summary);
     result.heartbeatBlocker = row.blocker ? String(row.blocker) : null;
@@ -945,6 +961,112 @@ function landingAttentionReason(verdict) {
   return verdict.detail ?? verdict.reason ?? "dirty_worktree_no_pr";
 }
 
+// src/landing-contract-gate.ts
+function trimOrNull3(value) {
+  if (typeof value !== "string") return null;
+  const t = value.trim();
+  return t.length ? t : null;
+}
+function hasFinalResult3(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function normalizePrUrl(url) {
+  const m = url.trim().match(/github\.com\/([^/]+\/[^/]+)\/(?:pull|pulls)\/(\d+)/i);
+  if (!m) return trimOrNull3(url);
+  return `https://github.com/${m[1]}/pull/${m[2]}`;
+}
+function parseReconciliation(finalResult) {
+  if (!finalResult || typeof finalResult !== "object" || Array.isArray(finalResult)) return [];
+  const record = finalResult;
+  const raw = record.targetPrReconciliation ?? record.target_pr_reconciliation;
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const row = item;
+    const prUrl = normalizePrUrl(String(row.prUrl ?? row.pr_url ?? ""));
+    const outcome = trimOrNull3(row.outcome);
+    if (!prUrl || outcome !== "merged" && outcome !== "skipped" && outcome !== "blocked") continue;
+    out.push({
+      prUrl,
+      outcome,
+      mergeCommit: trimOrNull3(row.mergeCommit ?? row.merge_commit),
+      reason: trimOrNull3(row.reason)
+    });
+  }
+  return out;
+}
+function workerPrUrls(snapshot, finalResult) {
+  const urls = [];
+  const fromSnapshot = normalizePrUrl(trimOrNull3(snapshot.prUrl) ?? "");
+  if (fromSnapshot) urls.push(fromSnapshot);
+  if (finalResult && typeof finalResult === "object" && !Array.isArray(finalResult)) {
+    const pr = normalizePrUrl(String(finalResult.prUrl ?? ""));
+    if (pr) urls.push(pr);
+  }
+  return [...new Set(urls)];
+}
+function assessWorkerLandingContract(input) {
+  const { contract, snapshot } = input;
+  const finalResult = input.finalResult ?? snapshot.finalResult;
+  if (!contract.landingOnly && contract.targetPrUrls.length === 0) {
+    return { blocked: false };
+  }
+  if (!hasFinalResult3(finalResult)) return { blocked: false };
+  const reconciliation = parseReconciliation(finalResult);
+  const byUrl = new Map(reconciliation.map((r) => [r.prUrl, r]));
+  const targetSet = new Set(
+    contract.targetPrUrls.map((u) => normalizePrUrl(u) ?? u).filter(Boolean)
+  );
+  const workerPrs = workerPrUrls(snapshot, finalResult);
+  if (contract.landingOnly) {
+    for (const pr of workerPrs) {
+      if (targetSet.size > 0 && !targetSet.has(pr)) {
+        return {
+          blocked: true,
+          reason: "unrelated_implementation_pr",
+          detail: `Landing-only worker attached unrelated PR ${pr}`
+        };
+      }
+      if (targetSet.size === 0) {
+        return {
+          blocked: true,
+          reason: "unrelated_implementation_pr",
+          detail: "Landing-only worker must not open new implementation PRs"
+        };
+      }
+    }
+  }
+  if (contract.targetPrUrls.length === 0) return { blocked: false };
+  const missing = [];
+  for (const target of contract.targetPrUrls) {
+    const key = normalizePrUrl(target) ?? target;
+    const entry = byUrl.get(key);
+    if (!entry) {
+      missing.push(key);
+      continue;
+    }
+    if (entry.outcome !== "merged" && !entry.reason?.trim()) {
+      missing.push(key);
+    }
+  }
+  if (missing.length > 0) {
+    return {
+      blocked: true,
+      reason: missing.every((u) => byUrl.has(u)) ? "incomplete_target_pr_landing" : "missing_target_pr_reconciliation",
+      detail: `Target PR reconciliation incomplete: ${missing.join(", ")}`
+    };
+  }
+  return { blocked: false };
+}
+function landingContractAttentionReason(verdict) {
+  if (!verdict.blocked) return void 0;
+  return verdict.detail ?? verdict.reason;
+}
+
 // src/status.ts
 var NO_START_MS = 18e4;
 var STALE_MS = 6e5;
@@ -954,11 +1076,13 @@ function computeAttention(input) {
     return { state: "blocked", reason: input.completionBlocker };
   }
   if (input.finalResult) {
-    const landing = assessWorkerLanding({
+    const landingSnapshot = {
       finalResult: input.finalResult,
       changedFiles: input.changedFiles ?? [],
-      gitAncestry: input.gitAncestry ?? null
-    });
+      gitAncestry: input.gitAncestry ?? null,
+      prUrl: input.prUrl ?? null
+    };
+    const landing = assessWorkerLanding(landingSnapshot);
     if (landing.blocked) {
       const detail = landingAttentionReason(landing);
       return {
@@ -966,6 +1090,20 @@ function computeAttention(input) {
         reason: landing.reason ? `landing blocked (${landing.reason}): ${detail}` : `landing blocked: ${detail}`
       };
     }
+    if (input.landingContract) {
+      const contractVerdict = assessWorkerLandingContract({
+        contract: input.landingContract,
+        snapshot: landingSnapshot,
+        finalResult: input.finalResult
+      });
+      const contractDetail = landingContractAttentionReason(contractVerdict);
+      if (contractDetail) {
+        return {
+          state: "needs_attention",
+          reason: contractVerdict.reason ? `landing contract (${contractVerdict.reason}): ${contractDetail}` : `landing contract: ${contractDetail}`
+        };
+      }
+    }
     return { state: "done", reason: "final result recorded" };
   }
   if (!input.alive) {
@@ -1003,11 +1141,18 @@ function computeAttention(input) {
   }
   return { state: "ok", reason: "recent activity" };
 }
+function resolveFinalResult(worker, parsedFinalResult, heartbeat) {
+  if (parsedFinalResult) return parsedFinalResult;
+  const ackSnapshot = worker.completionSnapshot?.finalResult;
+  if (ackSnapshot !== void 0 && ackSnapshot !== null) return ackSnapshot;
+  return terminalFinalResultFromHeartbeat(heartbeat);
+}
 function computeWorkerStatus(worker, options = {}) {
   const parsed = parseHarnessStream(worker.stdoutPath);
   const heartbeat = parseHeartbeat(worker.heartbeatPath);
-  const finalResult = parsed.finalResult ?? terminalFinalResultFromHeartbeat(heartbeat);
-  const alive = isPidAlive(worker.pid);
+  const completionAcknowledged = typeof worker.completionReportedAt === "string" && worker.completionReportedAt.trim().length > 0;
+  const finalResult = resolveFinalResult(worker, parsed.finalResult, heartbeat);
+  const alive = completionAcknowledged ? false : isPidAlive(worker.pid);
   const stdoutBytes = fileSize(worker.stdoutPath);
   const stderrBytes = fileSize(worker.stderrPath);
   const heartbeatBytes = fileSize(worker.heartbeatPath);
@@ -1039,7 +1184,7 @@ function computeWorkerStatus(worker, options = {}) {
     gitAncestry,
     completionBlocker
   });
-  const workerStatusLabel = completionBlocker || attention.state === "blocked" ? "blocked" : attention.state === "done" ? "done" : finalResult ? "exited" : alive ? "running" : "exited";
+  const workerStatusLabel = completionBlocker || attention.state === "blocked" ? "blocked" : completionAcknowledged || attention.state === "done" ? "done" : finalResult ? "exited" : alive ? "running" : "exited";
   return {
     runId: worker.runId,
     worker: worker.name,
@@ -1056,12 +1201,13 @@ function computeWorkerStatus(worker, options = {}) {
     firstEventAt: parsed.firstEventAt,
     lastEventAt: parsed.lastEventAt,
     lastActivityAt,
-    currentTool: parsed.currentTool,
+    currentTool: completionAcknowledged ? null : parsed.currentTool,
     heartbeatCount: heartbeat.heartbeatCount,
     lastHeartbeatAt: heartbeat.lastHeartbeatAt,
     lastHeartbeatPhase: heartbeat.lastHeartbeatPhase,
     lastHeartbeatSummary: heartbeat.lastHeartbeatSummary,
     heartbeatBlocker: heartbeat.heartbeatBlocker,
+    timestampAnomalies: heartbeat.timestampAnomalies,
     finalResult,
     error,
     changedFiles,
@@ -1201,6 +1347,16 @@ function normalize(value) {
   return value.toLowerCase();
 }
 var PERSONA_DEFAULT_LANE = {
+  ghost: "system",
+  astra: "plan_author",
+  rhea: "implementer",
+  mnemo: "implementer",
+  sentinel: "deep_reviewer",
+  pixel: "implementer",
+  schema: "implementer",
+  atlas: "runtime_verifier",
+  bridge: "implementer",
+  catalyst: "implementer",
   dalton: "implementer",
   lorentz: "report_reviewer"
 };
@@ -1580,7 +1736,7 @@ function hasLiveWorkerForTask(runId, taskId) {
 
 // src/supervisor.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync3 } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 
 // src/prompt.ts
 function buildPrompt(input) {
@@ -1602,6 +1758,7 @@ function buildPrompt(input) {
   const planArtifactLines = compact ? [
     "Plan artifacts: when authoring/revising docs/superpowers/plans/, open a GitHub PR early and iterate from that PR branch; do not leave the canonical plan only in the harness worktree."
   ] : [
+    "Plan persistence: use AgentOS API/MCP first; on approval/auth/network/server/interruption failures run `kynver plan persist` (queues under ~/.kynver/state/plan-outbox) then `kynver plan outbox drain` when connectivity returns. Never treat /tmp-only files as persisted plans.",
     "PR-first plan artifacts (when authoring or revising docs/superpowers/plans/):",
     "- Before substantial plan drafting: create a feature branch, open a GitHub PR (draft OK), commit and push the plan file \u2014 do not leave the canonical plan only in this harness worktree.",
     "- Iterate review on that PR branch; link prUrl on the AgentOS task and plan progress evidence (`--evidence pr:<url>`).",
@@ -1615,6 +1772,7 @@ function buildPrompt(input) {
     `Progress heartbeat file: ${input.heartbeatPath}`,
     "After each major step, append one JSON line to the heartbeat file with fields: ts, phase, summary, changedFiles, blocker.",
     "Final response must include files changed, verification commands, and unresolved risks.",
+    "Structured final result (recommended): record completion as JSON with summary, laneExpertise { whatChanged, why, files, prUrls, verification, risks, blockers, lessonsLearned, laneGuidance }, and targetPrReconciliation [{ prUrl, outcome: merged|skipped|blocked, mergeCommit?, reason? }] for every target PR on landing-only tasks.",
     "Completion handoff (required): before you stop, ensure the harness records a final result \u2014 summarize outcome in your last message and append a heartbeat line with phase `complete`. If you leave uncommitted changes or committed work without a PR, the orchestrator blocks completion until a GitHub PR exists (or you discard/commit cleanly). Exiting with only dirty files and no PR routes to salvage review, not production review.",
     "PR-ready handoff: for substantial implementation work, commit, push, and open a GitHub PR (draft OK) on your branch before finishing \u2014 or rely on the harness to run `gh pr create` at completion when `gh` is authenticated.",
     "Worker resource guard: do not run full monorepo verification (`npm run typecheck`, `npm run build`, or equivalent) from this worker lane unless an operator explicitly requests it. Use targeted checks for touched paths and rely on CI/operator lanes for heavy gates.",
@@ -1801,15 +1959,15 @@ function resolveWorkerProvider(name) {
 // src/auto-complete.ts
 import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync9, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/worker-ops.ts
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/pr-handoff/pr-handoff-assess.ts
 var REVIEW_LANE_RULE = /^(lane:)?(review|deep_review|planning|landing)(:|$)/i;
-function trimOrNull3(value) {
+function trimOrNull4(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   return trimmed.length ? trimmed : null;
@@ -1817,7 +1975,7 @@ function trimOrNull3(value) {
 function committedHead(ancestry) {
   if (!ancestry?.checked) return null;
   if (ancestry.headIsAncestorOfBase !== false) return null;
-  return trimOrNull3(ancestry.head);
+  return trimOrNull4(ancestry.head);
 }
 function extractPrUrlFromText(value) {
   if (value === void 0 || value === null) return null;
@@ -1825,11 +1983,11 @@ function extractPrUrlFromText(value) {
   const m = text.match(
     /https?:\/\/[^\s)>"]+\/(?:pull|pulls|merge_requests|pull-requests)\/\d+/i
   );
-  return m ? trimOrNull3(m[0]) : null;
+  return m ? trimOrNull4(m[0]) : null;
 }
 function hasWorkProduct(snapshot) {
   if (snapshot.changedFiles.length > 0) return true;
-  if (trimOrNull3(snapshot.headCommit)) return true;
+  if (trimOrNull4(snapshot.headCommit)) return true;
   if (committedHead(snapshot.gitAncestry)) return true;
   return false;
 }
@@ -1837,14 +1995,14 @@ function assessPrHandoffRequirement(input) {
   if (!input.dispatched) {
     return { required: false, reason: "not_dispatched" };
   }
-  const rule = trimOrNull3(input.routingRule) ?? "";
+  const rule = trimOrNull4(input.routingRule) ?? "";
   if (rule && REVIEW_LANE_RULE.test(rule)) {
     return { required: false, reason: "review_lane" };
   }
-  if (trimOrNull3(input.patchPath) || trimOrNull3(input.artifactBundlePath)) {
+  if (trimOrNull4(input.patchPath) || trimOrNull4(input.artifactBundlePath)) {
     return { required: false, reason: "patch_or_bundle" };
   }
-  const prUrl = trimOrNull3(input.prUrl) ?? trimOrNull3(input.snapshot.prUrl);
+  const prUrl = trimOrNull4(input.prUrl) ?? trimOrNull4(input.snapshot.prUrl);
   if (prUrl) {
     return { required: false, reason: "already_has_pr" };
   }
@@ -1860,8 +2018,8 @@ function buildPrHandoffSnapshotFromStatus(status, extras) {
     worktreePath: status.worktreePath,
     gitAncestry: status.gitAncestry,
     finalResult: status.finalResult,
-    headCommit: trimOrNull3(extras?.headCommit) ?? committedHead(status.gitAncestry),
-    prUrl: trimOrNull3(extras?.prUrl) ?? null
+    headCommit: trimOrNull4(extras?.headCommit) ?? committedHead(status.gitAncestry),
+    prUrl: trimOrNull4(extras?.prUrl) ?? null
   };
 }
 
@@ -2154,6 +2312,80 @@ function persistCompletionAck(worker, runId, fields) {
   saveWorker(runId, worker);
 }
 
+// src/worker-lifecycle.ts
+import path9 from "node:path";
+var TASK_LEFT_RUNNING = /* @__PURE__ */ new Set([
+  "awaiting_review",
+  "blocked",
+  "done",
+  "needs_input",
+  "waiting",
+  "scheduled",
+  "ready",
+  "cancelled",
+  "failed"
+]);
+function isCompletionAcknowledged(worker) {
+  return Boolean(
+    typeof worker.completionReportedAt === "string" && worker.completionReportedAt.trim()
+  );
+}
+function completionSnapshotFromStatus(status) {
+  const summary = typeof status.lastHeartbeatSummary === "string" ? status.lastHeartbeatSummary : null;
+  return {
+    finalResult: status.finalResult ?? summary ?? "completed",
+    summary
+  };
+}
+function persistCompletionAcknowledged(worker, status, opts) {
+  if (isCompletionAcknowledged(worker) && worker.status === "done" && worker.completionSnapshot != null) {
+    return;
+  }
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const snapshot = completionSnapshotFromStatus(status);
+  const source = opts?.source?.trim();
+  worker.completionReportedAt = at;
+  worker.completionSnapshot = snapshot;
+  worker.status = "done";
+  if (source) worker.completionAckSource = source;
+  saveWorker(worker.runId, worker);
+}
+function taskStatusByIdFromOperatorTick(operatorTick) {
+  const map = /* @__PURE__ */ new Map();
+  const body = operatorTick;
+  const items = body.response?.tick?.filteredItems;
+  if (!Array.isArray(items)) return map;
+  for (const item of items) {
+    if (item.kind !== "task" || typeof item.id !== "string") continue;
+    const status = typeof item.taskStatus === "string" ? item.taskStatus.trim() : "";
+    if (status) map.set(item.id, status);
+  }
+  return map;
+}
+function syncCompletionAcknowledgedFromOperatorTick(runId, operatorTick) {
+  const taskStatusById = taskStatusByIdFromOperatorTick(operatorTick);
+  if (taskStatusById.size === 0) return [];
+  const run = loadRun(runId);
+  const synced = [];
+  for (const name of Object.keys(run.workers || {})) {
+    const worker = readJson(
+      path9.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
+    );
+    if (!worker?.taskId || isCompletionAcknowledged(worker)) continue;
+    const taskStatus = taskStatusById.get(worker.taskId);
+    if (!taskStatus || taskStatus === "running" || !TASK_LEFT_RUNNING.has(taskStatus)) {
+      continue;
+    }
+    const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
+    persistCompletionAcknowledged(worker, status, {
+      source: `board-task-${taskStatus}`
+    });
+    synced.push({ worker: name, taskId: worker.taskId, taskStatus });
+  }
+  return synced;
+}
+
 // src/worker-ops.ts
 async function postCompletion(url, secret, body) {
   const res = await fetch(url, {
@@ -2285,6 +2517,7 @@ async function tryCompleteWorker(args) {
     workerInjection: {
       instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
       instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null,
+      policyAt: worker.instructionPolicyEvidence && typeof worker.instructionPolicyEvidence === "object" && "policyAt" in worker.instructionPolicyEvidence && typeof worker.instructionPolicyEvidence.policyAt === "string" ? worker.instructionPolicyEvidence.policyAt : null,
       personaSlug: worker.personaSlug ?? null,
       personaEvidence: worker.personaEvidence ?? null
     }
@@ -2305,6 +2538,7 @@ async function tryCompleteWorker(args) {
       completionResponse: result.parsed
     };
     persistCompletionAck(worker, worker.runId, ack);
+    persistCompletionAcknowledged(worker, status, { source: "harness-completion" });
     const prUrl = status.prUrl;
     return {
       ok: true,
@@ -2372,7 +2606,7 @@ function workerStatus(args) {
   const worker = loadWorker(String(args.run), String(args.name));
   const run = loadRun(worker.runId);
   const status = computeWorkerStatus(worker, workerStatusOptions(run));
-  writeJson(path9.join(worker.workerDir, "last-status.json"), status);
+  writeJson(path10.join(worker.workerDir, "last-status.json"), status);
   console.log(JSON.stringify(status, null, 2));
 }
 function buildRunBoard(runId) {
@@ -2380,7 +2614,7 @@ function buildRunBoard(runId) {
   const names = Object.keys(run.workers || {});
   const workers = names.map((name) => {
     const worker = readJson(
-      path9.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path10.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) {
@@ -2490,7 +2724,7 @@ function buildRunBoard(runId) {
     needsAttention: workers.filter((w) => w.attention && w.attention !== "ok" && w.attention !== "done").map((w) => w.worker),
     workers
   };
-  writeJson(path9.join(runDirectory(run.id), "last-board.json"), board);
+  writeJson(path10.join(runDirectory(run.id), "last-board.json"), board);
   return board;
 }
 async function publishHarnessBoardSnapshot(args, source) {
@@ -2657,12 +2891,12 @@ async function autoCompleteWorkerCli(raw) {
   }
 }
 function resolveDefaultCliPath() {
-  return path10.join(fileURLToPath(new URL(".", import.meta.url)), "cli.js");
+  return path11.join(fileURLToPath(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnCompletionSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath();
   if (!existsSync9(cliPath)) return void 0;
-  const logPath = path10.join(opts.workerDir, "auto-complete.log");
+  const logPath = path11.join(opts.workerDir, "auto-complete.log");
   let logFd;
   try {
     logFd = openSync3(logPath, "a");
@@ -2744,16 +2978,16 @@ function spawnWorkerProcess(run, opts) {
     launchModel = preflight.model;
   }
   const { worktreesDir } = getPaths();
-  const workerDir = path11.join(runDirectory(run.id), "workers", name);
+  const workerDir = path12.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
-  const worktreePath = path11.join(worktreesDir, run.id, name);
+  const worktreePath = path12.join(worktreesDir, run.id, name);
   const branch = opts.branch || `agent/${run.id}/${name}`;
   if (existsSync10(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
   git(run.repo, ["fetch", "origin", "--prune"], { allowFailure: true });
   git(run.repo, ["worktree", "add", "-b", branch, worktreePath, run.baseCommit], { throwError: true });
-  const stdoutPath = path11.join(workerDir, "stdout.jsonl");
-  const stderrPath = path11.join(workerDir, "stderr.log");
-  const heartbeatPath = path11.join(workerDir, "heartbeat.jsonl");
+  const stdoutPath = path12.join(workerDir, "stdout.jsonl");
+  const stderrPath = path12.join(workerDir, "stderr.log");
+  const heartbeatPath = path12.join(workerDir, "heartbeat.jsonl");
   const prompt = buildPrompt({
     task: opts.task,
     ownedPaths: opts.ownedPaths || [],
@@ -2814,7 +3048,7 @@ function spawnWorkerProcess(run, opts) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveWorker(run.id, worker);
-  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path11.join(workerDir, "worker.json") } };
+  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path12.join(workerDir, "worker.json") } };
   run.status = "running";
   saveRun(run);
   if (worker.agentOsId && worker.taskId) {
@@ -2908,6 +3142,580 @@ async function startWorker(args) {
   }
 }
 
+// src/plan-persist/body-hash.ts
+import { createHash } from "node:crypto";
+function hashPlanBody(body) {
+  const normalized = body.replace(/\r\n/g, "\n").trimEnd();
+  return createHash("sha256").update(normalized, "utf8").digest("hex");
+}
+function hashSummary(summary) {
+  if (summary == null) return null;
+  const trimmed = summary.trim();
+  if (!trimmed) return null;
+  return createHash("sha256").update(trimmed, "utf8").digest("hex");
+}
+
+// src/plan-persist/errors.ts
+var PlanPersistError = class extends Error {
+  kind;
+  httpStatus;
+  constructor(kind, message, httpStatus) {
+    super(message);
+    this.name = "PlanPersistError";
+    this.kind = kind;
+    this.httpStatus = httpStatus;
+  }
+};
+function classifyHttpFailure(status, message) {
+  if (status === 401 || status === 403) {
+    return new PlanPersistError("auth", message, status);
+  }
+  if (status >= 500) {
+    return new PlanPersistError("server", message, status);
+  }
+  return new PlanPersistError("permanent", message, status);
+}
+function classifyFetchFailure(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/ECONNREFUSED|ENOTFOUND|ETIMEDOUT|fetch failed|network/i.test(message)) {
+    return new PlanPersistError("network", message);
+  }
+  return new PlanPersistError("tool_interruption", message);
+}
+function isRetryableFailure(kind) {
+  return kind !== "permanent";
+}
+
+// src/plan-persist/agentos-api.ts
+function authHeaders(apiKey) {
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  return headers;
+}
+async function parseJsonResponse(res) {
+  const text = await res.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function agentOsGetPlan(slug, planId, deps = {}) {
+  const base = resolveBaseUrl(deps.baseUrl);
+  const apiKey = deps.apiKey ?? loadApiKey();
+  const fetchFn = deps.fetchFn ?? fetch;
+  const url = `${base}/api/agent-os/${encodeURIComponent(slug)}/plans/${encodeURIComponent(planId)}`;
+  try {
+    const res = await fetchFn(url, { method: "GET", headers: authHeaders(apiKey) });
+    const parsed = await parseJsonResponse(res);
+    if (!res.ok) {
+      const msg = typeof parsed === "object" && parsed && "error" in parsed ? String(parsed.error) : `GET plan failed (${res.status})`;
+      throw classifyHttpFailure(res.status, msg);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof PlanPersistError) throw err;
+    throw classifyFetchFailure(err);
+  }
+}
+async function agentOsWritePlan(input, deps = {}) {
+  const base = resolveBaseUrl(deps.baseUrl);
+  const apiKey = deps.apiKey ?? loadApiKey();
+  const fetchFn = deps.fetchFn ?? fetch;
+  const slug = input.agentOsSlug;
+  try {
+    if (input.operation === "create") {
+      const url2 = `${base}/api/agent-os/${encodeURIComponent(slug)}/plans`;
+      const body2 = {
+        title: input.title,
+        summary: input.summary ?? null,
+        slug: input.planSlug ?? null,
+        sourceRefs: mergeSourceRefs(input),
+        initialVersion: {
+          title: input.title,
+          body: input.body,
+          summary: input.summary ?? null,
+          changeSummary: input.changeSummary ?? null,
+          author: input.author ?? null,
+          sourceRefs: mergeSourceRefs(input)
+        }
+      };
+      const res2 = await fetchFn(url2, {
+        method: "POST",
+        headers: authHeaders(apiKey),
+        body: JSON.stringify(body2)
+      });
+      const parsed2 = await parseJsonResponse(res2);
+      if (!res2.ok) {
+        const msg = typeof parsed2 === "object" && parsed2 && "error" in parsed2 ? String(parsed2.error) : `create plan failed (${res2.status})`;
+        throw classifyHttpFailure(res2.status, msg);
+      }
+      const row2 = parsed2;
+      return {
+        planId: row2.plan.id,
+        versionId: row2.version.id,
+        versionNumber: row2.version.versionNumber
+      };
+    }
+    const planId = input.planId;
+    if (!planId) throw new PlanPersistError("permanent", "planId is required for this operation");
+    if (input.operation === "update_metadata") {
+      const url2 = `${base}/api/agent-os/${encodeURIComponent(slug)}/plans/${encodeURIComponent(planId)}`;
+      const body2 = {
+        title: input.title,
+        summary: input.summary ?? null,
+        sourceRefs: mergeSourceRefs(input)
+      };
+      const res2 = await fetchFn(url2, {
+        method: "PATCH",
+        headers: authHeaders(apiKey),
+        body: JSON.stringify(body2)
+      });
+      const parsed2 = await parseJsonResponse(res2);
+      if (!res2.ok) {
+        const msg = typeof parsed2 === "object" && parsed2 && "error" in parsed2 ? String(parsed2.error) : `update plan failed (${res2.status})`;
+        throw classifyHttpFailure(res2.status, msg);
+      }
+      const row2 = parsed2;
+      return {
+        planId: row2.id,
+        versionId: row2.currentVersionId,
+        versionNumber: null
+      };
+    }
+    const url = `${base}/api/agent-os/${encodeURIComponent(slug)}/plans/${encodeURIComponent(planId)}/versions`;
+    const body = {
+      title: input.title,
+      body: input.body,
+      summary: input.summary ?? null,
+      changeSummary: input.changeSummary ?? null,
+      author: input.author ?? null,
+      sourceRefs: mergeSourceRefs(input),
+      markCurrent: input.markCurrent !== false
+    };
+    const res = await fetchFn(url, {
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: JSON.stringify(body)
+    });
+    const parsed = await parseJsonResponse(res);
+    if (!res.ok) {
+      const msg = typeof parsed === "object" && parsed && "error" in parsed ? String(parsed.error) : `add version failed (${res.status})`;
+      throw classifyHttpFailure(res.status, msg);
+    }
+    const row = parsed;
+    return {
+      planId: row.version.planId,
+      versionId: row.version.id,
+      versionNumber: row.version.versionNumber
+    };
+  } catch (err) {
+    if (err instanceof PlanPersistError) throw err;
+    throw classifyFetchFailure(err);
+  }
+}
+function mergeSourceRefs(input) {
+  const refs = { ...input.sourceRefs ?? {} };
+  if (input.model) refs.model = input.model;
+  if (!Object.keys(refs).length) return input.sourceRefs ?? null;
+  return refs;
+}
+
+// src/plan-persist/idempotency.ts
+import { createHash as createHash2 } from "node:crypto";
+function buildPlanPersistIdempotencyKey(input) {
+  const payload = {
+    operation: input.operation,
+    agentOsSlug: input.agentOsSlug,
+    planId: input.planId ?? null,
+    planSlug: input.planSlug ?? null,
+    title: input.title.trim(),
+    summaryHash: hashSummary(input.summary),
+    bodyHash: hashPlanBody(input.body),
+    changeSummary: input.changeSummary?.trim() ?? null,
+    markCurrent: input.markCurrent ?? true
+  };
+  return createHash2("sha256").update(JSON.stringify(payload), "utf8").digest("hex");
+}
+
+// src/plan-persist/paths.ts
+import { mkdirSync as mkdirSync4 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import path13 from "node:path";
+function resolveKynverStateRoot() {
+  const env = process.env.KYNVER_STATE_ROOT;
+  if (env) return path13.resolve(env);
+  return path13.join(homedir3(), ".kynver", "state");
+}
+function planOutboxDir() {
+  return path13.join(resolveKynverStateRoot(), "plan-outbox");
+}
+function planOutboxArchiveDir() {
+  return path13.join(resolveKynverStateRoot(), "plan-outbox-archive");
+}
+function ensurePlanOutboxDirs() {
+  const outboxDir = planOutboxDir();
+  const archiveDir = planOutboxArchiveDir();
+  mkdirSync4(outboxDir, { recursive: true });
+  mkdirSync4(archiveDir, { recursive: true });
+  return { outboxDir, archiveDir };
+}
+function isTmpOnlyPath(filePath) {
+  if (filePath.startsWith("/tmp/") || filePath.startsWith("/var/folders/")) return true;
+  const resolved = path13.resolve(filePath);
+  return resolved.startsWith("/tmp/") || resolved.startsWith(path13.join("/var", "folders"));
+}
+
+// src/plan-persist/outbox-store.ts
+import {
+  existsSync as existsSync12,
+  readFileSync as readFileSync6,
+  renameSync,
+  readdirSync as readdirSync4,
+  writeFileSync as writeFileSync3,
+  unlinkSync
+} from "node:fs";
+import path14 from "node:path";
+import { randomUUID } from "node:crypto";
+var DEFAULT_MAX_RETRIES = 12;
+function listOutboxItems() {
+  const { outboxDir } = ensurePlanOutboxDirs();
+  const files = readdirSync4(outboxDir).filter((f) => f.endsWith(".json"));
+  const items = [];
+  for (const file of files) {
+    const item = readOutboxItem(path14.join(outboxDir, file));
+    if (item && item.queueStatus === "queued") items.push(item);
+  }
+  return items.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function findOutboxByIdempotencyKey(key) {
+  for (const item of listOutboxItems()) {
+    if (item.idempotencyKey === key) return item;
+  }
+  return null;
+}
+function readOutboxItem(jsonPath) {
+  if (!existsSync12(jsonPath)) return null;
+  try {
+    return JSON.parse(readFileSync6(jsonPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readOutboxBody(item) {
+  const { outboxDir } = ensurePlanOutboxDirs();
+  const bodyFile = path14.join(outboxDir, item.bodyPath);
+  return readFileSync6(bodyFile, "utf8");
+}
+function writeOutboxItem(input, opts) {
+  const { outboxDir } = ensurePlanOutboxDirs();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = opts.existing?.id ?? randomUUID();
+  const bodyPath = opts.existing?.bodyPath ?? `${id}.body.md`;
+  const jsonPath = path14.join(outboxDir, `${id}.json`);
+  const bodyFile = path14.join(outboxDir, bodyPath);
+  if (!opts.existing) {
+    writeFileSync3(bodyFile, input.body, "utf8");
+  }
+  const item = {
+    id,
+    idempotencyKey: buildPlanPersistIdempotencyKey(input),
+    operation: input.operation,
+    agentOsSlug: input.agentOsSlug,
+    planId: input.planId ?? opts.existing?.planId ?? null,
+    planSlug: input.planSlug ?? opts.existing?.planSlug ?? null,
+    title: input.title,
+    summary: input.summary ?? null,
+    bodyPath,
+    bodyHash: hashPlanBody(input.body),
+    author: input.author ?? null,
+    model: input.model ?? null,
+    sourceRefs: input.sourceRefs ?? null,
+    changeSummary: input.changeSummary ?? null,
+    markCurrent: input.markCurrent ?? true,
+    createdAt: opts.existing?.createdAt ?? now,
+    updatedAt: now,
+    retryCount: (opts.existing?.retryCount ?? 0) + (opts.existing ? 1 : 0),
+    maxRetries: input.maxRetries ?? opts.existing?.maxRetries ?? DEFAULT_MAX_RETRIES,
+    lastError: opts.lastError,
+    lastFailureKind: opts.lastFailureKind,
+    queueStatus: "queued",
+    userStatus: "queued for retry",
+    readbackEvidence: null
+  };
+  writeFileSync3(jsonPath, `${JSON.stringify(item, null, 2)}
+`, { mode: 384 });
+  return item;
+}
+function saveOutboxItem(item) {
+  const { outboxDir } = ensurePlanOutboxDirs();
+  const jsonPath = path14.join(outboxDir, `${item.id}.json`);
+  writeFileSync3(jsonPath, `${JSON.stringify(item, null, 2)}
+`, { mode: 384 });
+}
+function archiveOutboxItem(item) {
+  const { outboxDir, archiveDir } = ensurePlanOutboxDirs();
+  const jsonSrc = path14.join(outboxDir, `${item.id}.json`);
+  const bodySrc = path14.join(outboxDir, item.bodyPath);
+  const jsonDst = path14.join(archiveDir, `${item.id}.json`);
+  const bodyDst = path14.join(archiveDir, item.bodyPath);
+  if (existsSync12(jsonSrc)) renameSync(jsonSrc, jsonDst);
+  if (existsSync12(bodySrc)) renameSync(bodySrc, bodyDst);
+}
+function outboxItemPaths(item) {
+  const { outboxDir } = ensurePlanOutboxDirs();
+  return {
+    jsonPath: path14.join(outboxDir, `${item.id}.json`),
+    bodyPath: path14.join(outboxDir, item.bodyPath)
+  };
+}
+function outboxInputFromItem(item, body) {
+  return {
+    operation: item.operation,
+    agentOsSlug: item.agentOsSlug,
+    planId: item.planId,
+    planSlug: item.planSlug,
+    title: item.title,
+    summary: item.summary,
+    body,
+    changeSummary: item.changeSummary ?? void 0,
+    author: item.author ?? void 0,
+    model: item.model ?? void 0,
+    sourceRefs: item.sourceRefs,
+    markCurrent: item.markCurrent ?? true,
+    maxRetries: item.maxRetries
+  };
+}
+
+// src/plan-persist/readback.ts
+async function verifyPlanReadback(slug, expectation, deps = {}) {
+  const payload = await agentOsGetPlan(slug, expectation.planId, deps);
+  const plan = payload.plan;
+  const current = payload.currentVersion;
+  if (plan.title.trim() !== expectation.title.trim()) {
+    throw new PlanPersistError(
+      "verification_failed",
+      `title mismatch: expected "${expectation.title}", got "${plan.title}"`
+    );
+  }
+  const expectedSummaryHash = hashSummary(expectation.summary);
+  const actualSummaryHash = hashSummary(plan.summary);
+  if (expectedSummaryHash !== actualSummaryHash) {
+    throw new PlanPersistError("verification_failed", "summary mismatch on readback");
+  }
+  if (expectation.versionId && plan.currentVersionId !== expectation.versionId) {
+    throw new PlanPersistError(
+      "verification_failed",
+      `currentVersionId mismatch: expected ${expectation.versionId}, got ${plan.currentVersionId}`
+    );
+  }
+  if (expectation.versionNumber != null) {
+    if (!current || current.versionNumber !== expectation.versionNumber) {
+      throw new PlanPersistError(
+        "verification_failed",
+        `versionNumber mismatch: expected ${expectation.versionNumber}, got ${current?.versionNumber ?? "none"}`
+      );
+    }
+  }
+  const bodyForHash = current?.body ?? "";
+  const actualBodyHash = hashPlanBody(bodyForHash);
+  if (expectation.bodyHash && actualBodyHash !== expectation.bodyHash) {
+    throw new PlanPersistError("verification_failed", "body hash mismatch on readback");
+  }
+  return {
+    planId: plan.id,
+    currentVersionId: plan.currentVersionId,
+    versionNumber: current?.versionNumber ?? null,
+    title: plan.title,
+    summary: plan.summary,
+    bodyHash: expectation.bodyHash || actualBodyHash,
+    readAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildReadbackExpectation(input, write) {
+  return {
+    planId: write.planId,
+    title: input.title,
+    summary: input.summary ?? null,
+    body: input.body,
+    bodyHash: hashPlanBody(input.body),
+    versionId: write.versionId,
+    versionNumber: write.versionNumber
+  };
+}
+
+// src/plan-persist/persist.ts
+var SUCCESS_STATUS = "persisted and read back";
+var QUEUED_STATUS = "queued for retry";
+var FAILED_STATUS = "failed and needs action";
+async function persistPlan(input, deps = {}) {
+  if (input.bodyPathHint && isTmpOnlyPath(input.bodyPathHint)) {
+  }
+  const idempotencyKey = buildPlanPersistIdempotencyKey(input);
+  const existingOutbox = findOutboxByIdempotencyKey(idempotencyKey);
+  if (existingOutbox?.readbackEvidence) {
+    return {
+      userStatus: SUCCESS_STATUS,
+      outboxId: existingOutbox.id,
+      planId: existingOutbox.readbackEvidence.planId,
+      readbackEvidence: existingOutbox.readbackEvidence,
+      idempotencyKey
+    };
+  }
+  if (input.immediateFailure) {
+    return queueForRetry(input, input.immediateFailure.message, input.immediateFailure.kind, existingOutbox);
+  }
+  const writeFn = deps.writePlan ?? agentOsWritePlan;
+  const verifyFn = deps.verifyReadback ?? verifyPlanReadback;
+  try {
+    const write = await writeFn(input, deps);
+    const enriched = { ...input, planId: write.planId };
+    const expectation = buildReadbackExpectation(enriched, write);
+    const readback = await verifyFn(
+      input.agentOsSlug,
+      readbackExpectationForOperation(input, expectation),
+      deps
+    );
+    if (existingOutbox) archiveOutboxItem(existingOutbox);
+    return {
+      userStatus: SUCCESS_STATUS,
+      planId: write.planId,
+      versionId: write.versionId ?? void 0,
+      readbackEvidence: readback,
+      idempotencyKey
+    };
+  } catch (err) {
+    const failure = err instanceof PlanPersistError ? err : new PlanPersistError("tool_interruption", err instanceof Error ? err.message : String(err));
+    if (!isRetryableFailure(failure.kind)) {
+      const item = writeOutboxItem(input, {
+        lastError: failure.message,
+        lastFailureKind: failure.kind,
+        existing: existingOutbox ?? void 0
+      });
+      const paths = outboxItemPaths(item);
+      const failed = markOutboxFailed(item, failure.message);
+      return {
+        userStatus: FAILED_STATUS,
+        outboxId: failed.id,
+        outboxPath: paths.jsonPath,
+        bodyPath: paths.bodyPath,
+        lastError: failure.message,
+        idempotencyKey
+      };
+    }
+    return queueForRetry(input, failure.message, failure.kind, existingOutbox);
+  }
+}
+function readbackExpectationForOperation(input, expectation) {
+  if (input.operation === "update_metadata") {
+    return { ...expectation, body: "", bodyHash: "" };
+  }
+  return expectation;
+}
+function queueForRetry(input, message, kind, existing) {
+  const item = writeOutboxItem(input, {
+    lastError: message,
+    lastFailureKind: kind,
+    existing: existing ?? void 0
+  });
+  const paths = outboxItemPaths(item);
+  if (item.retryCount >= item.maxRetries) {
+    const failed = markOutboxFailed(item, message);
+    return {
+      userStatus: FAILED_STATUS,
+      outboxId: failed.id,
+      outboxPath: paths.jsonPath,
+      bodyPath: paths.bodyPath,
+      lastError: message,
+      idempotencyKey: item.idempotencyKey
+    };
+  }
+  return {
+    userStatus: QUEUED_STATUS,
+    outboxId: item.id,
+    outboxPath: paths.jsonPath,
+    bodyPath: paths.bodyPath,
+    lastError: message,
+    idempotencyKey: item.idempotencyKey
+  };
+}
+function markOutboxFailed(item, message) {
+  const failed = {
+    ...item,
+    queueStatus: "failed",
+    userStatus: FAILED_STATUS,
+    lastError: message,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveOutboxItem(failed);
+  return failed;
+}
+
+// src/plan-persist/drain.ts
+import path15 from "node:path";
+async function drainPlanOutbox(opts = {}, deps = {}) {
+  const items = listOutboxItems().filter(
+    (item) => opts.outboxId ? item.id === opts.outboxId : true
+  );
+  const slice = opts.max && opts.max > 0 ? items.slice(0, opts.max) : items;
+  const result = {
+    processed: 0,
+    succeeded: 0,
+    stillQueued: 0,
+    failed: 0,
+    results: []
+  };
+  for (const item of slice) {
+    result.processed += 1;
+    const body = readOutboxBody(item);
+    const input = outboxInputFromItem(item, body);
+    const attempt = await persistPlan(input, deps);
+    if (attempt.userStatus === "persisted and read back") {
+      result.succeeded += 1;
+    } else if (attempt.userStatus === "failed and needs action") {
+      result.failed += 1;
+    } else {
+      result.stillQueued += 1;
+    }
+    result.results.push({
+      outboxId: item.id,
+      userStatus: attempt.userStatus,
+      lastError: attempt.lastError
+    });
+  }
+  return result;
+}
+function loadOutboxById(outboxId) {
+  const jsonPath = path15.join(planOutboxDir(), `${outboxId}.json`);
+  return readOutboxItem(jsonPath);
+}
+
+// src/plan-persist/handoff.ts
+function formatPlanOutboxHandoffBlock(item) {
+  const paths = outboxItemPaths(item);
+  return [
+    "## Plan persistence risk",
+    "",
+    `AgentOS plan write is **not** confirmed (${item.userStatus}).`,
+    `- outboxId: \`${item.id}\``,
+    item.planId ? `- planId: \`${item.planId}\`` : "- planId: (pending \u2014 create not yet applied)",
+    `- outbox: \`${paths.jsonPath}\``,
+    `- body: \`${paths.bodyPath}\``,
+    "",
+    "Drain when approval/connectivity returns: `kynver plan outbox drain`"
+  ].join("\n");
+}
+function extractPlanOutboxFromTask(task) {
+  const meta = task.metadata && typeof task.metadata === "object" ? task.metadata : null;
+  const outboxId = typeof task.planPersistenceOutboxId === "string" && task.planPersistenceOutboxId || (meta && typeof meta.planPersistenceOutboxId === "string" ? meta.planPersistenceOutboxId : void 0);
+  if (!outboxId) return null;
+  return {
+    outboxId,
+    jsonPath: typeof task.planPersistenceOutboxPath === "string" ? task.planPersistenceOutboxPath : meta && typeof meta.planPersistenceOutboxPath === "string" ? meta.planPersistenceOutboxPath : void 0,
+    bodyPath: typeof task.planPersistenceBodyPath === "string" ? task.planPersistenceBodyPath : meta && typeof meta.planPersistenceBodyPath === "string" ? meta.planPersistenceBodyPath : void 0
+  };
+}
+
 // src/dispatch.ts
 var DEFAULT_DISPATCH_LEASE_MS = 60 * 60 * 1e3;
 function readHarnessWorkerContext(decision) {
@@ -2937,14 +3745,29 @@ function normalizePersonaSlug(value) {
   return trimmed.length ? trimmed : null;
 }
 function buildDispatchTaskText(task, agentOsId) {
-  return [
+  const lines = [
     `[AgentOS task ${task.id}] ${task.title}`,
     "",
     task.description ? String(task.description) : "(no description on the board task)",
     "",
     `Board linkage: agentOsId=${agentOsId}, taskId=${task.id}, attempt=${task.attempt}, executor=${task.executor}${task.executorRef ? `, executorRef=${task.executorRef}` : ""}.`,
     "This worker was dispatched from the AgentOS board. The harness reports your completion back to the board when you finish."
-  ].join("\n");
+  ];
+  const outboxRef = extractPlanOutboxFromTask(task);
+  if (outboxRef?.outboxId) {
+    const item = loadOutboxById(outboxRef.outboxId);
+    if (item) {
+      lines.push("", formatPlanOutboxHandoffBlock(item));
+    } else {
+      lines.push(
+        "",
+        `## Plan persistence risk`,
+        "",
+        `Unconfirmed AgentOS plan write (outboxId=${outboxRef.outboxId}).`
+      );
+    }
+  }
+  return lines.join("\n");
 }
 async function dispatchRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
@@ -2963,7 +3786,7 @@ async function dispatchRun(args) {
     const activeHarnessWorkers = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path16.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker?.taskId || !isPidAlive(worker.pid)) continue;
@@ -3167,7 +3990,7 @@ async function dispatchRun(args) {
 }
 
 // src/sweep.ts
-import path13 from "node:path";
+import path17 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -3180,7 +4003,7 @@ async function sweepRun(args) {
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path13.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path17.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
@@ -3223,11 +4046,11 @@ async function sweepRun(args) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync4 } from "node:fs";
-import path15 from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5 } from "node:fs";
+import path19 from "node:path";
 
 // src/validate.ts
-import path14 from "node:path";
+import path18 from "node:path";
 var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 function validateRunId(runId) {
   const trimmed = runId.trim();
@@ -3235,7 +4058,7 @@ function validateRunId(runId) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path14.resolve(repo);
+  const resolved = path18.resolve(repo);
   if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
   return resolved;
 }
@@ -3246,8 +4069,8 @@ function createRun(args) {
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync11(dir)) failExists(`run already exists: ${id}`);
-  mkdirSync4(dir, { recursive: true });
+  if (existsSync13(dir)) failExists(`run already exists: ${id}`);
+  mkdirSync5(dir, { recursive: true });
   const base = String(args.base || "origin/main");
   const baseCommit = git(repo, ["rev-parse", base]).trim();
   const run = {
@@ -3260,12 +4083,12 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path15.join(dir, "run.json"), run);
+  writeJson(path19.join(dir, "run.json"), run);
   console.log(JSON.stringify({ runId: id, runDir: dir, repo, base, baseCommit }, null, 2));
 }
 function listRuns() {
   const { runsDir } = getPaths();
-  const rows = listRunIds(runsDir).map((id) => readJson(path15.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
+  const rows = listRunIds(runsDir).map((id) => readJson(path19.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
     id: run.id,
     name: run.name,
     status: run.status,
@@ -3280,13 +4103,64 @@ function failExists(message) {
 }
 
 // src/pipeline-tick.ts
-import path24 from "node:path";
+import path28 from "node:path";
+
+// src/pipeline-dispatch.ts
+var RESERVED_REVIEW_STARTS = 1;
+function countDispatchStarts(result) {
+  if (!result || typeof result !== "object") return 0;
+  const startedCount = result.startedCount;
+  if (typeof startedCount === "number") return startedCount;
+  const outcomes = result.outcomes;
+  if (!Array.isArray(outcomes)) return 0;
+  return outcomes.filter((o) => o.started).length;
+}
+function stripCliMaxStarts(args) {
+  const { maxStarts: _maxStarts, ...rest } = args;
+  return rest;
+}
+async function runPipelineDispatch(args, slots) {
+  if (slots <= 0) {
+    return { ok: true, skipped: true, reason: "no slots", maxStarts: 0, startedCount: 0 };
+  }
+  const base = stripCliMaxStarts(args);
+  const reviewBudget = Math.min(slots, RESERVED_REVIEW_STARTS);
+  const workBudget = Math.max(0, slots - reviewBudget);
+  const review = await dispatchRun({
+    ...base,
+    execute: true,
+    pipeline: true,
+    lane: "review",
+    maxStarts: String(reviewBudget)
+  });
+  const reviewStarted = countDispatchStarts(review);
+  const workSlots = workBudget + (reviewBudget - reviewStarted);
+  if (workSlots <= 0) {
+    return {
+      ...typeof review === "object" && review !== null ? review : {},
+      passes: { review },
+      startedCount: reviewStarted
+    };
+  }
+  const work = await dispatchRun({
+    ...base,
+    execute: true,
+    pipeline: true,
+    maxStarts: String(workSlots)
+  });
+  const workStarted = countDispatchStarts(work);
+  return {
+    passes: { review, work },
+    startedCount: reviewStarted + workStarted,
+    ok: true
+  };
+}
 
 // src/stale-reconcile.ts
-import path17 from "node:path";
+import path21 from "node:path";
 
 // src/finalize.ts
-import path16 from "node:path";
+import path20 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set(["running", "dispatching", "pending", "queued"]);
 function terminalStatusFor(run) {
   const names = Object.keys(run.workers || {});
@@ -3297,7 +4171,7 @@ function terminalStatusFor(run) {
   let anyLandingBlocked = false;
   for (const name of names) {
     const worker = readJson(
-      path16.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path20.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) continue;
@@ -3349,7 +4223,7 @@ function reconcileStaleWorkers() {
   const now = Date.now();
   for (const run of listRunRecords()) {
     for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path17.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path21.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker || worker.status !== "running") {
         outcomes.push({
@@ -3425,7 +4299,7 @@ function reconcileStaleWorkers() {
 }
 
 // src/plan-progress-daemon-sync.ts
-import path18 from "node:path";
+import path22 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -3449,7 +4323,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path18.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path22.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -3498,7 +4372,7 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 }
 
 // src/cleanup.ts
-import path23 from "node:path";
+import path27 from "node:path";
 
 // src/cleanup-types.ts
 var DEFAULT_NODE_MODULES_AGE_MS = 6 * 60 * 60 * 1e3;
@@ -3569,14 +4443,14 @@ function skipNodeModulesRemoval(input) {
 }
 
 // src/cleanup-execute.ts
-import { existsSync as existsSync13, rmSync } from "node:fs";
-import path20 from "node:path";
+import { existsSync as existsSync15, rmSync } from "node:fs";
+import path24 from "node:path";
 
 // src/cleanup-dir-size.ts
-import { existsSync as existsSync12, readdirSync as readdirSync4, statSync as statSync2 } from "node:fs";
-import path19 from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
+import path23 from "node:path";
 function directorySizeBytes(root, maxEntries = 5e4) {
-  if (!existsSync12(root)) return 0;
+  if (!existsSync14(root)) return 0;
   let total = 0;
   let seen = 0;
   const stack = [root];
@@ -3584,13 +4458,13 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     const current = stack.pop();
     let entries;
     try {
-      entries = readdirSync4(current);
+      entries = readdirSync5(current);
     } catch {
       continue;
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path19.join(current, name);
+      const full = path23.join(current, name);
       let st;
       try {
         st = statSync2(full);
@@ -3606,7 +4480,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
 
 // src/cleanup-execute.ts
 function removeNodeModules(candidate, execute) {
-  if (!existsSync13(candidate.path)) {
+  if (!existsSync15(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -3637,7 +4511,7 @@ function removeNodeModules(candidate, execute) {
   }
 }
 function removeWorktree(candidate, execute) {
-  if (!existsSync13(candidate.path)) {
+  if (!existsSync15(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -3654,7 +4528,7 @@ function removeWorktree(candidate, execute) {
     if (repo) {
       git(repo, ["worktree", "remove", "--force", candidate.path], { allowFailure: true });
     }
-    if (existsSync13(candidate.path)) {
+    if (existsSync15(candidate.path)) {
       rmSync(candidate.path, { recursive: true, force: true });
     }
     return {
@@ -3674,20 +4548,20 @@ function removeWorktree(candidate, execute) {
   }
 }
 function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path20.resolve(targetPath);
-  const nm = resolved.endsWith(`${path20.sep}node_modules`) ? resolved : null;
+  const resolved = path24.resolve(targetPath);
+  const nm = resolved.endsWith(`${path24.sep}node_modules`) ? resolved : null;
   if (!nm) return "path_outside_harness";
-  const rel = path20.relative(worktreesDir, nm);
-  if (rel.startsWith("..") || path20.isAbsolute(rel)) return "path_outside_harness";
-  const parts = rel.split(path20.sep);
+  const rel = path24.relative(worktreesDir, nm);
+  if (rel.startsWith("..") || path24.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path24.sep);
   if (parts.length < 3 || parts[parts.length - 1] !== "node_modules") return "path_outside_harness";
-  if (!resolved.startsWith(path20.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path24.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 
 // src/cleanup-scan.ts
-import { existsSync as existsSync14, readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
-import path21 from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import path25 from "node:path";
 function pathAgeMs(target, now) {
   try {
     const mtime = statSync3(target).mtimeMs;
@@ -3697,17 +4571,17 @@ function pathAgeMs(target, now) {
   }
 }
 function isPathInside(child, parent) {
-  const rel = path21.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path21.isAbsolute(rel);
+  const rel = path25.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path25.isAbsolute(rel);
 }
 function scanNodeModulesCandidates(opts) {
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
     if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
-    const nm = path21.join(entry.worktreePath, "node_modules");
-    if (!existsSync14(nm)) continue;
-    const resolved = path21.resolve(nm);
+    const nm = path25.join(entry.worktreePath, "node_modules");
+    if (!existsSync16(nm)) continue;
+    const resolved = path25.resolve(nm);
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     candidates.push({
@@ -3720,16 +4594,16 @@ function scanNodeModulesCandidates(opts) {
       ageMs: pathAgeMs(resolved, opts.now)
     });
   }
-  if (!opts.includeOrphans || !existsSync14(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync5(opts.worktreesDir, { withFileTypes: true })) {
+  if (!opts.includeOrphans || !existsSync16(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync6(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path21.join(opts.worktreesDir, runEntry.name);
-    for (const workerEntry of readdirSync5(runPath, { withFileTypes: true })) {
+    const runPath = path25.join(opts.worktreesDir, runEntry.name);
+    for (const workerEntry of readdirSync6(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path21.join(runPath, workerEntry.name);
-      const nm = path21.join(worktreePath, "node_modules");
-      if (!existsSync14(nm)) continue;
-      const resolved = path21.resolve(nm);
+      const worktreePath = path25.join(runPath, workerEntry.name);
+      const nm = path25.join(worktreePath, "node_modules");
+      if (!existsSync16(nm)) continue;
+      const resolved = path25.resolve(nm);
       if (seen.has(resolved)) continue;
       if (!isPathInside(resolved, opts.harnessRoot)) continue;
       seen.add(resolved);
@@ -3752,7 +4626,7 @@ function scanWorktreeCandidates(opts) {
   for (const entry of opts.index.values()) {
     if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
     const resolved = entry.worktreePath;
-    if (!existsSync14(resolved)) continue;
+    if (!existsSync16(resolved)) continue;
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     candidates.push({
@@ -3769,17 +4643,17 @@ function scanWorktreeCandidates(opts) {
 }
 
 // src/cleanup-worktree-index.ts
-import path22 from "node:path";
+import path26 from "node:path";
 function buildWorktreeIndex() {
   const index = /* @__PURE__ */ new Map();
   for (const run of listRunRecords()) {
     for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path22.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path26.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker?.worktreePath) continue;
       const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
-      index.set(path22.resolve(worker.worktreePath), {
-        worktreePath: path22.resolve(worker.worktreePath),
+      index.set(path26.resolve(worker.worktreePath), {
+        worktreePath: path26.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -3793,8 +4667,8 @@ function buildWorktreeIndex() {
 
 // src/cleanup.ts
 function resolveOptions(options = {}) {
-  const harnessRoot = options.harnessRoot ? path23.resolve(options.harnessRoot) : resolveHarnessRoot();
-  const { worktreesDir } = options.harnessRoot ? { worktreesDir: path23.join(harnessRoot, "worktrees") } : getHarnessPaths();
+  const harnessRoot = options.harnessRoot ? path27.resolve(options.harnessRoot) : resolveHarnessRoot();
+  const { worktreesDir } = options.harnessRoot ? { worktreesDir: path27.join(harnessRoot, "worktrees") } : getHarnessPaths();
   const execute = options.execute === true;
   const nodeModulesAgeMs = options.nodeModulesAgeMs ?? DEFAULT_NODE_MODULES_AGE_MS;
   const worktreesAgeMs = options.worktreesAgeMs ?? 0;
@@ -3838,7 +4712,7 @@ function runHarnessCleanup(options = {}) {
       actions.push({ ...candidate, executed: false, skipped: true, skipReason: pathSkip });
       continue;
     }
-    const worktreePath = path23.resolve(candidate.path, "..");
+    const worktreePath = path27.resolve(candidate.path, "..");
     const indexed = index.get(worktreePath) ?? null;
     const guardReason = skipNodeModulesRemoval({
       indexed,
@@ -3854,7 +4728,7 @@ function runHarnessCleanup(options = {}) {
     actions.push(removeNodeModules(candidate, resolved.execute));
   }
   for (const candidate of scanWorktreeCandidates(scanOpts)) {
-    const indexed = index.get(path23.resolve(candidate.path)) ?? null;
+    const indexed = index.get(path27.resolve(candidate.path)) ?? null;
     const guardReason = skipWorktreeRemoval({
       indexed,
       includeOrphans: resolved.includeOrphans,
@@ -3923,7 +4797,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path24.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path28.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -3974,6 +4848,7 @@ async function runPipelineTick(args) {
     configuredMaxWorkersOverride: workspacePrefs?.maxConcurrentWorkers
   });
   const operatorTick = await postOperatorTick(agentOsId, runId, resourceGate, args);
+  const completionAckSync = syncCompletionAcknowledgedFromOperatorTick(runId, operatorTick);
   const leaseRenewal = await renewActiveTaskLeases(runId, args);
   const completedWorkers = await completeFinishedWorkers(runId, args);
   const staleReconcile = reconcileStaleWorkers();
@@ -3988,14 +4863,14 @@ async function runPipelineTick(args) {
   const sweep = await sweepRun({ run: runId, agentOsId, pipeline: true, ...args });
   let dispatch = null;
   if (execute && maxStarts > 0) {
-    dispatch = await dispatchRun({
-      run: runId,
-      agentOsId,
-      execute: true,
-      maxStarts: String(maxStarts),
-      pipeline: true,
-      ...args
-    });
+    dispatch = await runPipelineDispatch(
+      {
+        ...args,
+        run: runId,
+        agentOsId
+      },
+      maxStarts
+    );
   } else {
     dispatch = {
       ok: true,
@@ -4016,6 +4891,7 @@ async function runPipelineTick(args) {
     staleReconcile,
     harnessCleanup,
     planProgressSync,
+    completionAckSync,
     operatorTick,
     sweep,
     dispatch,
@@ -4087,6 +4963,8 @@ async function emitPlanProgress(args) {
   const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/plans/${encodeURIComponent(planId)}/progress-events`;
   const cfg = loadUserConfig();
   const provider = cfg.workerProvider ? `provider:${cfg.workerProvider}` : void 0;
+  const explicitProposed = args.proposed === true || args.proposed === "true" ? true : args.proposed === false || args.proposed === "false" ? false : void 0;
+  const proposed = explicitProposed ?? (status !== "done" && (roleLane === "implementer" || roleLane === "repair_implementer"));
   const body = {
     rowKey: args.row ? String(args.row) : void 0,
     rowId: args.rowId ? String(args.rowId) : void 0,
@@ -4097,9 +4975,9 @@ async function emitPlanProgress(args) {
     note: args.note ? String(args.note) : void 0,
     remainingWork: args.remaining ? String(args.remaining) : void 0,
     evidence: evidence.length ? evidence : void 0,
-    proposed: args.proposed === true || args.proposed === "true",
     executorRef: args.executorRef ? String(args.executorRef) : provider
   };
+  if (proposed !== void 0) body.proposed = proposed;
   const res = await fetch(url, {
     method: "POST",
     headers: buildHarnessCallbackHeaders(secret),
@@ -4153,6 +5031,86 @@ async function verifyPlan(args) {
   console.log(JSON.stringify(parsed, null, 2));
 }
 
+// src/plan-persist-cli.ts
+import { readFileSync as readFileSync7 } from "node:fs";
+var OPERATIONS = ["create", "add_version", "update_metadata"];
+var FAILURE_KINDS = [
+  "approval_guard",
+  "auth",
+  "network",
+  "server",
+  "tool_interruption"
+];
+function readBodyArg(args) {
+  const bodyFile = args.bodyFile ? String(args.bodyFile) : void 0;
+  if (bodyFile) {
+    return { body: readFileSync7(bodyFile, "utf8"), bodyPathHint: bodyFile };
+  }
+  const inline = args.body ? String(args.body) : void 0;
+  if (inline) return { body: inline };
+  throw new Error("requires --body-file PATH or --body TEXT");
+}
+async function runPlanPersist(args) {
+  const operationRaw = required(args.operation ? String(args.operation) : void 0, "operation");
+  if (!OPERATIONS.includes(operationRaw)) {
+    throw new Error(`invalid --operation ${operationRaw}`);
+  }
+  const operation = operationRaw;
+  const cfg = loadUserConfig();
+  const agentOsSlug = required(
+    args.slug ? String(args.slug) : cfg.agentOsSlug,
+    "slug (or agentOsSlug in ~/.kynver/config.json)"
+  );
+  const title = required(args.title ? String(args.title) : void 0, "title");
+  const { body, bodyPathHint } = readBodyArg(args);
+  if (bodyPathHint && isTmpOnlyPath(bodyPathHint)) {
+    console.warn(
+      JSON.stringify({
+        warning: "/tmp-only body path is not durable; AgentOS persistence requires outbox or successful API write",
+        bodyPathHint
+      })
+    );
+  }
+  const input = {
+    operation,
+    agentOsSlug,
+    title,
+    body,
+    bodyPathHint,
+    summary: args.summary ? String(args.summary) : void 0,
+    planId: args.plan ? String(args.plan) : void 0,
+    planSlug: args.planSlug ? String(args.planSlug) : void 0,
+    changeSummary: args.changeSummary ? String(args.changeSummary) : void 0,
+    author: args.author ? String(args.author) : void 0,
+    model: args.model ? String(args.model) : void 0,
+    maxRetries: args.maxRetries ? Number(args.maxRetries) : void 0,
+    immediateFailure: parseImmediateFailure(args)
+  };
+  const result = await persistPlan(input);
+  console.log(JSON.stringify(result, null, 2));
+  if (result.userStatus === "failed and needs action") process.exit(1);
+}
+function parseImmediateFailure(args) {
+  const kind = args.failureKind ? String(args.failureKind) : void 0;
+  if (!kind) return void 0;
+  if (!FAILURE_KINDS.includes(kind)) {
+    throw new Error(`invalid --failure-kind ${kind}`);
+  }
+  const message = args.failureMessage ? String(args.failureMessage) : `immediate failure (${kind})`;
+  return { kind, message };
+}
+async function runPlanOutboxList() {
+  const items = listOutboxItems();
+  console.log(JSON.stringify({ count: items.length, items }, null, 2));
+}
+async function runPlanOutboxDrain(args) {
+  const max = args.max ? Number(args.max) : void 0;
+  const outboxId = args.id ? String(args.id) : void 0;
+  const result = await drainPlanOutbox({ max, outboxId });
+  console.log(JSON.stringify(result, null, 2));
+  if (result.failed > 0) process.exit(1);
+}
+
 // src/cleanup-cli.ts
 function runCleanupCli(args) {
   const execute = args.execute === true || args.execute === "true";
@@ -4173,6 +5131,555 @@ function runCleanupCli(args) {
   }
 }
 
+// src/monitor/monitor.service.ts
+import path30 from "node:path";
+
+// src/monitor/monitor.classify.ts
+function expectedLeaseOwner(runId) {
+  return `kynver-harness:${runId}`;
+}
+function classifyWorkerHealth(input) {
+  const { worker, status, taskLease } = input;
+  const leaseOwner = taskLease?.leaseOwner ?? null;
+  const expectedOwner = expectedLeaseOwner(worker.runId);
+  if (worker.dispatched && taskLease) {
+    if (taskLease.status === "running" && leaseOwner && leaseOwner !== expectedOwner) {
+      return {
+        health: "orphaned",
+        reason: `task lease held by ${leaseOwner}, expected ${expectedOwner}`
+      };
+    }
+    if (taskLease.status === "running" && !status.alive && !status.finalResult) {
+      return {
+        health: "orphaned",
+        reason: "board task running but worker process is not alive"
+      };
+    }
+  }
+  if (worker.status === "running" && !status.alive && !status.finalResult) {
+    return {
+      health: "orphaned",
+      reason: "worker.json still running but process is dead"
+    };
+  }
+  if (status.attention.state === "stale") {
+    return { health: "stale", reason: status.attention.reason };
+  }
+  const hbMs = status.lastHeartbeatAt ? Date.parse(status.lastHeartbeatAt) : NaN;
+  if (status.alive && Number.isFinite(hbMs) && Date.now() - hbMs > STALE_MS) {
+    return {
+      health: "stale",
+      reason: `heartbeat older than ${Math.floor(STALE_MS / 1e3)}s`
+    };
+  }
+  if (status.alive && worker.pid && !isPidAlive(worker.pid)) {
+    return { health: "orphaned", reason: "pid recorded but process is not alive" };
+  }
+  if (taskLease?.status === "running" && !status.alive && status.finalResult) {
+    return {
+      health: "healthy",
+      reason: "finished worker awaiting completion replay"
+    };
+  }
+  return {
+    health: "healthy",
+    reason: status.attention.reason || "worker within expected lifecycle bounds"
+  };
+}
+
+// src/monitor/monitor.store.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync6, readdirSync as readdirSync7, unlinkSync as unlinkSync2 } from "node:fs";
+import path29 from "node:path";
+function monitorsDir() {
+  const { harnessRoot } = getHarnessPaths();
+  const dir = path29.join(harnessRoot, "monitors");
+  mkdirSync6(dir, { recursive: true });
+  return dir;
+}
+function monitorIdFor(runId, workerName) {
+  return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
+}
+function monitorPath(monitorId) {
+  return path29.join(monitorsDir(), `${monitorId}.json`);
+}
+function loadMonitorSession(monitorId) {
+  return readJson(monitorPath(monitorId), void 0);
+}
+function saveMonitorSession(session) {
+  writeJson(monitorPath(session.monitorId), session);
+}
+function deleteMonitorSession(monitorId) {
+  const file = monitorPath(monitorId);
+  if (!existsSync17(file)) return false;
+  unlinkSync2(file);
+  return true;
+}
+function listMonitorSessions() {
+  const dir = monitorsDir();
+  if (!existsSync17(dir)) return [];
+  const entries = [];
+  for (const name of readdirSync7(dir)) {
+    if (!name.endsWith(".json")) continue;
+    const session = readJson(
+      path29.join(dir, name),
+      void 0
+    );
+    if (!session?.monitorId) continue;
+    entries.push({
+      monitorId: session.monitorId,
+      runId: session.runId,
+      workerName: session.workerName,
+      agentOsId: session.agentOsId,
+      pid: session.pid,
+      alive: session.pid ? isPidAlive(session.pid) : false,
+      startedAt: session.startedAt,
+      pollMs: session.pollMs,
+      logPath: session.logPath
+    });
+  }
+  return entries.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+}
+
+// src/monitor/monitor.terminal.ts
+function assessAutoCompleteEligibility(input) {
+  const { worker, status } = input;
+  const blockers = [];
+  if (worker.localOnly) {
+    blockers.push("local-only worker (no board linkage)");
+  }
+  if (!worker.agentOsId || !worker.taskId) {
+    blockers.push("missing agentOsId/taskId linkage");
+  }
+  if (hasCompletionAck(worker)) {
+    blockers.push("completion already acknowledged");
+  }
+  if (worker.completionBlocker) {
+    blockers.push(worker.completionBlocker);
+  }
+  if (status.heartbeatBlocker && status.alive) {
+    blockers.push(`worker heartbeat blocker: ${status.heartbeatBlocker}`);
+  }
+  if (status.attention.state === "blocked") {
+    blockers.push(status.attention.reason || "worker attention blocked");
+  }
+  if (isLandingBlockedWorkerStatus(status)) {
+    blockers.push(status.attention.reason || "landing gate blocked");
+  }
+  const terminalVerified = isFinishedWorkerStatus(status);
+  let terminalReason;
+  if (terminalVerified) {
+    if (status.finalResult) terminalReason = "final_result";
+    else if (!status.alive) terminalReason = "process_exited";
+    else terminalReason = "terminal_status";
+  } else {
+    blockers.push("worker has not reached a terminal condition");
+  }
+  const eligible = terminalVerified && blockers.length === 0;
+  return {
+    eligible,
+    terminalVerified,
+    terminalReason,
+    blockers
+  };
+}
+
+// src/monitor/monitor.task-lease.ts
+async function fetchTaskLeasesForWorkers(input) {
+  const out = /* @__PURE__ */ new Map();
+  const agentOsId = input.agentOsId?.trim();
+  if (!agentOsId || input.taskIds.length === 0) return out;
+  const base = resolveBaseUrl(input.baseUrl);
+  try {
+    const secret = await resolveCallbackSecretWithMint(input.secret, agentOsId, { baseUrl: base });
+    const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/harness/monitor/task-leases`;
+    const res = await postJsonWithCredentialRefresh(
+      url,
+      secret,
+      { taskIds: [...new Set(input.taskIds)] },
+      { agentOsId, baseUrl: base }
+    );
+    if (!res.ok || !res.response || typeof res.response !== "object") return out;
+    const rows = res.response.tasks;
+    if (!Array.isArray(rows)) return out;
+    for (const row of rows) {
+      if (row?.taskId) out.set(row.taskId, row);
+    }
+  } catch {
+  }
+  return out;
+}
+
+// src/monitor/monitor.service.ts
+function workerRecord2(runId, name) {
+  return readJson(
+    path30.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    void 0
+  );
+}
+function workerNamesForRun(runId, scope) {
+  const run = loadRun(runId);
+  const names = Object.keys(run.workers || {});
+  if (!scope) return names;
+  const wanted = safeSlug(scope);
+  return names.filter((n) => safeSlug(n) === wanted);
+}
+function buildWorkerView(worker, taskLeases) {
+  const run = loadRun(worker.runId);
+  const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
+  const taskLease = worker.taskId ? taskLeases.get(worker.taskId) ?? null : null;
+  const health = classifyWorkerHealth({ worker, status, taskLease });
+  const autoComplete = assessAutoCompleteEligibility({ worker, status });
+  return {
+    runId: worker.runId,
+    worker: worker.name,
+    health: health.health,
+    healthReason: health.reason,
+    workerStatus: status.status,
+    attentionState: status.attention.state,
+    attentionReason: status.attention.reason,
+    alive: status.alive,
+    taskId: worker.taskId,
+    leaseOwner: taskLease?.leaseOwner ?? void 0,
+    taskStatus: taskLease?.status,
+    autoComplete,
+    status
+  };
+}
+async function runMonitorTick(args) {
+  const runId = String(args.run || "");
+  required(runId, "--run");
+  const scope = args.name ? String(args.name) : void 0;
+  const agentOsId = args.agentOsId ? String(args.agentOsId) : void 0;
+  const run = loadRun(runId);
+  const names = workerNamesForRun(runId, scope);
+  const workers = [];
+  for (const name of names) {
+    const worker = workerRecord2(runId, name);
+    if (worker) workers.push(worker);
+  }
+  const resolvedAgentOsId = agentOsId || workers.map((w) => w.agentOsId).find((id) => typeof id === "string" && id.trim()) || void 0;
+  const taskIds = workers.map((w) => w.taskId).filter((id) => Boolean(id));
+  const taskLeases = await fetchTaskLeasesForWorkers({
+    agentOsId: resolvedAgentOsId,
+    taskIds,
+    baseUrl: args.baseUrl ? String(args.baseUrl) : void 0,
+    secret: args.secret ? String(args.secret) : void 0
+  });
+  const views = workers.map((w) => buildWorkerView(w, taskLeases));
+  let leaseRenewal;
+  if (resolvedAgentOsId && args.renewLeases !== false && args.renewLeases !== "false") {
+    leaseRenewal = await renewActiveTaskLeases(runId, {
+      ...args,
+      agentOsId: resolvedAgentOsId
+    });
+  }
+  const autoCompleted = [];
+  const shouldAutoComplete = args.autoComplete === true || args.autoComplete === "true";
+  if (shouldAutoComplete) {
+    for (const view of views) {
+      if (!view.autoComplete.eligible) {
+        autoCompleted.push({
+          worker: view.worker,
+          outcome: "skipped",
+          ok: false,
+          reason: view.autoComplete.blockers.join("; ") || "not eligible"
+        });
+        continue;
+      }
+      const outcome = await autoCompleteWorker({
+        run: runId,
+        name: view.worker,
+        ...resolvedAgentOsId ? { agentOsId: resolvedAgentOsId } : {},
+        ...args.baseUrl ? { baseUrl: String(args.baseUrl) } : {},
+        ...args.secret ? { secret: String(args.secret) } : {}
+      });
+      autoCompleted.push({
+        worker: view.worker,
+        outcome: outcome.outcome,
+        ok: outcome.outcome === "completed",
+        reason: outcome.reason
+      });
+    }
+  }
+  return {
+    runId,
+    agentOsId: resolvedAgentOsId,
+    workers: views,
+    leaseRenewal,
+    autoCompleted
+  };
+}
+function getMonitorStatus(args) {
+  const runId = String(args.run || "");
+  required(runId, "--run");
+  const scope = args.name ? String(args.name) : void 0;
+  const names = workerNamesForRun(runId, scope);
+  const workers = [];
+  for (const name of names) {
+    const worker = workerRecord2(runId, name);
+    if (!worker) continue;
+    workers.push(buildWorkerView(worker, /* @__PURE__ */ new Map()));
+  }
+  return { runId, workers, autoCompleted: [] };
+}
+function listMonitors() {
+  return listMonitorSessions();
+}
+function stopMonitor(args) {
+  const runId = String(args.run || "");
+  required(runId, "--run");
+  const monitorId = monitorIdFor(runId, args.name ? String(args.name) : void 0);
+  const session = loadMonitorSession(monitorId);
+  if (!session) {
+    return { monitorId, stopped: false };
+  }
+  if (session.pid && isPidAlive(session.pid)) {
+    try {
+      process.kill(session.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  session.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveMonitorSession(session);
+  deleteMonitorSession(monitorId);
+  return { monitorId, stopped: true, pid: session.pid };
+}
+async function monitorAutoCompleteCli(args) {
+  const runId = String(args.run || "");
+  const name = String(args.name || "");
+  required(runId, "--run");
+  required(name, "--name");
+  const worker = loadWorker(runId, name);
+  const run = loadRun(runId);
+  const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
+  const assessment = assessAutoCompleteEligibility({ worker, status });
+  if (!assessment.eligible) {
+    console.log(
+      JSON.stringify(
+        {
+          runId,
+          worker: name,
+          outcome: "blocked",
+          blockers: assessment.blockers,
+          terminalVerified: assessment.terminalVerified
+        },
+        null,
+        2
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const outcome = await autoCompleteWorker({
+    ...args,
+    run: runId,
+    name
+  });
+  console.log(JSON.stringify(outcome, null, 2));
+  if (outcome.outcome !== "completed" && outcome.outcome !== "blocked") {
+    process.exitCode = 1;
+  }
+}
+
+// src/monitor/monitor-loop.ts
+var DEFAULT_POLL_MS2 = 5e3;
+var DEFAULT_MAX_TOTAL_MS2 = 6 * 60 * 60 * 1e3;
+async function runMonitorLoop(args) {
+  const monitorId = String(args.monitorId || "");
+  const pollMs = Number(args.pollMs) > 0 ? Math.floor(Number(args.pollMs)) : DEFAULT_POLL_MS2;
+  const maxTotalMs = Number(args.maxTotalMs) > 0 ? Math.floor(Number(args.maxTotalMs)) : DEFAULT_MAX_TOTAL_MS2;
+  const startMs = Date.now();
+  while (Date.now() - startMs <= maxTotalMs) {
+    const session = monitorId ? loadMonitorSession(monitorId) : void 0;
+    if (session?.stoppedAt) break;
+    const tick = await runMonitorTick({
+      ...args,
+      autoComplete: args.autoComplete ?? true,
+      renewLeases: args.renewLeases ?? true
+    });
+    console.log(JSON.stringify({ monitorId, phase: "tick", ...tick }));
+    const allTerminal = tick.workers.length > 0 && tick.workers.every(
+      (w) => w.autoComplete.terminalVerified && (w.autoComplete.eligible || w.autoComplete.blockers.some((b) => b.includes("already acknowledged")))
+    );
+    if (allTerminal && tick.autoCompleted.every((a) => a.ok || a.outcome === "skipped")) {
+      if (monitorId && session) {
+        session.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+        saveMonitorSession(session);
+      }
+      break;
+    }
+    sleepMs(pollMs);
+  }
+}
+
+// src/monitor/monitor-spawn.ts
+import { spawn as spawn4 } from "node:child_process";
+import { closeSync as closeSync4, existsSync as existsSync18, openSync as openSync4 } from "node:fs";
+import path31 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function resolveDefaultCliPath2() {
+  return path31.join(fileURLToPath2(new URL(".", import.meta.url)), "..", "cli.js");
+}
+function spawnMonitorSidecar(opts) {
+  const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
+  if (!existsSync18(cliPath)) return void 0;
+  const monitorId = monitorIdFor(opts.runId, opts.workerName);
+  const { harnessRoot } = getHarnessPaths();
+  const logPath = path31.join(harnessRoot, "monitors", `${monitorId}.log`);
+  let logFd;
+  try {
+    logFd = openSync4(logPath, "a");
+  } catch {
+    logFd = void 0;
+  }
+  const nodeExecutable = opts.nodeExecutable ?? process.execPath;
+  const pollMs = opts.pollMs ?? 5e3;
+  const args = [
+    cliPath,
+    "monitor",
+    "run-loop",
+    "--run",
+    opts.runId,
+    "--monitor-id",
+    monitorId,
+    "--poll-ms",
+    String(pollMs),
+    "--auto-complete",
+    "true",
+    "--renew-leases",
+    "true"
+  ];
+  if (opts.workerName) args.push("--name", opts.workerName);
+  if (opts.agentOsId) args.push("--agent-os-id", opts.agentOsId);
+  if (opts.baseUrl) args.push("--base-url", opts.baseUrl);
+  if (opts.secret) args.push("--secret", opts.secret);
+  const stdio = [
+    "ignore",
+    logFd ?? "ignore",
+    logFd ?? "ignore"
+  ];
+  try {
+    const child = spawn4(
+      nodeExecutable,
+      args,
+      hiddenSpawnOptions({
+        detached: true,
+        stdio,
+        env: process.env
+      })
+    );
+    if (logFd !== void 0) closeSync4(logFd);
+    child.unref();
+    const session = {
+      monitorId,
+      runId: opts.runId,
+      workerName: opts.workerName,
+      agentOsId: opts.agentOsId,
+      pid: child.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pollMs,
+      logPath
+    };
+    saveMonitorSession(session);
+    return { monitorId, pid: child.pid, logPath, session };
+  } catch {
+    if (logFd !== void 0) {
+      try {
+        closeSync4(logFd);
+      } catch {
+      }
+    }
+    return void 0;
+  }
+}
+
+// src/monitor/monitor-cli.ts
+async function startMonitorCli(args) {
+  const runId = String(args.run || "");
+  required(runId, "--run");
+  const workerName = args.name ? String(args.name) : void 0;
+  const monitorId = monitorIdFor(runId, workerName);
+  const existing = loadMonitorSession(monitorId);
+  if (existing?.pid && !existing.stoppedAt) {
+    return { monitorId, session: existing, spawned: false, pid: existing.pid };
+  }
+  const spawned = spawnMonitorSidecar({
+    runId,
+    workerName,
+    agentOsId: args.agentOsId ? String(args.agentOsId) : void 0,
+    pollMs: Number(args.pollMs) > 0 ? Math.floor(Number(args.pollMs)) : void 0,
+    baseUrl: args.baseUrl ? String(args.baseUrl) : void 0,
+    secret: args.secret ? String(args.secret) : void 0
+  });
+  if (!spawned) {
+    throw new Error("failed to spawn monitor sidecar (cli.js missing or spawn error)");
+  }
+  return {
+    monitorId,
+    session: spawned.session,
+    spawned: true,
+    pid: spawned.pid
+  };
+}
+async function monitorStatusCli(args) {
+  const runId = String(args.run || "");
+  if (runId) {
+    const tick = args.tick === true || args.tick === "true" ? await runMonitorTick({ ...args, autoComplete: false }) : getMonitorStatus(args);
+    console.log(JSON.stringify(tick, null, 2));
+    return;
+  }
+  console.log(JSON.stringify({ monitors: listMonitors() }, null, 2));
+}
+function monitorStopCli(args) {
+  console.log(JSON.stringify(stopMonitor(args), null, 2));
+}
+function monitorListCli() {
+  console.log(JSON.stringify({ monitors: listMonitors() }, null, 2));
+}
+async function monitorRunLoopCli(args) {
+  await runMonitorLoop(args);
+}
+async function monitorTickCli(args) {
+  const tick = await runMonitorTick(args);
+  console.log(JSON.stringify(tick, null, 2));
+}
+
+// src/package-version.ts
+import { existsSync as existsSync19, readFileSync as readFileSync8 } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function resolvePackageRoot(moduleUrl) {
+  let dir = dirname(fileURLToPath3(moduleUrl));
+  for (let depth = 0; depth < 6; depth += 1) {
+    if (existsSync19(join(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(`package.json not found above ${dirname(fileURLToPath3(moduleUrl))}`);
+}
+function readOwnPackageVersion(moduleUrl = import.meta.url) {
+  const pkgPath = join(resolvePackageRoot(moduleUrl), "package.json");
+  const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
+  if (typeof pkg.version !== "string" || !pkg.version.trim()) {
+    throw new Error(`Missing package.json version at ${pkgPath}`);
+  }
+  return pkg.version;
+}
+var PACKAGE_VERSION = readOwnPackageVersion();
+function wantsCliVersion(argv) {
+  return argv.some((arg) => arg === "--version" || arg === "-v");
+}
+function printCliVersionAndExit(version, binName) {
+  console.log(binName ? `${binName} ${version}` : version);
+  process.exit(0);
+}
+function handleCliVersionFlag(argv, moduleUrl = import.meta.url, binName) {
+  if (!wantsCliVersion(argv)) return false;
+  printCliVersionAndExit(readOwnPackageVersion(moduleUrl), binName);
+  return true;
+}
+
 // src/cli.ts
 function isHelpFlag(arg) {
   return arg === "help" || arg === "--help" || arg === "-h";
@@ -4204,17 +5711,28 @@ function usage(code = 0) {
       "  kynver worker auto-complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--poll-ms 5000] [--max-total-ms 21600000] [--complete-attempts 3] [--complete-backoff-ms 5000] [--base-url URL] [--secret SECRET]",
       "  kynver plan progress --plan PLAN_ID --row ROW_KEY --role ROLE --status STATUS [--task TASK_ID] [--note NOTE] [--evidence type:value] [--agent-os-id AOS_ID]",
       "  kynver plan verify --plan PLAN_ID [--worktree PATH] [--task TASK_ID] [--human-override]",
-      "  kynver cleanup [--execute] [--node-modules-age-ms MS] [--worktrees-age-ms MS] [--harness-root PATH] [--include-orphans]"
+      "  kynver plan persist --operation create|add_version|update_metadata --title TITLE (--body-file PATH | --body TEXT) [--slug SLUG] [--plan PLAN_ID] [--summary TEXT] [--failure-kind approval_guard|auth|network|server|tool_interruption]",
+      "  kynver plan outbox list",
+      "  kynver plan outbox drain [--max N] [--id OUTBOX_ID]",
+      "  kynver cleanup [--execute] [--node-modules-age-ms MS] [--worktrees-age-ms MS] [--harness-root PATH] [--include-orphans]",
+      "  kynver monitor start --run RUN_ID [--name worker] [--agent-os-id AOS_ID] [--poll-ms MS]",
+      "  kynver monitor status [--run RUN_ID] [--name worker] [--tick]",
+      "  kynver monitor stop --run RUN_ID [--name worker]",
+      "  kynver monitor list",
+      "  kynver monitor tick --run RUN_ID [--name worker] [--agent-os-id AOS_ID] [--auto-complete] [--renew-leases]",
+      "  kynver monitor auto-complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--base-url URL] [--secret SECRET]",
+      "  kynver monitor run-loop --run RUN_ID --monitor-id ID [--name worker] [--agent-os-id AOS_ID] [--poll-ms MS] [--auto-complete] [--renew-leases]"
     ].join("\n")
   );
   process.exit(code);
 }
 async function main(argv = process.argv.slice(2)) {
+  if (handleCliVersionFlag(argv, import.meta.url, "kynver")) return;
   if (argv.length === 0 || isHelpFlag(argv[0])) return usage(0);
   const scope = argv.shift();
   let action;
   let rest;
-  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner") {
+  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner" || scope === "monitor") {
     action = argv.shift();
     rest = argv;
   } else {
@@ -4223,14 +5741,21 @@ async function main(argv = process.argv.slice(2)) {
   if (action && isHelpFlag(action) || rest.some(isHelpFlag)) return usage(0);
   const args = parseArgs(rest);
   const { runsDir, worktreesDir } = getPaths();
-  mkdirSync5(runsDir, { recursive: true });
-  mkdirSync5(worktreesDir, { recursive: true });
+  mkdirSync7(runsDir, { recursive: true });
+  mkdirSync7(worktreesDir, { recursive: true });
   if (scope === "login") return void await runLogin(args);
   if (scope === "runner" && action === "credential") return void await mintRunnerCredential(args);
   if (scope === "setup") return void await runSetup(args);
   if (scope === "daemon") return void await runDaemon(args);
   if (scope === "plan" && action === "progress") return void await emitPlanProgress(args);
   if (scope === "plan" && action === "verify") return void await verifyPlan(args);
+  if (scope === "plan" && action === "persist") return void await runPlanPersist(args);
+  if (scope === "plan" && action === "outbox") {
+    const outboxAction = rest.shift();
+    if (outboxAction === "list") return void await runPlanOutboxList();
+    if (outboxAction === "drain") return void await runPlanOutboxDrain(parseArgs(rest));
+    unknownCommand("plan", `outbox ${outboxAction ?? ""}`.trim());
+  }
   if (scope === "cleanup") return runCleanupCli(args);
   if (scope === "run" && action === "create") return createRun(args);
   if (scope === "run" && action === "list") return listRuns();
@@ -4243,9 +5768,20 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "worker" && action === "stop") return stopWorker(args);
   if (scope === "worker" && action === "complete") return void await completeWorker(args);
   if (scope === "worker" && action === "auto-complete") return void await autoCompleteWorkerCli(args);
+  if (scope === "monitor" && action === "start") {
+    const result = await startMonitorCli(args);
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (scope === "monitor" && action === "status") return void await monitorStatusCli(args);
+  if (scope === "monitor" && action === "stop") return monitorStopCli(args);
+  if (scope === "monitor" && action === "list") return monitorListCli();
+  if (scope === "monitor" && action === "tick") return void await monitorTickCli(args);
+  if (scope === "monitor" && action === "auto-complete") return void await monitorAutoCompleteCli(args);
+  if (scope === "monitor" && action === "run-loop") return void await monitorRunLoopCli(args);
   unknownCommand(scope, action);
 }
-var isCliEntry = process.argv[1] && realpathSync.native(process.argv[1]) === realpathSync.native(fileURLToPath2(import.meta.url));
+var isCliEntry = process.argv[1] && realpathSync.native(process.argv[1]) === realpathSync.native(fileURLToPath4(import.meta.url));
 if (isCliEntry) {
   void main().catch((error) => {
     console.error(error);