@kynver-app/runtime 0.1.51 → 0.1.59

package/dist/index.js

@@ -169,12 +169,14 @@ var FORBIDDEN_WORKER_ENV_KEYS = [
   "NEXTAUTH_SECRET",
   "DATABASE_URL",
   "PRODUCTION_DATABASE_URL",
+  "KYNVER_PRODUCTION_DATABASE_URL",
   "REDIS_URL",
   "GOOGLE_CLIENT_SECRET",
   "GITHUB_CLIENT_SECRET",
   "KYNVER_API_KEY",
   "KYNVER_SERVICE_SECRET",
   "KYNVER_RUNTIME_SECRET",
+  "KYNVER_CRON_SECRET",
   "OPENCLAW_CRON_SECRET",
   "QSTASH_TOKEN",
   "QSTASH_CURRENT_SIGNING_KEY",
@@ -455,7 +457,7 @@ function presentUserConfig(config) {
 }
 function inferSetupFields(existing, args) {
   const creds = loadCredentialsFile();
-  const apiBaseUrl = (typeof args.apiBaseUrl === "string" ? args.apiBaseUrl : void 0) || existing.apiBaseUrl?.trim() || process.env.KYNVER_API_URL?.trim() || process.env.OPENCLAW_CRON_FIRE_BASE_URL?.trim();
+  const apiBaseUrl = (typeof args.apiBaseUrl === "string" ? args.apiBaseUrl : void 0) || existing.apiBaseUrl?.trim() || process.env.KYNVER_API_URL?.trim() || process.env.KYNVER_CRON_FIRE_BASE_URL?.trim() || process.env.OPENCLAW_CRON_FIRE_BASE_URL?.trim();
   const agentOsId = (typeof args.agentOsId === "string" ? args.agentOsId : void 0) || existing.agentOsId?.trim() || process.env.KYNVER_AGENT_OS_ID?.trim() || (creds.runnerToken?.trim().startsWith("krc1.") ? creds.runnerTokenAgentOsId?.trim() : void 0);
   const explicitRepo = typeof args.repo === "string" ? args.repo : args.discoverRepo === true || args.discoverRepo === "true" ? discoverDefaultRepo()?.repo : void 0;
   const defaultRepo = explicitRepo || existing.defaultRepo?.trim() || process.env.KYNVER_DEFAULT_REPO?.trim() || process.env.KYNVER_HARNESS_REPO?.trim() || discoverDefaultRepo()?.repo;
@@ -507,17 +509,17 @@ function saveRunnerToken(agentOsId, token) {
 }
 function resolveBaseUrl(argsBaseUrl) {
   const baseUrl = resolveConfiguredBaseUrl(argsBaseUrl);
-  if (!baseUrl) failConfig("requires --base-url, KYNVER_API_URL, OPENCLAW_CRON_FIRE_BASE_URL, or ~/.kynver/config.json apiBaseUrl");
+  if (!baseUrl) failConfig("requires --base-url, KYNVER_API_URL, KYNVER_CRON_FIRE_BASE_URL, or ~/.kynver/config.json apiBaseUrl");
   return baseUrl;
 }
 function resolveConfiguredBaseUrl(argsBaseUrl) {
-  const baseUrl = argsBaseUrl || process.env.KYNVER_API_URL || process.env.OPENCLAW_CRON_FIRE_BASE_URL || loadUserConfig().apiBaseUrl;
+  const baseUrl = argsBaseUrl || process.env.KYNVER_API_URL || process.env.KYNVER_CRON_FIRE_BASE_URL || process.env.OPENCLAW_CRON_FIRE_BASE_URL || loadUserConfig().apiBaseUrl;
   return baseUrl ? trimTrailingSlash(String(baseUrl)) : void 0;
 }
 function resolveConfiguredCallbackSecret(argsSecret, agentOsId) {
   const scoped = argsSecret || loadRunnerToken(agentOsId) || (agentOsId ? void 0 : loadRunnerToken(loadUserConfig().agentOsId));
   if (scoped) return String(scoped);
-  const globalSecret = process.env.KYNVER_RUNTIME_SECRET || process.env.OPENCLAW_CRON_SECRET;
+  const globalSecret = process.env.KYNVER_RUNTIME_SECRET || process.env.KYNVER_CRON_SECRET || process.env.OPENCLAW_CRON_SECRET;
   if (globalSecret) {
     console.warn(
       "[kynver] using deployment-level callback secret; run `kynver runner credential --agent-os-id <id>` for a scoped token"
@@ -530,7 +532,7 @@ function resolveCallbackSecret(argsSecret, agentOsId) {
   const configured = resolveConfiguredCallbackSecret(argsSecret, agentOsId);
   if (configured) return configured;
   failConfig(
-    "requires --secret, KYNVER_RUNNER_TOKEN, a scoped runner token (`kynver runner credential`), ~/.kynver/credentials runnerToken, KYNVER_API_KEY with an API base URL to mint one, or (legacy) KYNVER_RUNTIME_SECRET / OPENCLAW_CRON_SECRET"
+    "requires --secret, KYNVER_RUNNER_TOKEN, a scoped runner token (`kynver runner credential`), ~/.kynver/credentials runnerToken, KYNVER_API_KEY with an API base URL to mint one, or (legacy) KYNVER_RUNTIME_SECRET / KYNVER_CRON_SECRET / OPENCLAW_CRON_SECRET"
   );
 }
 async function resolveCallbackSecretWithMint(argsSecret, agentOsId, opts) {
@@ -548,7 +550,7 @@ async function resolveCallbackSecretWithMint(argsSecret, agentOsId, opts) {
     }
   }
   failConfig(
-    "requires --secret, KYNVER_RUNNER_TOKEN, a scoped runner token (`kynver runner credential`), ~/.kynver/credentials runnerToken, KYNVER_API_KEY with an API base URL to mint one, or (legacy) KYNVER_RUNTIME_SECRET / OPENCLAW_CRON_SECRET"
+    "requires --secret, KYNVER_RUNNER_TOKEN, a scoped runner token (`kynver runner credential`), ~/.kynver/credentials runnerToken, KYNVER_API_KEY with an API base URL to mint one, or (legacy) KYNVER_RUNTIME_SECRET / KYNVER_CRON_SECRET / OPENCLAW_CRON_SECRET"
   );
 }
 async function refreshRunnerToken(agentOsId, opts) {
@@ -708,6 +710,11 @@ function buildHarnessCallbackHeaders(secret) {
   }
   return {
     "Content-Type": "application/json",
+    // Canonical header. We keep sending the legacy `X-OpenClaw-Cron-Secret`
+    // (and `X-Kynver-Runtime-Secret`) so an un-upgraded Kynver server that
+    // only reads the old header still authenticates this runner during the
+    // rename compat window.
+    "X-Kynver-Cron-Secret": trimmed,
     "X-OpenClaw-Cron-Secret": trimmed,
     "X-Kynver-Runtime-Secret": trimmed
   };
@@ -751,18 +758,88 @@ async function getJson(url, secret) {
 }
 
 // src/disk-gate.ts
-import { statfsSync } from "node:fs";
+import { statfsSync as statfsSync2 } from "node:fs";
+
+// src/wsl-host.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, statfsSync } from "node:fs";
+var DEFAULT_WSL_HOST_WARN_FREE_BYTES = 25 * 1024 * 1024 * 1024;
+var DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES = 12 * 1024 * 1024 * 1024;
+var DEFAULT_WSL_HOST_MOUNT = "/mnt/c";
+function isWslHost() {
+  if (process.platform !== "linux") return false;
+  for (const probe of ["/proc/sys/kernel/osrelease", "/proc/version"]) {
+    try {
+      if (!existsSync5(probe)) continue;
+      const text = readFileSync5(probe, "utf8");
+      if (/microsoft|wsl/i.test(text)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function observeWslHostDisk(options = {}) {
+  const wsl = options.forceWsl === void 0 ? isWslHost() : options.forceWsl;
+  if (!wsl) return null;
+  const path44 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
+  const warnBelowBytes = options.wslHostFreeWarnBytes ?? DEFAULT_WSL_HOST_WARN_FREE_BYTES;
+  const criticalBelowBytes = options.wslHostFreeCriticalBytes ?? DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES;
+  const statfs = options.statfs ?? statfsSync;
+  let stats;
+  try {
+    stats = statfs(path44);
+  } catch (error) {
+    return {
+      ok: false,
+      path: path44,
+      freeBytes: 0,
+      totalBytes: 0,
+      usedPercent: 100,
+      warnBelowBytes,
+      criticalBelowBytes,
+      reason: `Windows host disk probe failed at ${path44}: ${error.message}`,
+      probeError: error.message
+    };
+  }
+  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;
+  const lowFree = freeBytes < warnBelowBytes;
+  const criticalFree = freeBytes < criticalBelowBytes;
+  const ok = !lowFree && !criticalFree;
+  const freeGiB = (freeBytes / (1024 * 1024 * 1024)).toFixed(1);
+  let reason = null;
+  if (!ok) {
+    const tag = criticalFree ? "critical" : "warning";
+    reason = `Windows host disk ${path44} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+  }
+  return {
+    ok,
+    path: path44,
+    freeBytes,
+    totalBytes,
+    usedPercent,
+    warnBelowBytes,
+    criticalBelowBytes,
+    reason,
+    probeError: null
+  };
+}
+function summarizeWslRecoverySteps() {
+  return "Recovery: 1) free Windows C: (empty Recycle Bin / Storage Sense / clear %TEMP%); 2) shut down WSL (`wsl --shutdown`) then compact the VHDX (`Optimize-VHD` or `diskpart compact vdisk`); 3) clear local node_modules / .next / harness worktrees before restarting workers. Full runbook: docs/runbooks/wsl-disk-pressure.md.";
+}
+
+// src/disk-gate.ts
 var DEFAULT_WARN_FREE_BYTES = 30 * 1024 * 1024 * 1024;
 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 path40 = input.diskPath?.trim() || "/";
+  const path44 = 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(path40);
+  const stats = statfsSync2(path44);
   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;
@@ -770,19 +847,22 @@ function observeRunnerDiskGate(input = {}) {
   const criticalFree = freeBytes < criticalBelowBytes;
   const highUse = usedPercent > maxUsedPercent;
   const hardHighUse = usedPercent > hardMaxUsedPercent;
-  const ok = !lowFree && !criticalFree && !highUse && !hardHighUse;
+  const localOk = !lowFree && !criticalFree && !highUse && !hardHighUse;
+  const wslHost = input.skipWslHostCheck ? null : observeWslHostDisk(input.wslHost);
+  const ok = localOk && (wslHost ? wslHost.ok : true);
   let reason = null;
   if (!ok) {
     reason = [
       criticalFree ? `free space below critical ${criticalBelowBytes} bytes` : null,
       lowFree ? `free space below warning ${warnBelowBytes} bytes` : null,
       hardHighUse ? `used percent above hard cap ${hardMaxUsedPercent}%` : null,
-      highUse ? `used percent above cap ${maxUsedPercent}%` : null
+      highUse ? `used percent above cap ${maxUsedPercent}%` : null,
+      wslHost && !wslHost.ok ? wslHost.reason : null
     ].filter(Boolean).join("; ");
   }
   return {
     ok,
-    path: path40,
+    path: path44,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -790,7 +870,8 @@ function observeRunnerDiskGate(input = {}) {
     criticalBelowBytes,
     maxUsedPercent,
     hardMaxUsedPercent,
-    reason
+    reason,
+    wslHost
   };
 }
 
@@ -798,7 +879,7 @@ function observeRunnerDiskGate(input = {}) {
 import os2 from "node:os";
 
 // src/bounded-build/meminfo.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 import os from "node:os";
 function readMemAvailableBytes(meminfoText) {
   if (meminfoText !== void 0) {
@@ -808,7 +889,7 @@ function readMemAvailableBytes(meminfoText) {
   }
   if (process.platform === "linux") {
     try {
-      const meminfo = readFileSync5("/proc/meminfo", "utf8");
+      const meminfo = readFileSync6("/proc/meminfo", "utf8");
       const match = meminfo.match(/^MemAvailable:\s+(\d+)\s*kB/m);
       if (match) return Number(match[1]) * 1024;
     } catch {
@@ -821,11 +902,11 @@ function readMemAvailableBytes(meminfoText) {
 import path7 from "node:path";
 
 // src/run-store.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync2 } from "node:fs";
 import path6 from "node:path";
 
 // src/paths.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import path5 from "node:path";
 var LEGACY_ROOT = path5.join(homedir4(), ".openclaw", "harness");
@@ -835,8 +916,8 @@ function resolveHarnessRoot() {
   const configured = loadUserConfig().harnessRoot?.trim();
   if (configured) return resolveUserPath(configured);
   const kynverRoot = path5.join(homedir4(), ".kynver", "harness");
-  if (existsSync5(kynverRoot)) return kynverRoot;
-  if (existsSync5(LEGACY_ROOT)) return LEGACY_ROOT;
+  if (existsSync6(kynverRoot)) return kynverRoot;
+  if (existsSync6(LEGACY_ROOT)) return LEGACY_ROOT;
   return kynverRoot;
 }
 function getHarnessPaths() {
@@ -861,7 +942,7 @@ function loadRun(id) {
 }
 function listRunRecords() {
   const { runsDir } = getPaths();
-  if (!existsSync6(runsDir)) return [];
+  if (!existsSync7(runsDir)) return [];
   const runs = [];
   for (const entry of readdirSync2(runsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
@@ -893,7 +974,7 @@ function runDirectory(id) {
 }
 
 // src/heartbeat.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
 var HEARTBEAT_FUTURE_SKEW_MS = 6e4;
 function isTerminalHeartbeatPhase(phase) {
   return phase === "complete";
@@ -912,10 +993,10 @@ function parseHeartbeat(file) {
     heartbeatBlocker: null,
     timestampAnomalies: []
   };
-  if (!existsSync7(file)) return result;
+  if (!existsSync8(file)) return result;
   const maxFutureMs = Date.now() + HEARTBEAT_FUTURE_SKEW_MS;
   const clampedTo = new Date(maxFutureMs).toISOString();
-  const lines = readFileSync6(file, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync7(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const entry = safeJson(line);
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
@@ -942,7 +1023,7 @@ function parseHeartbeat(file) {
 }
 
 // src/stream.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
 
 // src/shell-command-outcome.ts
 var NPM_AUDIT_RE = /\bnpm\s+audit\b/i;
@@ -1146,8 +1227,8 @@ function parseHarnessStream(file) {
     error: null,
     lastShellOutcome: null
   };
-  if (!existsSync8(file)) return result;
-  const lines = readFileSync7(file, "utf8").split("\n").filter(Boolean);
+  if (!existsSync9(file)) return result;
+  const lines = readFileSync8(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const event = safeJson(line);
     if (!event) continue;
@@ -2173,7 +2254,7 @@ function hasLiveWorkerForTask(runId, taskId) {
 }
 
 // src/supervisor.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync3 } from "node:fs";
 import path14 from "node:path";
 
 // src/prompt.ts
@@ -2194,7 +2275,7 @@ function buildPrompt(input) {
     input.planId ? `Active planId: ${input.planId}${input.taskId ? ` \xB7 taskId: ${input.taskId}` : ""}` : "No planId on this worker \u2014 still emit progress when you touch plan-scoped work."
   ];
   const mergeGateLines = compact ? [
-    "Merge-gate cost control: run `node scripts/verify-pr-local.mjs --emit-json` and `node scripts/collect-pr-vercel-evidence.mjs --pr <url> --emit-json` (trusts GitHub Vercel status for dashboard target_url; never passes dashboard URLs to `vercel inspect`) before any GitHub Actions run; request merge-gate only via POST pr-merge-gate/request-run (one Actions run per PR head unless human approves extra)."
+    "Merge-gate cost control: run `node scripts/agent-os-pr-merge-gate.mjs --pr <url> --agent-os-id <id>` (or `verify-pr-local.mjs --from-pr` + `collect-pr-vercel-evidence.mjs` + POST pr-merge-gate/refresh) before any GitHub Actions run; request merge-gate only via refresh then POST pr-merge-gate/request-run (one Actions run per PR head unless human approves extra)."
   ] : [
     "GitHub Actions merge-gate cost control (Kynver/Hermes PRs):",
     "- Prefer local cached package verification (`node scripts/verify-pr-local.mjs --emit-json`) and Vercel preview evidence before GitHub Actions.",
@@ -2221,7 +2302,7 @@ function buildPrompt(input) {
     "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.",
+    "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). One-off helper scripts must be removed (`kynver worker discard-disposable --path <file>`) or committed before completion \u2014 maintenance/board-drain workers are not exempt. 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.",
     "Expert review / production-review workers (Dalton/Lorentz, plan-review-task, scheduledJob reviewer children): do NOT open new implementation PRs \u2014 review the parent task's existing PR and record reviewVerdict in finalResult; landing-contract targetPrReconciliation does not apply.",
     "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.",
@@ -2243,12 +2324,12 @@ function buildPrompt(input) {
 }
 
 // src/providers/cursor.ts
-import { closeSync as closeSync2, existsSync as existsSync10, openSync as openSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync11, openSync as openSync2 } from "node:fs";
 import { spawn as spawn2 } from "node:child_process";
 import path10 from "node:path";
 
 // src/providers/cursor-windows.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync3 } from "node:fs";
 import path9 from "node:path";
 var CURSOR_VERSION_DIR = /^\d{4}\.\d{1,2}\.\d{1,2}-[a-f0-9]+$/i;
 function parseCursorVersionSortKey(versionName) {
@@ -2261,7 +2342,7 @@ function parseCursorVersionSortKey(versionName) {
 }
 function pickLatestCursorVersionDir(agentRoot) {
   const versionsRoot = path9.join(agentRoot, "versions");
-  if (!existsSync9(versionsRoot)) return null;
+  if (!existsSync10(versionsRoot)) return null;
   let bestDir = null;
   let bestKey = -1;
   for (const entry of readdirSync3(versionsRoot, { withFileTypes: true })) {
@@ -2277,14 +2358,14 @@ function resolveWindowsCursorBundled(agentRoot) {
   const root = agentRoot?.trim() || path9.join(process.env.LOCALAPPDATA || "", "cursor-agent");
   const directNode = path9.join(root, "node.exe");
   const directIndex = path9.join(root, "index.js");
-  if (existsSync9(directNode) && existsSync9(directIndex)) {
+  if (existsSync10(directNode) && existsSync10(directIndex)) {
     return { nodeExe: directNode, indexJs: directIndex, versionDir: root };
   }
   const versionDir = pickLatestCursorVersionDir(root);
   if (!versionDir) return null;
   const nodeExe = path9.join(versionDir, "node.exe");
   const indexJs = path9.join(versionDir, "index.js");
-  if (!existsSync9(nodeExe) || !existsSync9(indexJs)) return null;
+  if (!existsSync10(nodeExe) || !existsSync10(indexJs)) return null;
   return { nodeExe, indexJs, versionDir };
 }
 
@@ -2302,7 +2383,7 @@ function bundledSpawnTarget(nodeExe, indexJs, versionDir) {
 function resolveCursorSpawn(agentBin) {
   if (process.platform === "win32") {
     const isCursorWrapper = /\.(cmd|bat)$/i.test(agentBin);
-    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync10(path10.join(path10.dirname(agentBin), "index.js"));
+    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync11(path10.join(path10.dirname(agentBin), "index.js"));
     const isDefaultShim = agentBin === "agent";
     if (isCursorWrapper || isBundledNode || isDefaultShim) {
       const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path10.dirname(agentBin)) : isBundledNode ? {
@@ -2329,7 +2410,7 @@ function resolveAgentBin() {
     );
     if (bundled) return bundled.nodeExe;
     const localAgent = path10.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
-    if (existsSync10(localAgent)) return localAgent;
+    if (existsSync11(localAgent)) return localAgent;
   }
   return "agent";
 }
@@ -2412,7 +2493,7 @@ function resolveWorkerProvider(name) {
 
 // src/auto-complete.ts
 import { spawn as spawn3 } from "node:child_process";
-import { existsSync as existsSync11, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
+import { existsSync as existsSync12, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
 import path13 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
@@ -2911,6 +2992,133 @@ function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
   };
 }
 
+// src/material-worktree-changes.ts
+function materialWorktreeChanges(changedFiles) {
+  return changedFiles.filter((line) => {
+    const trimmed = line.trim();
+    const pathPart = trimmed.startsWith("??") ? trimmed.slice(2).trim() : trimmed.length > 3 ? trimmed.slice(3).trim() : trimmed;
+    return pathPart !== "node_modules" && !pathPart.startsWith("node_modules/");
+  });
+}
+function pathFromGitStatusLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.startsWith("??")) return trimmed.slice(2).trim();
+  if (trimmed.length > 3 && /^[ MADRCU?!]{2} /.test(trimmed.slice(0, 3))) {
+    return trimmed.slice(3).trim();
+  }
+  return trimmed;
+}
+
+// src/disposable-artifacts.ts
+function stringList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function extractDisposableArtifactsRemoved(finalResult) {
+  const record = asRecord2(finalResult);
+  if (!record) return [];
+  const nested = asRecord2(record.worktreeHandoff);
+  const fromNested = stringList(nested?.disposableArtifactsRemoved);
+  if (fromNested.length) return fromNested;
+  return stringList(record.disposableArtifactsRemoved);
+}
+function normalizeRelativePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+}
+function dirtyPathsCoveredByDisposableRemoval(changedFiles, removed) {
+  const material = materialWorktreeChanges(changedFiles);
+  if (material.length === 0) return true;
+  if (removed.length === 0) return false;
+  const removedSet = new Set(removed.map((p) => normalizeRelativePath(p)));
+  return material.every((line) => {
+    const path44 = normalizeRelativePath(pathFromGitStatusLine(line));
+    return removedSet.has(path44);
+  });
+}
+
+// src/worktree-completion-handoff.ts
+function trimOrNull5(value) {
+  if (typeof value !== "string") return null;
+  const t = value.trim();
+  return t.length ? t : null;
+}
+function stringList2(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
+}
+function hasFinalResult4(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "boolean") return value;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function mergedDisposableRemoved(input) {
+  const fromWorker = stringList2(input.disposableArtifactsRemoved);
+  const fromResult = extractDisposableArtifactsRemoved(input.finalResult);
+  return [.../* @__PURE__ */ new Set([...fromWorker, ...fromResult])];
+}
+function assessWorktreeCompletionHandoff(input) {
+  const rawDirty = stringList2(input.changedFiles);
+  const materialDirty = materialWorktreeChanges(rawDirty);
+  const removed = mergedDisposableRemoved(input);
+  const effectivelyClean = materialDirty.length === 0 || dirtyPathsCoveredByDisposableRemoval(rawDirty, removed);
+  if (trimOrNull5(input.prUrl)) {
+    if (!effectivelyClean) {
+      return {
+        allowed: false,
+        state: "dirty_worktree",
+        materialDirtyCount: materialDirty.length,
+        detail: `Worktree has ${materialDirty.length} uncommitted change(s) with a PR attached; commit or discard before completing`
+      };
+    }
+    return { allowed: true, state: "pr_handoff", materialDirtyCount: 0 };
+  }
+  if (trimOrNull5(input.headCommit)) {
+    if (!effectivelyClean) {
+      return {
+        allowed: false,
+        state: "dirty_worktree",
+        materialDirtyCount: materialDirty.length,
+        detail: `Worktree has ${materialDirty.length} uncommitted change(s) on top of a commit; commit or discard before completing`
+      };
+    }
+    return { allowed: true, state: "commit_handoff", materialDirtyCount: 0 };
+  }
+  if (trimOrNull5(input.artifactBundlePath) || trimOrNull5(input.patchPath)) {
+    if (!effectivelyClean) {
+      return {
+        allowed: false,
+        state: "dirty_worktree",
+        materialDirtyCount: materialDirty.length,
+        detail: `Worktree has ${materialDirty.length} uncommitted change(s) with a patch/bundle handoff; clean the tree before completing`
+      };
+    }
+    return { allowed: true, state: "commit_handoff", materialDirtyCount: 0 };
+  }
+  if (effectivelyClean) {
+    return { allowed: true, state: "clean", materialDirtyCount: 0 };
+  }
+  if (hasFinalResult4(input.finalResult)) {
+    return {
+      allowed: false,
+      state: "dirty_worktree_no_pr",
+      materialDirtyCount: materialDirty.length,
+      detail: `Worktree has ${materialDirty.length} uncommitted change(s) with no commit or PR; commit, open a PR, discard, or remove one-off files via \`kynver worker discard-disposable\` before completing`
+    };
+  }
+  return {
+    allowed: false,
+    state: "dirty_worktree",
+    materialDirtyCount: materialDirty.length,
+    detail: `Worktree has ${materialDirty.length} uncommitted change(s) with no final result`
+  };
+}
+
 // src/worker-lifecycle.ts
 import path11 from "node:path";
 var TASK_LEFT_RUNNING = /* @__PURE__ */ new Set([
@@ -3007,7 +3215,7 @@ function completionErrorText(parsed) {
   }
   return void 0;
 }
-function asRecord2(value) {
+function asRecord3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function asString2(value) {
@@ -3084,26 +3292,48 @@ async function tryCompleteWorker(args) {
   if (worker.localOnly) {
     return { ok: true, skipped: true, reason: "local-only-worker" };
   }
+  const headCommit = status.gitAncestry.headIsAncestorOfBase === false && status.gitAncestry.head ? status.gitAncestry.head : status.headCommit;
+  const handoff = assessWorktreeCompletionHandoff({
+    changedFiles: status.changedFiles,
+    finalResult: status.finalResult,
+    prUrl: status.prUrl,
+    headCommit,
+    disposableArtifactsRemoved: worker.disposableArtifactsRemoved
+  });
+  if (!handoff.allowed) {
+    const reason2 = handoff.detail ?? `worktree completion blocked (${handoff.state})`;
+    persistCompletionBlocker(worker, reason2);
+    return {
+      ok: false,
+      reason: reason2,
+      nextAction: "Clean the worktree (commit, open a PR, or `kynver worker discard-disposable --path <file>`), then rerun `kynver worker complete`.",
+      completionBlocked: true
+    };
+  }
   const skipPrHandoff = args.skipPrHandoff === true || args.skipPrHandoff === "true";
   if (!skipPrHandoff && worker.dispatched && taskId) {
-    const handoff = ensurePrReadyHandoff({ worker, run, status });
-    if (!handoff.ok) {
-      persistCompletionBlocker(worker, handoff.reason);
+    const handoff2 = ensurePrReadyHandoff({ worker, run, status });
+    if (!handoff2.ok) {
+      persistCompletionBlocker(worker, handoff2.reason);
       return {
         ok: false,
-        reason: handoff.reason,
-        nextAction: handoff.nextAction,
+        reason: handoff2.reason,
+        nextAction: handoff2.nextAction,
         completionBlocked: true
       };
     }
-    if (handoff.prUrl || handoff.headCommit) {
-      status = applyPrHandoffToStatus(status, handoff);
+    if (handoff2.prUrl || handoff2.headCommit) {
+      status = applyPrHandoffToStatus(status, handoff2);
     }
   }
   const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
   const explicitSecret = args.secret ? String(args.secret) : void 0;
   let secret = await resolveCallbackSecretWithMint(explicitSecret, agentOsId, { baseUrl: base });
   const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/harness/completion`;
+  const statusPayload = { ...status };
+  if (worker.disposableArtifactsRemoved?.length) {
+    statusPayload.disposableArtifactsRemoved = worker.disposableArtifactsRemoved;
+  }
   const body = {
     source: "kynver-harness",
     agentOsId,
@@ -3112,10 +3342,11 @@ async function tryCompleteWorker(args) {
     taskId,
     startedAt: worker.startedAt,
     finishedAt: status.lastActivityAt || (/* @__PURE__ */ new Date()).toISOString(),
-    status,
+    status: statusPayload,
     workerInjection: {
       instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
       instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null,
+      memoryQualityCapture: worker.memoryQualityCapture ?? 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
@@ -3256,8 +3487,8 @@ function buildRunBoard(runId) {
     const completionBlocker = typeof rawBlocker === "string" && rawBlocker ? rawBlocker : void 0;
     const boardStatus = completionBlocker ? "blocked" : status.status;
     const boardAttention = completionBlocker ? "blocked" : status.attention.state;
-    const completionResponse = asRecord2(worker.completionResponse);
-    const completionTask = asRecord2(completionResponse?.task);
+    const completionResponse = asRecord3(worker.completionResponse);
+    const completionTask = asRecord3(completionResponse?.task);
     const completionOutcome = asString2(completionResponse?.outcome);
     const completionRouteStatus = asString2(completionResponse?.status);
     const completionWarnings = Array.isArray(completionResponse?.warnings) ? completionResponse.warnings.filter((w) => typeof w === "string" && w.trim().length > 0) : [];
@@ -3538,7 +3769,7 @@ function resolveDefaultCliPath() {
 }
 function spawnCompletionSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath();
-  if (!existsSync11(cliPath)) return void 0;
+  if (!existsSync12(cliPath)) return void 0;
   const logPath = path13.join(opts.workerDir, "auto-complete.log");
   let logFd;
   try {
@@ -3625,7 +3856,7 @@ function spawnWorkerProcess(run, opts) {
   mkdirSync3(workerDir, { recursive: true });
   const worktreePath = path14.join(worktreesDir, run.id, name);
   const branch = opts.branch || `agent/${run.id}/${name}`;
-  if (existsSync12(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
+  if (existsSync13(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 = path14.join(workerDir, "stdout.jsonl");
@@ -3681,6 +3912,7 @@ function spawnWorkerProcess(run, opts) {
     ...opts.planId ? { planId: String(opts.planId) } : {},
     ...opts.instructionPolicyFingerprint ? { instructionPolicyFingerprint: String(opts.instructionPolicyFingerprint) } : {},
     ...opts.instructionPolicyEvidence ? { instructionPolicyEvidence: opts.instructionPolicyEvidence } : {},
+    ...opts.memoryQualityCapture ? { memoryQualityCapture: opts.memoryQualityCapture } : {},
     ...opts.personaSlug ? { personaSlug: String(opts.personaSlug) } : {},
     ...opts.personaEvidence ? { personaEvidence: opts.personaEvidence } : {},
     ...opts.leaseOwner ? { leaseOwner: String(opts.leaseOwner) } : {},
@@ -4015,8 +4247,8 @@ function isTmpOnlyPath(filePath) {
 
 // src/plan-persist/outbox-store.ts
 import {
-  existsSync as existsSync14,
-  readFileSync as readFileSync8,
+  existsSync as existsSync15,
+  readFileSync as readFileSync9,
   renameSync,
   readdirSync as readdirSync4,
   writeFileSync as writeFileSync3,
@@ -4042,9 +4274,9 @@ function findOutboxByIdempotencyKey(key) {
   return null;
 }
 function readOutboxItem(jsonPath) {
-  if (!existsSync14(jsonPath)) return null;
+  if (!existsSync15(jsonPath)) return null;
   try {
-    return JSON.parse(readFileSync8(jsonPath, "utf8"));
+    return JSON.parse(readFileSync9(jsonPath, "utf8"));
   } catch {
     return null;
   }
@@ -4052,7 +4284,7 @@ function readOutboxItem(jsonPath) {
 function readOutboxBody(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
   const bodyFile = path16.join(outboxDir, item.bodyPath);
-  return readFileSync8(bodyFile, "utf8");
+  return readFileSync9(bodyFile, "utf8");
 }
 function writeOutboxItem(input, opts) {
   const { outboxDir } = ensurePlanOutboxDirs();
@@ -4106,8 +4338,8 @@ function archiveOutboxItem(item) {
   const bodySrc = path16.join(outboxDir, item.bodyPath);
   const jsonDst = path16.join(archiveDir, `${item.id}.json`);
   const bodyDst = path16.join(archiveDir, item.bodyPath);
-  if (existsSync14(jsonSrc)) renameSync(jsonSrc, jsonDst);
-  if (existsSync14(bodySrc)) renameSync(bodySrc, bodyDst);
+  if (existsSync15(jsonSrc)) renameSync(jsonSrc, jsonDst);
+  if (existsSync15(bodySrc)) renameSync(bodySrc, bodyDst);
 }
 function outboxItemPaths(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
@@ -4376,10 +4608,12 @@ function readHarnessWorkerContext(decision) {
   const personaSlug = typeof ctx.personaEvidence === "object" && ctx.personaEvidence && typeof ctx.personaEvidence.injectedPersonaSlug === "string" ? ctx.personaEvidence.injectedPersonaSlug : null;
   const personaEvidence = ctx.personaEvidence && typeof ctx.personaEvidence === "object" ? ctx.personaEvidence : null;
   const personaInjectionReady = ctx.personaInjectionReady === true;
+  const memoryQualityCapture = ctx.memoryQualityCapture && typeof ctx.memoryQualityCapture === "object" ? ctx.memoryQualityCapture : null;
   return {
     instructionPolicyMarkdown: markdown,
     instructionPolicyFingerprint: fingerprint,
     instructionPolicyEvidence: evidence,
+    memoryQualityCapture,
     personaMarkdown,
     personaSlug,
     personaEvidence,
@@ -4568,6 +4802,7 @@ async function dispatchRun(args) {
           instructionPolicyMarkdown: harnessContext?.instructionPolicyMarkdown ?? null,
           instructionPolicyFingerprint: harnessContext?.instructionPolicyFingerprint ?? null,
           instructionPolicyEvidence: harnessContext?.instructionPolicyEvidence ?? null,
+          memoryQualityCapture: harnessContext?.memoryQualityCapture ?? null,
           personaMarkdown: harnessContext?.personaMarkdown ?? null,
           personaSlug: harnessContext?.personaSlug ?? expectedPersona,
           personaEvidence: harnessContext?.personaEvidence ?? null,
@@ -4657,8 +4892,175 @@ function redactHarness(text, secret) {
   return out;
 }
 
+// src/db-credential-resolver.ts
+import { execFileSync, spawnSync as spawnSync3 } from "node:child_process";
+import * as fs from "node:fs";
+import * as path19 from "node:path";
+
+// src/db-url-hint.ts
+function safeDatabaseUrlHint(url) {
+  if (!url?.trim()) return "(not set)";
+  try {
+    const u = new URL(url);
+    const name = (u.pathname || "").replace(/^\//, "").split("?")[0] || "(no database name)";
+    return `${u.hostname} / ${name}`;
+  } catch {
+    return "(invalid URL)";
+  }
+}
+
+// src/db-credential-resolver.ts
+var PRODUCTION_ENV_KEYS = [
+  "KYNVER_PRODUCTION_DATABASE_URL",
+  "PRODUCTION_DATABASE_URL"
+];
+var ENV_FILE_KEYS = [...PRODUCTION_ENV_KEYS];
+function readEnvValue(env, key) {
+  const value = env[key]?.trim();
+  return value || void 0;
+}
+function readProductionDbKeysFromEnvFile(envPath) {
+  if (!fs.existsSync(envPath)) return {};
+  const out = {};
+  const allowed = new Set(ENV_FILE_KEYS);
+  for (const line of fs.readFileSync(envPath, "utf8").split("\n")) {
+    const m = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (!m || !allowed.has(m[1])) continue;
+    const key = m[1];
+    out[key] = m[2].replace(/^["']|["']$/g, "").trim();
+  }
+  return out;
+}
+function resolveFromProcessEnv(env) {
+  for (const key of PRODUCTION_ENV_KEYS) {
+    const value = readEnvValue(env, key);
+    if (value) {
+      return {
+        ok: true,
+        databaseUrl: value,
+        source: `env:${key}`,
+        hint: safeDatabaseUrlHint(value)
+      };
+    }
+  }
+  return null;
+}
+function resolveFromEnvFile(cwd) {
+  const envPath = path19.join(cwd, ".env");
+  const parsed = readProductionDbKeysFromEnvFile(envPath);
+  for (const key of ENV_FILE_KEYS) {
+    const value = parsed[key]?.trim();
+    if (value) {
+      return {
+        ok: true,
+        databaseUrl: value,
+        source: `env-file:${key}`,
+        hint: safeDatabaseUrlHint(value)
+      };
+    }
+  }
+  return null;
+}
+function defaultNeonConnectionString(args) {
+  const neonBin = process.platform === "win32" ? "neon.cmd" : "neon";
+  const argv = [
+    "connection-string",
+    args.branch,
+    "--prisma",
+    "-o",
+    "json",
+    "--no-color",
+    "--no-analytics"
+  ];
+  if (args.projectId) argv.push("--project-id", args.projectId);
+  if (args.databaseName) argv.push("--database-name", args.databaseName);
+  if (args.roleName) argv.push("--role-name", args.roleName);
+  if (args.pooled) argv.push("--pooled");
+  let stdout;
+  try {
+    const result = spawnSync3(neonBin, argv, {
+      encoding: "utf8",
+      env: process.env,
+      timeout: 3e4
+    });
+    if (result.status !== 0) return null;
+    stdout = (result.stdout || "").trim();
+  } catch {
+    try {
+      stdout = execFileSync("neonctl", argv, {
+        encoding: "utf8",
+        env: process.env,
+        timeout: 3e4
+      }).trim();
+    } catch {
+      return null;
+    }
+  }
+  if (!stdout) return null;
+  try {
+    const parsed = JSON.parse(stdout);
+    const fromField = typeof parsed.connection_uri === "string" && parsed.connection_uri || typeof parsed.connection_string === "string" && parsed.connection_string || typeof parsed.connectionString === "string" && parsed.connectionString;
+    if (fromField) return fromField;
+  } catch {
+  }
+  if (/^postgres(ql)?:\/\//i.test(stdout)) return stdout;
+  return null;
+}
+function resolveFromNeonCli(env, neonFn) {
+  const branch = readEnvValue(env, "KYNVER_NEON_BRANCH") || readEnvValue(env, "NEON_BRANCH") || "production";
+  const url = neonFn({
+    branch,
+    projectId: readEnvValue(env, "KYNVER_NEON_PROJECT_ID") || readEnvValue(env, "NEON_PROJECT_ID"),
+    databaseName: readEnvValue(env, "KYNVER_NEON_DATABASE_NAME") || readEnvValue(env, "NEON_DATABASE_NAME"),
+    roleName: readEnvValue(env, "KYNVER_NEON_ROLE_NAME") || readEnvValue(env, "NEON_ROLE_NAME"),
+    pooled: readEnvValue(env, "KYNVER_NEON_POOLED") === "1" || readEnvValue(env, "NEON_POOLED") === "1"
+  });
+  if (!url) return null;
+  return {
+    ok: true,
+    databaseUrl: url,
+    source: "neon-cli",
+    hint: safeDatabaseUrlHint(url)
+  };
+}
+function resolveProductionDatabaseUrl(options = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  const neonFn = options.neonConnectionString ?? defaultNeonConnectionString;
+  const attempted = [];
+  const fromNeon = resolveFromNeonCli(env, neonFn);
+  attempted.push("neon-cli");
+  if (fromNeon) return fromNeon;
+  for (const key of PRODUCTION_ENV_KEYS) {
+    attempted.push(`env:${key}`);
+  }
+  const fromEnv = resolveFromProcessEnv(env);
+  if (fromEnv) return fromEnv;
+  for (const key of ENV_FILE_KEYS) {
+    attempted.push(`env-file:${key}`);
+  }
+  const fromFile = resolveFromEnvFile(cwd);
+  if (fromFile) return fromFile;
+  return {
+    ok: false,
+    reason: "No production database credentials found. Authenticate Neon CLI (`neon auth`), set KYNVER_NEON_* / NEON_* project hints, or provide PRODUCTION_DATABASE_URL / KYNVER_PRODUCTION_DATABASE_URL (process env or selective .env keys only).",
+    attempted
+  };
+}
+function applyProductionDatabaseToProcess(options = {}) {
+  const resolved = resolveProductionDatabaseUrl(options);
+  if (!resolved.ok) {
+    throw new Error(resolved.reason);
+  }
+  process.env.DATABASE_URL = resolved.databaseUrl;
+  console.error(
+    `[kynver-cli] database target: ${resolved.hint} (source: ${resolved.source})`
+  );
+  return resolved;
+}
+
 // src/validate.ts
-import path19 from "node:path";
+import path20 from "node:path";
 var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 var WORKER_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
 function validateRunId(runId) {
@@ -4672,15 +5074,15 @@ function validateWorkerName(name) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path19.resolve(repo);
+  const resolved = path20.resolve(repo);
   if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
   return resolved;
 }
 function validateOwnedPaths(repoRoot, ownedPaths) {
   return ownedPaths.map((owned) => {
-    const resolved = path19.resolve(repoRoot, owned);
-    const rel = path19.relative(repoRoot, resolved);
-    if (rel.startsWith("..") || path19.isAbsolute(rel)) {
+    const resolved = path20.resolve(repoRoot, owned);
+    const rel = path20.relative(repoRoot, resolved);
+    if (rel.startsWith("..") || path20.isAbsolute(rel)) {
       throw new Error(`owned path escapes repo: ${owned}`);
     }
     return resolved;
@@ -4692,13 +5094,13 @@ function validateTailLines(lines) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync5 } from "node:fs";
-import path21 from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync5 } from "node:fs";
+import path22 from "node:path";
 
 // src/default-repo.ts
-import path20 from "node:path";
+import path21 from "node:path";
 function expandConfiguredRepo(value) {
-  return path20.resolve(resolveUserPath(value.trim()));
+  return path21.resolve(resolveUserPath(value.trim()));
 }
 function fromConfigured(value, source, persistedInConfig) {
   const trimmed = value?.trim();
@@ -4732,7 +5134,7 @@ function resolveDefaultRepo(opts = {}) {
 function persistDefaultRepo(repo, existing) {
   const config = {
     ...existing ?? loadUserConfig(),
-    defaultRepo: redactHomePath(path20.resolve(repo))
+    defaultRepo: redactHomePath(path21.resolve(repo))
   };
   saveUserConfig(config);
   return config;
@@ -4778,7 +5180,7 @@ function createRun(args) {
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync15(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync17(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();
@@ -4792,12 +5194,12 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path21.join(dir, "run.json"), run);
+  writeJson(path22.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(path21.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
+  const rows = listRunIds(runsDir).map((id) => readJson(path22.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
     id: run.id,
     name: run.name,
     status: run.status,
@@ -4812,7 +5214,7 @@ function failExists(message) {
 }
 
 // src/sweep.ts
-import path22 from "node:path";
+import path23 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -4825,7 +5227,7 @@ async function sweepRun(args) {
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path22.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path23.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
@@ -4867,69 +5269,182 @@ async function sweepRun(args) {
   }
 }
 
-// src/cli.ts
-import { mkdirSync as mkdirSync7, realpathSync } from "node:fs";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
-
-// src/pipeline-tick.ts
-import path32 from "node:path";
+// src/harness-storage-snapshot.ts
+import { existsSync as existsSync19, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import path25 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;
+// src/cleanup-dir-size.ts
+import { existsSync as existsSync18, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
+import path24 from "node:path";
+function directorySizeBytes(root, maxEntries = 5e4) {
+  if (!existsSync18(root)) return 0;
+  let total = 0;
+  let seen = 0;
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync5(current);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (seen++ > maxEntries) return null;
+      const full = path24.join(current, name);
+      let st;
+      try {
+        st = statSync2(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) stack.push(full);
+      else total += st.size;
+    }
+  }
+  return total;
 }
-async function runPipelineDispatch(args, slots) {
-  if (slots <= 0) {
-    return { ok: true, skipped: true, reason: "no slots", maxStarts: 0, startedCount: 0 };
+
+// src/harness-storage-snapshot.ts
+function harnessStorageSnapshot(opts = {}) {
+  const harnessRoot = opts.harnessRoot ?? resolveHarnessRoot();
+  const worktreesDir = path25.join(harnessRoot, "worktrees");
+  const now = opts.now ?? Date.now();
+  const scannedAt = new Date(now).toISOString();
+  if (!existsSync19(worktreesDir)) {
+    return {
+      harnessRoot,
+      worktreesDir,
+      worktreesBytes: 0,
+      runCount: 0,
+      workerCount: 0,
+      oldestRunAt: null,
+      scannedAt
+    };
   }
-  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) {
+  let totalBytes = 0;
+  let runCount = 0;
+  let workerCount = 0;
+  let oldestMs = null;
+  let entries;
+  try {
+    entries = readdirSync6(worktreesDir, { withFileTypes: true });
+  } catch {
     return {
-      ...typeof review === "object" && review !== null ? review : {},
-      passes: { review },
-      startedCount: reviewStarted
+      harnessRoot,
+      worktreesDir,
+      worktreesBytes: null,
+      runCount: 0,
+      workerCount: 0,
+      oldestRunAt: null,
+      scannedAt
     };
   }
-  const work = await dispatchRun({
-    ...base,
-    execute: true,
-    pipeline: true,
-    maxStarts: String(workSlots)
-  });
-  const workStarted = countDispatchStarts(work);
+  for (const runEntry of entries) {
+    if (!runEntry.isDirectory()) continue;
+    runCount += 1;
+    const runPath = path25.join(worktreesDir, runEntry.name);
+    try {
+      const st = statSync3(runPath);
+      oldestMs = oldestMs === null ? st.mtimeMs : Math.min(oldestMs, st.mtimeMs);
+    } catch {
+    }
+    try {
+      for (const workerEntry of readdirSync6(runPath, { withFileTypes: true })) {
+        if (workerEntry.isDirectory()) workerCount += 1;
+      }
+    } catch {
+    }
+    if (totalBytes !== null && opts.perRunEntryCap !== null) {
+      const cap = opts.perRunEntryCap ?? 5e4;
+      if (cap <= 0) {
+        totalBytes = null;
+      } else {
+        const runBytes = directorySizeBytes(runPath, cap);
+        if (runBytes === null) totalBytes = null;
+        else totalBytes += runBytes;
+      }
+    }
+  }
   return {
-    passes: { review, work },
-    startedCount: reviewStarted + workStarted,
-    ok: true
+    harnessRoot,
+    worktreesDir,
+    worktreesBytes: totalBytes,
+    runCount,
+    workerCount,
+    oldestRunAt: oldestMs === null ? null : new Date(oldestMs).toISOString(),
+    scannedAt
   };
 }
 
-// src/stale-reconcile.ts
-import path24 from "node:path";
+// src/cleanup-orphan-safety.ts
+import { existsSync as existsSync20, statSync as statSync4 } from "node:fs";
+import path26 from "node:path";
+
+// src/cleanup-guards-helpers.ts
+function materialWorktreeChanges2(changedFiles) {
+  return changedFiles.filter((line) => {
+    const trimmed = line.trim();
+    const pathPart = trimmed.startsWith("??") ? trimmed.slice(2).trim() : trimmed.length > 3 ? trimmed.slice(3).trim() : trimmed;
+    return pathPart !== "node_modules" && !pathPart.startsWith("node_modules/");
+  });
+}
+
+// src/cleanup-orphan-safety.ts
+var DEFAULT_HEARTBEAT_FRESH_MS = 30 * 60 * 1e3;
+function assessOrphanWorktreeSafety(input) {
+  const now = input.now ?? Date.now();
+  const heartbeatFreshMs = input.heartbeatFreshMs ?? DEFAULT_HEARTBEAT_FRESH_MS;
+  if (!existsSync20(input.worktreePath)) return null;
+  if (input.runId && input.workerName) {
+    const heartbeatPath = path26.join(
+      input.harnessRoot,
+      "runs",
+      input.runId,
+      "workers",
+      input.workerName,
+      "heartbeat.jsonl"
+    );
+    try {
+      const mtime = statSync4(heartbeatPath).mtimeMs;
+      if (now - mtime < heartbeatFreshMs) return "active_worker";
+    } catch {
+    }
+  }
+  const gitDir = path26.join(input.worktreePath, ".git");
+  if (!existsSync20(gitDir)) return null;
+  const porcelain = gitCapture(input.worktreePath, ["status", "--porcelain"]);
+  if (porcelain.status !== 0) return "pr_or_unmerged_commits";
+  const dirtyLines = porcelain.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  if (materialWorktreeChanges2(dirtyLines).length > 0) return "dirty_worktree";
+  const upstreamAhead = gitCapture(input.worktreePath, [
+    "rev-list",
+    "--count",
+    "@{u}..HEAD"
+  ]);
+  if (upstreamAhead.status === 0) {
+    const count = Number(upstreamAhead.stdout.trim());
+    if (Number.isFinite(count) && count > 0) return "pr_or_unmerged_commits";
+  }
+  const mainAhead = gitCapture(input.worktreePath, [
+    "rev-list",
+    "--count",
+    "origin/main..HEAD"
+  ]);
+  if (mainAhead.status !== 0) {
+    if (upstreamAhead.status !== 0) return "pr_or_unmerged_commits";
+    return null;
+  }
+  const mainCount = Number(mainAhead.stdout.trim());
+  if (Number.isFinite(mainCount) && mainCount > 0) return "pr_or_unmerged_commits";
+  return null;
+}
+
+// src/cleanup.ts
+import path31 from "node:path";
 
 // src/finalize.ts
-import path23 from "node:path";
+import path27 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set([
   "running",
   "dispatching",
@@ -4947,7 +5462,7 @@ function deriveTerminalRunStatus(run) {
   let anyLandingBlocked = false;
   for (const name of names) {
     const worker = readJson(
-      path23.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path27.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) continue;
@@ -4986,188 +5501,6 @@ function finalizeStaleRuns() {
   return finalized;
 }
 
-// src/stale-reconcile.ts
-var STALE_RECONCILE_HEARTBEAT_MS = 15 * 60 * 1e3;
-function staleReconcileDisabled() {
-  return process.env.KYNVER_NO_STALE_CLEANUP === "1";
-}
-function reconcileStaleWorkers() {
-  if (staleReconcileDisabled()) {
-    return { workers: [], finalizedRuns: finalizeStaleRuns() };
-  }
-  const outcomes = [];
-  const now = Date.now();
-  for (const run of listRunRecords()) {
-    for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path24.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
-      const worker = readJson(workerPath, void 0);
-      if (!worker || worker.status !== "running") {
-        outcomes.push({
-          runId: run.id,
-          worker: name,
-          action: "skipped",
-          reason: worker ? `worker status is ${worker.status}` : "worker.json missing"
-        });
-        continue;
-      }
-      const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
-      if (status.finalResult) {
-        if (worker.status === "running") {
-          const nextStatus = status.attention.state === "blocked" ? "blocked" : status.attention.state === "done" || status.status === "done" ? "done" : "exited";
-          worker.status = nextStatus;
-          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
-          worker.reconcileReason = "synced finished worker record after terminal stdout/heartbeat";
-          saveWorker(run.id, worker);
-          outcomes.push({
-            runId: run.id,
-            worker: name,
-            action: "marked_exited",
-            reason: worker.reconcileReason
-          });
-        } else {
-          outcomes.push({ runId: run.id, worker: name, action: "skipped", reason: "final result present" });
-        }
-        continue;
-      }
-      if (!status.alive) {
-        const nextStatus = status.attention.state === "blocked" ? "blocked" : status.status === "done" ? "done" : "exited";
-        worker.status = nextStatus;
-        worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
-        worker.reconcileReason = status.attention.reason;
-        saveWorker(run.id, worker);
-        outcomes.push({
-          runId: run.id,
-          worker: name,
-          action: "marked_exited",
-          reason: status.attention.reason
-        });
-        continue;
-      }
-      if (status.attention.state === "stale" && worker.pid && isPidAlive(worker.pid)) {
-        const hbMs = status.lastHeartbeatAt ? Date.parse(status.lastHeartbeatAt) : NaN;
-        const actMs = status.lastActivityAt ? Date.parse(status.lastActivityAt) : NaN;
-        const hbStale = !Number.isFinite(hbMs) || now - hbMs > STALE_RECONCILE_HEARTBEAT_MS;
-        const actStale = Number.isFinite(actMs) && now - actMs > STALE_MS;
-        if (hbStale && actStale) {
-          killWorkerProcess(worker.pid, "SIGTERM");
-          worker.status = "exited";
-          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
-          worker.reconcileReason = `reconciled stale worker: ${status.attention.reason}`;
-          saveWorker(run.id, worker);
-          outcomes.push({
-            runId: run.id,
-            worker: name,
-            action: "killed_stale",
-            reason: status.attention.reason
-          });
-          continue;
-        }
-      }
-      outcomes.push({
-        runId: run.id,
-        worker: name,
-        action: "skipped",
-        reason: status.attention.reason
-      });
-    }
-  }
-  return { workers: outcomes, finalizedRuns: finalizeStaleRuns() };
-}
-function reconcileRunsCli() {
-  const result = reconcileStaleWorkers();
-  const markedExited = result.workers.filter((w) => w.action === "marked_exited").length;
-  const killedStale = result.workers.filter((w) => w.action === "killed_stale").length;
-  const skipped = result.workers.filter((w) => w.action === "skipped").length;
-  console.log(
-    JSON.stringify(
-      {
-        ok: true,
-        workers: { markedExited, killedStale, skipped, total: result.workers.length },
-        finalizedRuns: result.finalizedRuns.length,
-        details: { workers: result.workers, finalizedRuns: result.finalizedRuns }
-      },
-      null,
-      2
-    )
-  );
-}
-
-// src/plan-progress-daemon-sync.ts
-import path25 from "node:path";
-
-// src/plan-progress-sync.ts
-async function syncPlanProgress(args) {
-  const base = resolveBaseUrl(args.baseUrl);
-  const secret = await resolveCallbackSecretWithMint(args.secret, args.agentOsId, { baseUrl: base });
-  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(args.agentOsId)}/tasks/${encodeURIComponent(args.taskId)}/plan-progress-sync`;
-  const res = await postJsonWithCredentialRefresh(url, secret, {
-    phase: args.phase,
-    taskId: args.taskId,
-    blocker: args.blocker,
-    artifact: args.artifact
-  }, { agentOsId: args.agentOsId, baseUrl: base });
-  return { ok: res.ok, status: res.status, response: res.response };
-}
-
-// src/plan-progress-daemon-sync.ts
-async function syncActiveWorkerPlanProgress(runId, args) {
-  const run = loadRun(runId);
-  const agentOsId = String(args.agentOsId || "");
-  if (!agentOsId) return [];
-  const outcomes = [];
-  for (const name of Object.keys(run.workers || {})) {
-    const worker = readJson(
-      path25.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-      void 0
-    );
-    if (!worker?.dispatched || !worker.taskId) continue;
-    const status = computeWorkerStatus(worker);
-    if (!status.heartbeatBlocker) continue;
-    if (worker.lastSyncedHeartbeatBlocker === status.heartbeatBlocker) {
-      outcomes.push({ worker: name, phase: "heartbeat_blocker", ok: true, skipped: true });
-      continue;
-    }
-    const res = await syncPlanProgress({
-      agentOsId,
-      taskId: worker.taskId,
-      phase: "heartbeat_blocker",
-      blocker: status.heartbeatBlocker,
-      baseUrl: args.baseUrl ? String(args.baseUrl) : void 0,
-      secret: args.secret ? String(args.secret) : void 0
-    });
-    if (res.ok) {
-      worker.lastSyncedHeartbeatBlocker = status.heartbeatBlocker;
-      saveWorker(run.id, worker);
-    }
-    outcomes.push({ worker: name, phase: "heartbeat_blocker", ok: res.ok });
-  }
-  return outcomes;
-}
-
-// src/workspace-runtime-config.ts
-async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
-  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
-  const secret = await resolveCallbackSecretWithMint(args.secret ? String(args.secret) : void 0, agentOsId, { baseUrl: base });
-  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/runtime`;
-  try {
-    const res = await getJson(url, secret);
-    if (!res.ok) return null;
-    const body = res.response;
-    const raw = body?.preferences?.maxConcurrentWorkers;
-    if (raw === null || raw === void 0) {
-      return { maxConcurrentWorkers: null };
-    }
-    const n = Number(raw);
-    if (!Number.isFinite(n) || n <= 0) return { maxConcurrentWorkers: null };
-    return { maxConcurrentWorkers: Math.floor(n) };
-  } catch {
-    return null;
-  }
-}
-
-// src/cleanup.ts
-import path30 from "node:path";
-
 // src/cleanup-run-liveness.ts
 function isWorkerProcessLive(indexed) {
   if (indexed.status.alive) return true;
@@ -5209,29 +5542,25 @@ function isPrOrUnmergedWork(status) {
   if (status.changedFiles.length > 0 && status.finalResult) return true;
   return false;
 }
-function materialWorktreeChanges(changedFiles) {
-  return changedFiles.filter((line) => {
-    const trimmed = line.trim();
-    const pathPart = trimmed.startsWith("??") ? trimmed.slice(2).trim() : trimmed.length > 3 ? trimmed.slice(3).trim() : trimmed;
-    return pathPart !== "node_modules" && !pathPart.startsWith("node_modules/");
-  });
-}
 function hasUnrestorableWorktreeChanges(status) {
-  if (materialWorktreeChanges(status.changedFiles).length > 0) return true;
+  if (materialWorktreeChanges2(status.changedFiles).length > 0) return true;
   if (status.gitAncestry?.relation === "diverged") return true;
   return false;
 }
 function skipWorktreeRemoval(input) {
-  const { indexed, includeOrphans, worktreesAgeMs, ageMs } = input;
-  if (worktreesAgeMs <= 0) return "worktrees_disabled";
-  if (ageMs < worktreesAgeMs) return "below_age_threshold";
-  if (!indexed) return includeOrphans ? null : "orphan_without_flag";
+  const { indexed, includeOrphans, worktreesAgeMs, ageMs, orphanSafety, worktreeRemovalGuard } = input;
+  if (!indexed) {
+    if (!includeOrphans) return "orphan_without_flag";
+    return orphanSafety ?? null;
+  }
+  if (worktreesAgeMs <= 0 && !includeOrphans) return "worktrees_disabled";
+  if (worktreesAgeMs > 0 && ageMs < worktreesAgeMs) return "below_age_threshold";
   if (isWorkerProcessLive(indexed)) return "active_worker";
   if (indexed.worker.completionBlocker) return "completion_blocked";
   if (runBlocksWorktreeRemoval(indexed)) return "run_still_active";
   if (!isFinishedWorkerStatus(indexed.status)) return "run_still_active";
   if (isPrOrUnmergedWork(indexed.status)) return "pr_or_unmerged_commits";
-  if (materialWorktreeChanges(indexed.status.changedFiles).length > 0) return "dirty_worktree";
+  if (materialWorktreeChanges2(indexed.status.changedFiles).length > 0) return "dirty_worktree";
   const landing = assessWorkerLanding({
     finalResult: indexed.status.finalResult,
     changedFiles: indexed.status.changedFiles,
@@ -5239,6 +5568,17 @@ function skipWorktreeRemoval(input) {
     prUrl: prUrlFromFinalResult(indexed.status.finalResult)
   });
   if (landing.blocked) return "landing_blocked";
+  if (worktreeRemovalGuard && input.worktreePath) {
+    const overlay = worktreeRemovalGuard({
+      worktreePath: input.worktreePath,
+      indexed: Boolean(indexed),
+      runId: indexed?.runId,
+      worker: indexed?.workerName
+    });
+    if (overlay) {
+      return overlay.detail ? { reason: overlay.reason, detail: overlay.detail } : overlay.reason;
+    }
+  }
   return null;
 }
 function skipNodeModulesRemoval(input) {
@@ -5255,51 +5595,17 @@ function skipNodeModulesRemoval(input) {
     gitAncestry: indexed.status.gitAncestry,
     prUrl: prUrlFromFinalResult(indexed.status.finalResult)
   });
-  if (landing.blocked && materialWorktreeChanges(indexed.status.changedFiles).length > 0) {
+  if (landing.blocked && materialWorktreeChanges2(indexed.status.changedFiles).length > 0) {
     return "landing_blocked";
   }
   return null;
 }
 
 // src/cleanup-execute.ts
-import { existsSync as existsSync17, rmSync } from "node:fs";
-import path27 from "node:path";
-
-// src/cleanup-dir-size.ts
-import { existsSync as existsSync16, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
-import path26 from "node:path";
-function directorySizeBytes(root, maxEntries = 5e4) {
-  if (!existsSync16(root)) return 0;
-  let total = 0;
-  let seen = 0;
-  const stack = [root];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    let entries;
-    try {
-      entries = readdirSync5(current);
-    } catch {
-      continue;
-    }
-    for (const name of entries) {
-      if (seen++ > maxEntries) return null;
-      const full = path26.join(current, name);
-      let st;
-      try {
-        st = statSync2(full);
-      } catch {
-        continue;
-      }
-      if (st.isDirectory()) stack.push(full);
-      else total += st.size;
-    }
-  }
-  return total;
-}
-
-// src/cleanup-execute.ts
+import { existsSync as existsSync21, rmSync } from "node:fs";
+import path28 from "node:path";
 function removeNodeModules(candidate, execute) {
-  if (!existsSync17(candidate.path)) {
+  if (!existsSync21(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -5330,7 +5636,7 @@ function removeNodeModules(candidate, execute) {
   }
 }
 function removeWorktree(candidate, execute) {
-  if (!existsSync17(candidate.path)) {
+  if (!existsSync21(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -5347,7 +5653,7 @@ function removeWorktree(candidate, execute) {
     if (repo) {
       git(repo, ["worktree", "remove", "--force", candidate.path], { allowFailure: true });
     }
-    if (existsSync17(candidate.path)) {
+    if (existsSync21(candidate.path)) {
       rmSync(candidate.path, { recursive: true, force: true });
     }
     return {
@@ -5367,40 +5673,40 @@ function removeWorktree(candidate, execute) {
   }
 }
 function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path27.resolve(targetPath);
-  const nm = resolved.endsWith(`${path27.sep}node_modules`) ? resolved : null;
+  const resolved = path28.resolve(targetPath);
+  const nm = resolved.endsWith(`${path28.sep}node_modules`) ? resolved : null;
   if (!nm) return "path_outside_harness";
-  const rel = path27.relative(worktreesDir, nm);
-  if (rel.startsWith("..") || path27.isAbsolute(rel)) return "path_outside_harness";
-  const parts = rel.split(path27.sep);
+  const rel = path28.relative(worktreesDir, nm);
+  if (rel.startsWith("..") || path28.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path28.sep);
   if (parts.length < 3 || parts[parts.length - 1] !== "node_modules") return "path_outside_harness";
-  if (!resolved.startsWith(path27.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path28.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 
 // src/cleanup-scan.ts
-import { existsSync as existsSync18, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
-import path28 from "node:path";
+import { existsSync as existsSync22, readdirSync as readdirSync7, statSync as statSync5 } from "node:fs";
+import path29 from "node:path";
 function pathAgeMs(target, now) {
   try {
-    const mtime = statSync3(target).mtimeMs;
+    const mtime = statSync5(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
   }
 }
 function isPathInside(child, parent) {
-  const rel = path28.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path28.isAbsolute(rel);
+  const rel = path29.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path29.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 = path28.join(entry.worktreePath, "node_modules");
-    if (!existsSync18(nm)) continue;
-    const resolved = path28.resolve(nm);
+    const nm = path29.join(entry.worktreePath, "node_modules");
+    if (!existsSync22(nm)) continue;
+    const resolved = path29.resolve(nm);
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     candidates.push({
@@ -5413,16 +5719,16 @@ function scanNodeModulesCandidates(opts) {
       ageMs: pathAgeMs(resolved, opts.now)
     });
   }
-  if (!opts.includeOrphans || !existsSync18(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync6(opts.worktreesDir, { withFileTypes: true })) {
+  if (!opts.includeOrphans || !existsSync22(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync7(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path28.join(opts.worktreesDir, runEntry.name);
-    for (const workerEntry of readdirSync6(runPath, { withFileTypes: true })) {
+    const runPath = path29.join(opts.worktreesDir, runEntry.name);
+    for (const workerEntry of readdirSync7(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path28.join(runPath, workerEntry.name);
-      const nm = path28.join(worktreePath, "node_modules");
-      if (!existsSync18(nm)) continue;
-      const resolved = path28.resolve(nm);
+      const worktreePath = path29.join(runPath, workerEntry.name);
+      const nm = path29.join(worktreePath, "node_modules");
+      if (!existsSync22(nm)) continue;
+      const resolved = path29.resolve(nm);
       if (seen.has(resolved)) continue;
       if (!isPathInside(resolved, opts.harnessRoot)) continue;
       seen.add(resolved);
@@ -5439,40 +5745,76 @@ function scanNodeModulesCandidates(opts) {
   return candidates;
 }
 function scanWorktreeCandidates(opts) {
-  if (opts.worktreesAgeMs <= 0) return [];
+  const indexedEnabled = opts.worktreesAgeMs > 0 || opts.includeOrphans;
+  const orphanEnabled = opts.includeOrphans;
+  if (!indexedEnabled && !orphanEnabled) return [];
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
+  if (indexedEnabled) {
+    for (const entry of opts.index.values()) {
+      if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
+      const resolved = entry.worktreePath;
+      if (!existsSync22(resolved)) continue;
+      if (seen.has(resolved)) continue;
+      seen.add(resolved);
+      candidates.push({
+        kind: "remove_worktree",
+        path: resolved,
+        bytes: null,
+        runId: entry.runId,
+        worker: entry.workerName,
+        repo: entry.run.repo,
+        ageMs: pathAgeMs(resolved, opts.now)
+      });
+    }
+  }
+  if (!orphanEnabled || !existsSync22(opts.worktreesDir)) return candidates;
+  const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
-    const resolved = entry.worktreePath;
-    if (!existsSync18(resolved)) continue;
-    if (seen.has(resolved)) continue;
-    seen.add(resolved);
-    candidates.push({
-      kind: "remove_worktree",
-      path: resolved,
-      bytes: null,
-      runId: entry.runId,
-      worker: entry.workerName,
-      repo: entry.run.repo,
-      ageMs: pathAgeMs(resolved, opts.now)
-    });
+    indexedPaths.add(path29.resolve(entry.worktreePath));
+  }
+  for (const runEntry of readdirSync7(opts.worktreesDir, { withFileTypes: true })) {
+    if (!runEntry.isDirectory()) continue;
+    if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
+    const runPath = path29.join(opts.worktreesDir, runEntry.name);
+    let workerEntries;
+    try {
+      workerEntries = readdirSync7(runPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const workerEntry of workerEntries) {
+      if (!workerEntry.isDirectory()) continue;
+      const worktreePath = path29.resolve(path29.join(runPath, workerEntry.name));
+      if (seen.has(worktreePath)) continue;
+      if (indexedPaths.has(worktreePath)) continue;
+      if (!isPathInside(worktreePath, opts.harnessRoot)) continue;
+      seen.add(worktreePath);
+      candidates.push({
+        kind: "remove_worktree",
+        path: worktreePath,
+        bytes: null,
+        runId: runEntry.name,
+        worker: workerEntry.name,
+        ageMs: pathAgeMs(worktreePath, opts.now)
+      });
+    }
   }
   return candidates;
 }
 
 // src/cleanup-worktree-index.ts
-import path29 from "node:path";
+import path30 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 = path29.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path30.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(path29.resolve(worker.worktreePath), {
-        worktreePath: path29.resolve(worker.worktreePath),
+      index.set(path30.resolve(worker.worktreePath), {
+        worktreePath: path30.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -5518,157 +5860,465 @@ function resolveHarnessRetention(options = {}) {
     accountBytes
   };
 }
-function resolvePipelineHarnessRetention(runId) {
-  const scopeAll = process.env.KYNVER_CLEANUP_SCOPE === "all";
-  const envWorktrees = Number(process.env.KYNVER_CLEANUP_WORKTREES_AGE_MS);
-  const worktreesAgeMs = scopeAll ? Number.isFinite(envWorktrees) && envWorktrees > 0 ? envWorktrees : DEFAULT_WORKTREES_AGE_MS : Number.isFinite(envWorktrees) && envWorktrees > 0 ? envWorktrees : 0;
-  return resolveHarnessRetention({
-    runIdFilter: scopeAll ? void 0 : runId,
-    worktreesAgeMs,
-    finalizeStaleRuns: true,
-    accountBytes: true
-  });
+function resolvePipelineHarnessRetention(runId) {
+  const scopeAll = process.env.KYNVER_CLEANUP_SCOPE === "all";
+  const envWorktrees = Number(process.env.KYNVER_CLEANUP_WORKTREES_AGE_MS);
+  const worktreesAgeMs = scopeAll ? Number.isFinite(envWorktrees) && envWorktrees > 0 ? envWorktrees : DEFAULT_WORKTREES_AGE_MS : Number.isFinite(envWorktrees) && envWorktrees > 0 ? envWorktrees : 0;
+  return resolveHarnessRetention({
+    runIdFilter: scopeAll ? void 0 : runId,
+    worktreesAgeMs,
+    finalizeStaleRuns: true,
+    accountBytes: true
+  });
+}
+
+// src/cleanup.ts
+function resolvePaths(options = {}) {
+  const harnessRoot = options.harnessRoot ? resolveUserPath(options.harnessRoot) : resolveHarnessRoot();
+  const { worktreesDir } = options.harnessRoot ? { worktreesDir: path31.join(harnessRoot, "worktrees") } : getHarnessPaths();
+  const now = options.now ?? Date.now();
+  return { harnessRoot, worktreesDir, now };
+}
+function normalizeGuardSkip(skip) {
+  if (typeof skip === "string") return { reason: skip };
+  return skip;
+}
+function recordSkip(skips, pathValue, reason, detail) {
+  skips.push({ path: pathValue, reason, ...detail ? { detail } : {} });
+}
+function attachCandidateBytes(candidate, accountBytes) {
+  if (!accountBytes || candidate.bytes != null) return candidate;
+  return { ...candidate, bytes: directorySizeBytes(candidate.path) };
+}
+function tallySkipReasons(actions, skips) {
+  const counts = {};
+  for (const skip of skips) {
+    counts[skip.reason] = (counts[skip.reason] ?? 0) + 1;
+  }
+  for (const action of actions) {
+    if (action.skipReason) {
+      counts[action.skipReason] = (counts[action.skipReason] ?? 0) + 1;
+    }
+  }
+  return counts;
+}
+function runHarnessCleanup(options = {}) {
+  const retention = resolveHarnessRetention(options);
+  const paths = resolvePaths(options);
+  const finalizedRuns = retention.finalizeStaleRuns ? finalizeStaleRuns().map((f) => ({ runId: f.runId, from: f.from, to: f.to })) : [];
+  const index = buildWorktreeIndex();
+  const scanOpts = {
+    harnessRoot: paths.harnessRoot,
+    worktreesDir: paths.worktreesDir,
+    nodeModulesAgeMs: retention.nodeModulesAgeMs,
+    worktreesAgeMs: retention.worktreesAgeMs,
+    includeOrphans: retention.includeOrphans,
+    runIdFilter: retention.runIdFilter,
+    index,
+    now: paths.now
+  };
+  const skips = [];
+  const actions = [];
+  for (const raw of scanNodeModulesCandidates(scanOpts)) {
+    const candidate = attachCandidateBytes(raw, retention.accountBytes);
+    const pathSkip = isHarnessNodeModulesPath(candidate.path, paths.harnessRoot, paths.worktreesDir);
+    if (pathSkip) {
+      recordSkip(skips, candidate.path, pathSkip);
+      actions.push({ ...candidate, executed: false, skipped: true, skipReason: pathSkip });
+      continue;
+    }
+    const worktreePath = path31.resolve(candidate.path, "..");
+    const indexed = index.get(worktreePath) ?? null;
+    const guardReason = skipNodeModulesRemoval({
+      indexed,
+      includeOrphans: retention.includeOrphans,
+      nodeModulesAgeMs: retention.nodeModulesAgeMs,
+      ageMs: candidate.ageMs
+    });
+    if (guardReason) {
+      recordSkip(skips, candidate.path, guardReason);
+      actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
+      continue;
+    }
+    actions.push(removeNodeModules(candidate, retention.execute));
+  }
+  for (const raw of scanWorktreeCandidates(scanOpts)) {
+    const candidate = attachCandidateBytes(raw, retention.accountBytes);
+    const indexed = index.get(path31.resolve(candidate.path)) ?? null;
+    const orphanSafety = indexed ? null : assessOrphanWorktreeSafety({
+      worktreePath: candidate.path,
+      harnessRoot: paths.harnessRoot,
+      runId: candidate.runId,
+      workerName: candidate.worker,
+      now: paths.now
+    });
+    const guardSkip = skipWorktreeRemoval({
+      indexed,
+      worktreePath: path31.resolve(candidate.path),
+      includeOrphans: retention.includeOrphans,
+      worktreesAgeMs: retention.worktreesAgeMs,
+      ageMs: candidate.ageMs,
+      orphanSafety,
+      worktreeRemovalGuard: options.worktreeRemovalGuard
+    });
+    if (guardSkip) {
+      const { reason: guardReason, detail: guardDetail } = normalizeGuardSkip(guardSkip);
+      recordSkip(skips, candidate.path, guardReason, guardDetail);
+      actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
+      continue;
+    }
+    actions.push(removeWorktree(candidate, retention.execute));
+  }
+  let candidateBytes = 0;
+  let reclaimableBytes = 0;
+  let removedBytes = 0;
+  let removedPaths = 0;
+  let skippedPaths = 0;
+  for (const action of actions) {
+    if (action.bytes) candidateBytes += action.bytes;
+    if (!action.skipped && !action.executed && action.bytes) reclaimableBytes += action.bytes;
+    if (action.executed) {
+      removedPaths += 1;
+      removedBytes += action.bytes ?? 0;
+    } else if (action.skipped) {
+      skippedPaths += 1;
+      if (action.skipReason === "dry_run" && action.bytes) reclaimableBytes += action.bytes;
+    }
+  }
+  const storage = retention.accountBytes ? harnessStorageSnapshot({ harnessRoot: paths.harnessRoot, now: paths.now }) : void 0;
+  return {
+    harnessRoot: paths.harnessRoot,
+    dryRun: !retention.execute,
+    execute: retention.execute,
+    nodeModulesAgeMs: retention.nodeModulesAgeMs,
+    worktreesAgeMs: retention.worktreesAgeMs,
+    includeOrphans: retention.includeOrphans,
+    scannedAt: new Date(paths.now).toISOString(),
+    finalizedRuns,
+    actions,
+    skips,
+    totals: {
+      candidateBytes,
+      reclaimableBytes,
+      removedBytes,
+      removedPaths,
+      skippedPaths,
+      skipReasons: tallySkipReasons(actions, skips)
+    },
+    ...storage ? { storage } : {}
+  };
+}
+function runPipelineHarnessCleanup(runId) {
+  const retention = resolvePipelineHarnessRetention(runId);
+  return runHarnessCleanup({
+    execute: retention.execute,
+    finalizeStaleRuns: retention.finalizeStaleRuns,
+    accountBytes: retention.accountBytes,
+    nodeModulesAgeMs: retention.nodeModulesAgeMs,
+    worktreesAgeMs: retention.worktreesAgeMs,
+    includeOrphans: retention.includeOrphans,
+    runIdFilter: retention.runIdFilter
+  });
+}
+function isPipelineCleanupEnabled() {
+  return process.env.KYNVER_PIPELINE_CLEANUP !== "0";
+}
+
+// src/cli.ts
+import { mkdirSync as mkdirSync7, realpathSync } from "node:fs";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+
+// src/discard-disposable.ts
+import { existsSync as existsSync23, rmSync as rmSync2 } from "node:fs";
+import path32 from "node:path";
+function normalizeRelativePath2(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").trim();
+  if (!normalized || normalized.startsWith("/") || normalized.includes("..")) {
+    throw new Error(`unsafe path: ${value}`);
+  }
+  return normalized;
+}
+function parsePathsArg(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return [];
+  return raw.split(",").map((p) => p.trim()).filter(Boolean);
+}
+function discardDisposableArtifacts(args) {
+  const worker = loadWorker(String(args.run), String(args.name));
+  const paths = [
+    ...parsePathsArg(args.path),
+    ...Array.isArray(args.paths) ? args.paths : []
+  ];
+  if (paths.length === 0) {
+    return { ok: false, removed: [], reason: "requires at least one --path" };
+  }
+  const worktreeRoot = path32.resolve(worker.worktreePath);
+  const removed = [];
+  for (const raw of paths) {
+    const rel = normalizeRelativePath2(raw);
+    const abs = path32.resolve(worktreeRoot, rel);
+    if (!abs.startsWith(worktreeRoot + path32.sep) && abs !== worktreeRoot) {
+      return { ok: false, removed, reason: `path escapes worktree: ${raw}` };
+    }
+    if (!existsSync23(abs)) {
+      return { ok: false, removed, reason: `path not found: ${raw}` };
+    }
+    rmSync2(abs, { recursive: true, force: true });
+    removed.push(rel);
+  }
+  const prior = Array.isArray(worker.disposableArtifactsRemoved) ? worker.disposableArtifactsRemoved.filter((p) => typeof p === "string") : [];
+  worker.disposableArtifactsRemoved = [.../* @__PURE__ */ new Set([...prior, ...removed])];
+  saveWorker(worker.runId, worker);
+  const status = computeWorkerStatus(worker);
+  return {
+    ok: true,
+    removed,
+    ...status.changedFiles.length ? { reason: "worktree still has other changes" } : {}
+  };
+}
+function discardDisposableCli(args) {
+  const result = discardDisposableArtifacts(args);
+  console.log(JSON.stringify(result, null, 2));
+  if (!result.ok) process.exit(1);
+}
+
+// src/pipeline-tick.ts
+import path36 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 path33 from "node:path";
+var STALE_RECONCILE_HEARTBEAT_MS = 15 * 60 * 1e3;
+function staleReconcileDisabled() {
+  return process.env.KYNVER_NO_STALE_CLEANUP === "1";
+}
+function reconcileStaleWorkers() {
+  if (staleReconcileDisabled()) {
+    return { workers: [], finalizedRuns: finalizeStaleRuns() };
+  }
+  const outcomes = [];
+  const now = Date.now();
+  for (const run of listRunRecords()) {
+    for (const name of Object.keys(run.workers || {})) {
+      const workerPath = path33.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const worker = readJson(workerPath, void 0);
+      if (!worker || worker.status !== "running") {
+        outcomes.push({
+          runId: run.id,
+          worker: name,
+          action: "skipped",
+          reason: worker ? `worker status is ${worker.status}` : "worker.json missing"
+        });
+        continue;
+      }
+      const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
+      if (status.finalResult) {
+        if (worker.status === "running") {
+          const nextStatus = status.attention.state === "blocked" ? "blocked" : status.attention.state === "done" || status.status === "done" ? "done" : "exited";
+          worker.status = nextStatus;
+          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+          worker.reconcileReason = "synced finished worker record after terminal stdout/heartbeat";
+          saveWorker(run.id, worker);
+          outcomes.push({
+            runId: run.id,
+            worker: name,
+            action: "marked_exited",
+            reason: worker.reconcileReason
+          });
+        } else {
+          outcomes.push({ runId: run.id, worker: name, action: "skipped", reason: "final result present" });
+        }
+        continue;
+      }
+      if (!status.alive) {
+        const nextStatus = status.attention.state === "blocked" ? "blocked" : status.status === "done" ? "done" : "exited";
+        worker.status = nextStatus;
+        worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+        worker.reconcileReason = status.attention.reason;
+        saveWorker(run.id, worker);
+        outcomes.push({
+          runId: run.id,
+          worker: name,
+          action: "marked_exited",
+          reason: status.attention.reason
+        });
+        continue;
+      }
+      if (status.attention.state === "stale" && worker.pid && isPidAlive(worker.pid)) {
+        const hbMs = status.lastHeartbeatAt ? Date.parse(status.lastHeartbeatAt) : NaN;
+        const actMs = status.lastActivityAt ? Date.parse(status.lastActivityAt) : NaN;
+        const hbStale = !Number.isFinite(hbMs) || now - hbMs > STALE_RECONCILE_HEARTBEAT_MS;
+        const actStale = Number.isFinite(actMs) && now - actMs > STALE_MS;
+        if (hbStale && actStale) {
+          killWorkerProcess(worker.pid, "SIGTERM");
+          worker.status = "exited";
+          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+          worker.reconcileReason = `reconciled stale worker: ${status.attention.reason}`;
+          saveWorker(run.id, worker);
+          outcomes.push({
+            runId: run.id,
+            worker: name,
+            action: "killed_stale",
+            reason: status.attention.reason
+          });
+          continue;
+        }
+      }
+      outcomes.push({
+        runId: run.id,
+        worker: name,
+        action: "skipped",
+        reason: status.attention.reason
+      });
+    }
+  }
+  return { workers: outcomes, finalizedRuns: finalizeStaleRuns() };
+}
+function reconcileRunsCli() {
+  const result = reconcileStaleWorkers();
+  const markedExited = result.workers.filter((w) => w.action === "marked_exited").length;
+  const killedStale = result.workers.filter((w) => w.action === "killed_stale").length;
+  const skipped = result.workers.filter((w) => w.action === "skipped").length;
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        workers: { markedExited, killedStale, skipped, total: result.workers.length },
+        finalizedRuns: result.finalizedRuns.length,
+        details: { workers: result.workers, finalizedRuns: result.finalizedRuns }
+      },
+      null,
+      2
+    )
+  );
 }
 
-// src/cleanup.ts
-function resolvePaths(options = {}) {
-  const harnessRoot = options.harnessRoot ? resolveUserPath(options.harnessRoot) : resolveHarnessRoot();
-  const { worktreesDir } = options.harnessRoot ? { worktreesDir: path30.join(harnessRoot, "worktrees") } : getHarnessPaths();
-  const now = options.now ?? Date.now();
-  return { harnessRoot, worktreesDir, now };
-}
-function recordSkip(skips, pathValue, reason, detail) {
-  skips.push({ path: pathValue, reason, ...detail ? { detail } : {} });
-}
-function attachCandidateBytes(candidate, accountBytes) {
-  if (!accountBytes || candidate.bytes != null) return candidate;
-  return { ...candidate, bytes: directorySizeBytes(candidate.path) };
-}
-function tallySkipReasons(actions, skips) {
-  const counts = {};
-  for (const skip of skips) {
-    counts[skip.reason] = (counts[skip.reason] ?? 0) + 1;
-  }
-  for (const action of actions) {
-    if (action.skipReason) {
-      counts[action.skipReason] = (counts[action.skipReason] ?? 0) + 1;
-    }
-  }
-  return counts;
+// src/plan-progress-daemon-sync.ts
+import path34 from "node:path";
+
+// src/plan-progress-sync.ts
+async function syncPlanProgress(args) {
+  const base = resolveBaseUrl(args.baseUrl);
+  const secret = await resolveCallbackSecretWithMint(args.secret, args.agentOsId, { baseUrl: base });
+  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(args.agentOsId)}/tasks/${encodeURIComponent(args.taskId)}/plan-progress-sync`;
+  const res = await postJsonWithCredentialRefresh(url, secret, {
+    phase: args.phase,
+    taskId: args.taskId,
+    blocker: args.blocker,
+    artifact: args.artifact
+  }, { agentOsId: args.agentOsId, baseUrl: base });
+  return { ok: res.ok, status: res.status, response: res.response };
 }
-function runHarnessCleanup(options = {}) {
-  const retention = resolveHarnessRetention(options);
-  const paths = resolvePaths(options);
-  const finalizedRuns = retention.finalizeStaleRuns ? finalizeStaleRuns().map((f) => ({ runId: f.runId, from: f.from, to: f.to })) : [];
-  const index = buildWorktreeIndex();
-  const scanOpts = {
-    harnessRoot: paths.harnessRoot,
-    worktreesDir: paths.worktreesDir,
-    nodeModulesAgeMs: retention.nodeModulesAgeMs,
-    worktreesAgeMs: retention.worktreesAgeMs,
-    includeOrphans: retention.includeOrphans,
-    runIdFilter: retention.runIdFilter,
-    index,
-    now: paths.now
-  };
-  const skips = [];
-  const actions = [];
-  for (const raw of scanNodeModulesCandidates(scanOpts)) {
-    const candidate = attachCandidateBytes(raw, retention.accountBytes);
-    const pathSkip = isHarnessNodeModulesPath(candidate.path, paths.harnessRoot, paths.worktreesDir);
-    if (pathSkip) {
-      recordSkip(skips, candidate.path, pathSkip);
-      actions.push({ ...candidate, executed: false, skipped: true, skipReason: pathSkip });
-      continue;
-    }
-    const worktreePath = path30.resolve(candidate.path, "..");
-    const indexed = index.get(worktreePath) ?? null;
-    const guardReason = skipNodeModulesRemoval({
-      indexed,
-      includeOrphans: retention.includeOrphans,
-      nodeModulesAgeMs: retention.nodeModulesAgeMs,
-      ageMs: candidate.ageMs
-    });
-    if (guardReason) {
-      recordSkip(skips, candidate.path, guardReason);
-      actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
+
+// src/plan-progress-daemon-sync.ts
+async function syncActiveWorkerPlanProgress(runId, args) {
+  const run = loadRun(runId);
+  const agentOsId = String(args.agentOsId || "");
+  if (!agentOsId) return [];
+  const outcomes = [];
+  for (const name of Object.keys(run.workers || {})) {
+    const worker = readJson(
+      path34.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
+    );
+    if (!worker?.dispatched || !worker.taskId) continue;
+    const status = computeWorkerStatus(worker);
+    if (!status.heartbeatBlocker) continue;
+    if (worker.lastSyncedHeartbeatBlocker === status.heartbeatBlocker) {
+      outcomes.push({ worker: name, phase: "heartbeat_blocker", ok: true, skipped: true });
       continue;
     }
-    actions.push(removeNodeModules(candidate, retention.execute));
-  }
-  for (const raw of scanWorktreeCandidates(scanOpts)) {
-    const candidate = attachCandidateBytes(raw, retention.accountBytes);
-    const indexed = index.get(path30.resolve(candidate.path)) ?? null;
-    const guardReason = skipWorktreeRemoval({
-      indexed,
-      includeOrphans: retention.includeOrphans,
-      worktreesAgeMs: retention.worktreesAgeMs,
-      ageMs: candidate.ageMs
+    const res = await syncPlanProgress({
+      agentOsId,
+      taskId: worker.taskId,
+      phase: "heartbeat_blocker",
+      blocker: status.heartbeatBlocker,
+      baseUrl: args.baseUrl ? String(args.baseUrl) : void 0,
+      secret: args.secret ? String(args.secret) : void 0
     });
-    if (guardReason) {
-      recordSkip(skips, candidate.path, guardReason);
-      actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
-      continue;
+    if (res.ok) {
+      worker.lastSyncedHeartbeatBlocker = status.heartbeatBlocker;
+      saveWorker(run.id, worker);
     }
-    actions.push(removeWorktree(candidate, retention.execute));
+    outcomes.push({ worker: name, phase: "heartbeat_blocker", ok: res.ok });
   }
-  let candidateBytes = 0;
-  let reclaimableBytes = 0;
-  let removedBytes = 0;
-  let removedPaths = 0;
-  let skippedPaths = 0;
-  for (const action of actions) {
-    if (action.bytes) candidateBytes += action.bytes;
-    if (!action.skipped && !action.executed && action.bytes) reclaimableBytes += action.bytes;
-    if (action.executed) {
-      removedPaths += 1;
-      removedBytes += action.bytes ?? 0;
-    } else if (action.skipped) {
-      skippedPaths += 1;
-      if (action.skipReason === "dry_run" && action.bytes) reclaimableBytes += action.bytes;
+  return outcomes;
+}
+
+// src/workspace-runtime-config.ts
+async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
+  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+  const secret = await resolveCallbackSecretWithMint(args.secret ? String(args.secret) : void 0, agentOsId, { baseUrl: base });
+  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/runtime`;
+  try {
+    const res = await getJson(url, secret);
+    if (!res.ok) return null;
+    const body = res.response;
+    const raw = body?.preferences?.maxConcurrentWorkers;
+    if (raw === null || raw === void 0) {
+      return { maxConcurrentWorkers: null };
     }
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0) return { maxConcurrentWorkers: null };
+    return { maxConcurrentWorkers: Math.floor(n) };
+  } catch {
+    return null;
   }
-  return {
-    harnessRoot: paths.harnessRoot,
-    dryRun: !retention.execute,
-    execute: retention.execute,
-    nodeModulesAgeMs: retention.nodeModulesAgeMs,
-    worktreesAgeMs: retention.worktreesAgeMs,
-    includeOrphans: retention.includeOrphans,
-    scannedAt: new Date(paths.now).toISOString(),
-    finalizedRuns,
-    actions,
-    skips,
-    totals: {
-      candidateBytes,
-      reclaimableBytes,
-      removedBytes,
-      removedPaths,
-      skippedPaths,
-      skipReasons: tallySkipReasons(actions, skips)
-    }
-  };
-}
-function runPipelineHarnessCleanup(runId) {
-  const retention = resolvePipelineHarnessRetention(runId);
-  return runHarnessCleanup({
-    execute: retention.execute,
-    finalizeStaleRuns: retention.finalizeStaleRuns,
-    accountBytes: retention.accountBytes,
-    nodeModulesAgeMs: retention.nodeModulesAgeMs,
-    worktreesAgeMs: retention.worktreesAgeMs,
-    includeOrphans: retention.includeOrphans,
-    runIdFilter: retention.runIdFilter
-  });
-}
-function isPipelineCleanupEnabled() {
-  return process.env.KYNVER_PIPELINE_CLEANUP !== "0";
 }
 
 // src/installed-package-versions.ts
 import { readFile } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import path31 from "node:path";
+import path35 from "node:path";
 var MANAGED_PACKAGES = [
   "@kynver-app/runtime",
   "@kynver-app/openclaw-agent-os",
@@ -5683,12 +6333,12 @@ function unique(values) {
 }
 function moduleRoots() {
   const home = homedir6();
-  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path31.join(home, ".openclaw", "npm");
-  const npmGlobalRoot = trim(process.env.KYNVER_NPM_GLOBAL_ROOT) ?? trim(process.env.KYNVER_NPM_GLOBAL_MODULES_ROOT) ?? (trim(process.env.NPM_CONFIG_PREFIX) ? path31.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path31.join(home, ".npm-global", "lib", "node_modules"));
+  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path35.join(home, ".openclaw", "npm");
+  const npmGlobalRoot = trim(process.env.KYNVER_NPM_GLOBAL_ROOT) ?? trim(process.env.KYNVER_NPM_GLOBAL_MODULES_ROOT) ?? (trim(process.env.NPM_CONFIG_PREFIX) ? path35.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path35.join(home, ".npm-global", "lib", "node_modules"));
   return unique([
-    path31.join(openClawPrefix, "lib", "node_modules"),
-    path31.join(openClawPrefix, "node_modules"),
-    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path31.join(npmGlobalRoot, "lib", "node_modules")
+    path35.join(openClawPrefix, "lib", "node_modules"),
+    path35.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path35.join(npmGlobalRoot, "lib", "node_modules")
   ]);
 }
 async function readVersion(packageJsonPath) {
@@ -5704,7 +6354,7 @@ async function collectInstalledPackageVersions(observedAt = (/* @__PURE__ */ new
   const out = {};
   for (const packageName of MANAGED_PACKAGES) {
     for (const root of roots) {
-      const packageJsonPath = path31.join(root, packageName, "package.json");
+      const packageJsonPath = path35.join(root, packageName, "package.json");
       const version = await readVersion(packageJsonPath);
       if (!version) continue;
       out[packageName] = { version, observedAt, path: packageJsonPath };
@@ -5720,7 +6370,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path32.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path36.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -5862,7 +6512,7 @@ async function runDaemon(args) {
 }
 
 // src/plan-progress.ts
-import path33 from "node:path";
+import path37 from "node:path";
 
 // src/bounded-build/constants.ts
 var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
@@ -5900,7 +6550,7 @@ function formatNodeOptionsFlag(mb = resolveNodeOldSpaceSizeMb()) {
 }
 
 // src/bounded-build/systemd-wrap.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 var systemdAvailableCache;
 function isSystemdRunAvailable() {
   if (process.env.KYNVER_BUILD_SKIP_SYSTEMD === "1" || process.env.KYNVER_BUILD_SKIP_SYSTEMD === "true") {
@@ -5911,7 +6561,7 @@ function isSystemdRunAvailable() {
     systemdAvailableCache = false;
     return false;
   }
-  const res = spawnSync3("systemd-run", ["--version"], { encoding: "utf8", stdio: ["ignore", "ignore", "pipe"] });
+  const res = spawnSync4("systemd-run", ["--version"], { encoding: "utf8", stdio: ["ignore", "ignore", "pipe"] });
   systemdAvailableCache = res.status === 0;
   return systemdAvailableCache;
 }
@@ -5935,7 +6585,7 @@ function buildSystemdRunArgv(opts) {
 }
 
 // src/bounded-build/admission.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
 function positiveInt3(value, fallback) {
   const n = Number(value);
   if (!Number.isFinite(n) || n <= 0) return fallback;
@@ -5971,7 +6621,7 @@ function assessBuildAdmission(opts = {}) {
 }
 function sleepMs2(ms) {
   if (ms <= 0) return;
-  spawnSync4(process.execPath, ["-e", `const d=Date.now()+${Math.floor(ms)};while(Date.now()<d);`], {
+  spawnSync5(process.execPath, ["-e", `const d=Date.now()+${Math.floor(ms)};while(Date.now()<d);`], {
     stdio: "ignore"
   });
 }
@@ -5992,7 +6642,7 @@ function waitForBuildAdmission(timeoutMs, pollMs = 2e3, opts = {}) {
 }
 
 // src/bounded-build/exec.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 function envArgv(env) {
   const out = [];
   for (const [key, value] of Object.entries(env)) {
@@ -6002,7 +6652,7 @@ function envArgv(env) {
   return out;
 }
 function runSpawn(argv, opts) {
-  const res = spawnSync5(argv[0], argv.slice(1), {
+  const res = spawnSync6(argv[0], argv.slice(1), {
     cwd: opts.cwd,
     env: opts.env,
     encoding: "utf8",
@@ -6148,7 +6798,7 @@ async function emitPlanProgress(args) {
 }
 function verifyPlanLocal(args) {
   const worktree = required(args.worktree ? String(args.worktree) : void 0, "worktree");
-  const cwd = path33.resolve(worktree);
+  const cwd = path37.resolve(worktree);
   const summary = runHarnessVerifyCommands(cwd);
   const emitJson = args.json === true || args.json === "true";
   const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
@@ -6197,9 +6847,9 @@ async function verifyPlan(args) {
 }
 
 // src/harness-verify-cli.ts
-import path34 from "node:path";
+import path38 from "node:path";
 function runHarnessVerifyCli(args) {
-  const cwd = path34.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const cwd = path38.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
   const emitJson = args.json === true || args.json === "true" || args.emitJson === true || args.emitJson === "true";
   const commands = [];
   const rawCmd = args.command;
@@ -6243,7 +6893,7 @@ function runHarnessVerifyCli(args) {
 }
 
 // src/plan-persist-cli.ts
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 var OPERATIONS = ["create", "add_version", "update_metadata"];
 var FAILURE_KINDS = [
   "approval_guard",
@@ -6255,7 +6905,7 @@ var FAILURE_KINDS = [
 function readBodyArg(args) {
   const bodyFile = args.bodyFile ? String(args.bodyFile) : void 0;
   if (bodyFile) {
-    return { body: readFileSync9(bodyFile, "utf8"), bodyPathHint: bodyFile };
+    return { body: readFileSync11(bodyFile, "utf8"), bodyPathHint: bodyFile };
   }
   const inline = args.body ? String(args.body) : void 0;
   if (inline) return { body: inline };
@@ -6345,7 +6995,7 @@ function runCleanupCli(args) {
 }
 
 // src/monitor/monitor.service.ts
-import path36 from "node:path";
+import path40 from "node:path";
 
 // src/monitor/monitor.classify.ts
 function expectedLeaseOwner(runId) {
@@ -6401,11 +7051,11 @@ function classifyWorkerHealth(input) {
 }
 
 // src/monitor/monitor.store.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync6, readdirSync as readdirSync7, unlinkSync as unlinkSync2 } from "node:fs";
-import path35 from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync6, readdirSync as readdirSync8, unlinkSync as unlinkSync2 } from "node:fs";
+import path39 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path35.join(harnessRoot, "monitors");
+  const dir = path39.join(harnessRoot, "monitors");
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
@@ -6413,7 +7063,7 @@ function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path35.join(monitorsDir(), `${monitorId}.json`);
+  return path39.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -6423,18 +7073,18 @@ function saveMonitorSession(session) {
 }
 function deleteMonitorSession(monitorId) {
   const file = monitorPath(monitorId);
-  if (!existsSync19(file)) return false;
+  if (!existsSync24(file)) return false;
   unlinkSync2(file);
   return true;
 }
 function listMonitorSessions() {
   const dir = monitorsDir();
-  if (!existsSync19(dir)) return [];
+  if (!existsSync24(dir)) return [];
   const entries = [];
-  for (const name of readdirSync7(dir)) {
+  for (const name of readdirSync8(dir)) {
     if (!name.endsWith(".json")) continue;
     const session = readJson(
-      path35.join(dir, name),
+      path39.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -6525,7 +7175,7 @@ async function fetchTaskLeasesForWorkers(input) {
 // src/monitor/monitor.service.ts
 function workerRecord2(runId, name) {
   return readJson(
-    path36.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path40.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -6727,18 +7377,18 @@ async function runMonitorLoop(args) {
 
 // src/monitor/monitor-spawn.ts
 import { spawn as spawn4 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync20, openSync as openSync4 } from "node:fs";
-import path37 from "node:path";
+import { closeSync as closeSync4, existsSync as existsSync25, openSync as openSync4 } from "node:fs";
+import path41 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path37.join(fileURLToPath4(new URL(".", import.meta.url)), "..", "cli.js");
+  return path41.join(fileURLToPath4(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
-  if (!existsSync20(cliPath)) return void 0;
+  if (!existsSync25(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path37.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path41.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
     logFd = openSync4(logPath, "a");
@@ -6858,16 +7508,16 @@ async function monitorTickCli(args) {
 }
 
 // src/doctor/runtime-takeover.ts
-import path39 from "node:path";
+import path43 from "node:path";
 
 // src/doctor/runtime-takeover.probes.ts
-import { accessSync, constants, existsSync as existsSync21, readFileSync as readFileSync10 } from "node:fs";
+import { accessSync, constants, existsSync as existsSync26, readFileSync as readFileSync12 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import path38 from "node:path";
-import { spawnSync as spawnSync6 } from "node:child_process";
+import path42 from "node:path";
+import { spawnSync as spawnSync7 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
-    const res = spawnSync6(bin, args, { encoding: "utf8" });
+    const res = spawnSync7(bin, args, { encoding: "utf8" });
     const stdout = (res.stdout || "").trim();
     const stderr = (res.stderr || "").trim();
     const ok = res.status === 0;
@@ -6892,7 +7542,7 @@ function tokenPrefix(token) {
   return trimmed.length <= 12 ? `${trimmed}\u2026` : `${trimmed.slice(0, 12)}\u2026`;
 }
 function isWritable(target) {
-  if (!existsSync21(target)) return false;
+  if (!existsSync26(target)) return false;
   try {
     accessSync(target, constants.W_OK);
     return true;
@@ -6905,15 +7555,15 @@ var defaultRuntimeTakeoverProbes = {
   commandOnPath: (bin) => captureCommand(process.platform === "win32" ? "where" : "which", [bin]),
   kynverVersion: (bin) => captureCommand(bin, ["--version"]),
   loadConfig: () => loadUserConfig(),
-  configFilePath: () => path38.join(homedir7(), ".kynver", "config.json"),
-  credentialsFilePath: () => path38.join(homedir7(), ".kynver", "credentials"),
+  configFilePath: () => path42.join(homedir7(), ".kynver", "config.json"),
+  credentialsFilePath: () => path42.join(homedir7(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path38.join(homedir7(), ".kynver", "credentials");
-    if (!existsSync21(credPath)) {
+    const credPath = path42.join(homedir7(), ".kynver", "credentials");
+    if (!existsSync26(credPath)) {
       return { hasApiKey: false };
     }
     try {
-      const parsed = JSON.parse(readFileSync10(credPath, "utf8"));
+      const parsed = JSON.parse(readFileSync12(credPath, "utf8"));
       return {
         hasApiKey: Boolean(parsed.apiKey?.trim()),
         runnerTokenPrefix: tokenPrefix(parsed.runnerToken),
@@ -6932,6 +7582,7 @@ var defaultRuntimeTakeoverProbes = {
     kynverHarnessRoot: process.env.KYNVER_HARNESS_ROOT?.trim() || void 0,
     opusHarnessRoot: process.env.OPUS_HARNESS_ROOT?.trim() || void 0,
     kynverSchedulerProvider: process.env.KYNVER_SCHEDULER_PROVIDER?.trim() || void 0,
+    openclawCronStorePath: Boolean(process.env.OPENCLAW_CRON_STORE_PATH?.trim()),
     qstashTokenPresent: Boolean(process.env.QSTASH_TOKEN?.trim()),
     kynverHostedDeployment: (() => {
       const v = process.env.KYNVER_HOSTED_DEPLOYMENT?.trim().toLowerCase();
@@ -6939,18 +7590,59 @@ var defaultRuntimeTakeoverProbes = {
     })()
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path38.join(homedir7(), ".openclaw", "harness"),
-  pathExists: (target) => existsSync21(target),
+  legacyOpenclawHarnessRoot: () => path42.join(homedir7(), ".openclaw", "harness"),
+  pathExists: (target) => existsSync26(target),
   pathWritable: (target) => isWritable(target),
   vercelVersion: () => captureCommand("vercel", ["--version"]),
   vercelWhoami: () => captureCommand("vercel", ["whoami"])
 };
 
 // src/doctor/runtime-takeover-scheduler.ts
+function hasLocalOpenClawDependency(env, ctx) {
+  return env.kynverSchedulerProvider === "kynver-cron" || env.kynverSchedulerProvider === "openclaw-cron" || ctx.deploymentSchedulerProvider === "kynver-cron" || ctx.deploymentSchedulerProvider === "openclaw-cron" || Boolean(env.openclawCronStorePath);
+}
+function hasQstashCutover(env, ctx) {
+  return env.kynverSchedulerProvider === "qstash" || ctx.deploymentSchedulerProvider === "qstash";
+}
 function check(partial) {
   return partial;
 }
 function assessRuntimeTakeoverScheduler(env, ctx) {
+  const schedulerDetails = {
+    schedulerProvider: env.kynverSchedulerProvider ?? null,
+    deploymentSchedulerProvider: ctx.deploymentSchedulerProvider ?? null,
+    openclawCronStorePath: Boolean(env.openclawCronStorePath)
+  };
+  if (hasQstashCutover(env, ctx) && !hasLocalOpenClawDependency(env, ctx)) {
+    const source = env.kynverSchedulerProvider === "qstash" ? "KYNVER_SCHEDULER_PROVIDER=qstash on this host" : "deploymentSchedulerProvider=qstash in ~/.kynver/config.json";
+    return check({
+      id: "hotspot_openclaw_scheduler",
+      label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
+      status: "pass",
+      summary: `AgentOS scheduler cut over to QStash (${source})`,
+      details: schedulerDetails
+    });
+  }
+  if (hasLocalOpenClawDependency(env, ctx)) {
+    const parts = [];
+    if (env.kynverSchedulerProvider === "openclaw-cron") {
+      parts.push("KYNVER_SCHEDULER_PROVIDER=openclaw-cron");
+    }
+    if (ctx.deploymentSchedulerProvider === "openclaw-cron") {
+      parts.push("deploymentSchedulerProvider=openclaw-cron in config");
+    }
+    if (env.openclawCronStorePath) {
+      parts.push("OPENCLAW_CRON_STORE_PATH set (local cron bridge)");
+    }
+    return check({
+      id: "hotspot_openclaw_scheduler",
+      label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
+      status: "warn",
+      summary: `OpenClaw local cron still active (${parts.join("; ")})`,
+      remediation: "On the Kynver deployment: set KYNVER_SCHEDULER_PROVIDER=qstash with QSTASH_TOKEN configured. On user runners: unset KYNVER_SCHEDULER_PROVIDER and OPENCLAW_CRON_STORE_PATH; set deploymentSchedulerProvider to qstash in ~/.kynver/config.json after Vercel env is updated.",
+      details: schedulerDetails
+    });
+  }
   const runnerOpenclaw = env.kynverSchedulerProvider === "openclaw-cron";
   const runnerQstash = env.kynverSchedulerProvider === "qstash";
   const hostedDeployment = Boolean(env.qstashTokenPresent) || Boolean(env.kynverHostedDeployment);
@@ -7227,8 +7919,8 @@ function assessVercelCli(probes) {
 }
 function assessHarnessDirs(probes) {
   const harnessRoot = probes.harnessRoot();
-  const runsDir = path39.join(harnessRoot, "runs");
-  const worktreesDir = path39.join(harnessRoot, "worktrees");
+  const runsDir = path43.join(harnessRoot, "runs");
+  const worktreesDir = path43.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -7337,7 +8029,8 @@ function assessOpenclawHotspots(probes) {
     assessRuntimeTakeoverScheduler(env, {
       agentOsId: targetAgentOsId ?? null,
       apiBaseUrl: config.apiBaseUrl?.trim() ?? env.kynverApiUrl ?? null,
-      hasScopedRunnerToken
+      hasScopedRunnerToken,
+      deploymentSchedulerProvider: config.deploymentSchedulerProvider === "qstash" || config.deploymentSchedulerProvider === "kynver-cron" || config.deploymentSchedulerProvider === "openclaw-cron" ? config.deploymentSchedulerProvider : void 0
     }),
     check2({
       id: "hotspot_lease_source_names",
@@ -7443,6 +8136,7 @@ function usage(code = 0) {
       "  kynver worker tail --run RUN_ID --name worker [--lines 40] [--raw]",
       "  kynver worker stop --run RUN_ID --name worker",
       "  kynver worker complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--task-id TASK_ID] [--base-url URL] [--secret SECRET]",
+      "  kynver worker discard-disposable --run RUN_ID --name worker --path scripts/helper.mjs[,other]",
       "  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 run reconcile",
       "  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]",
@@ -7452,6 +8146,7 @@ function usage(code = 0) {
       "  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] [--skip-finalize]",
+      "    --include-orphans also scans whole worktree directories (<harnessRoot>/worktrees/<runId>/<workerId>/) that no run/worker.json references; orphans pass salvage gates (recent heartbeat, dirty git, ahead of origin/main) before removal.",
       "  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]",
@@ -7512,6 +8207,7 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "worker" && action === "tail") return tailWorker(args);
   if (scope === "worker" && action === "stop") return stopWorker(args);
   if (scope === "worker" && action === "complete") return void await completeWorker(args);
+  if (scope === "worker" && action === "discard-disposable") return discardDisposableCli(args);
   if (scope === "worker" && action === "auto-complete") return void await autoCompleteWorkerCli(args);
   if (scope === "monitor" && action === "start") {
     const result = await startMonitorCli(args);
@@ -7650,7 +8346,7 @@ function pickVercelStatusContext(statuses) {
 }
 
 // src/vercel/vercel-evidence.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 var DEFAULT_INSPECT_WAIT_SECONDS = 120;
 function mapGitHubStateToEvidence(state) {
   if (state === "success") return "ready";
@@ -7716,7 +8412,7 @@ function evidenceFromGitHubVercelStatus(statuses, options = {}) {
 }
 function defaultRunVercelInspect(target, waitSeconds) {
   const args = ["inspect", target, "--wait", String(waitSeconds)];
-  const result = spawnSync7("vercel", args, {
+  const result = spawnSync8("vercel", args, {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -7825,11 +8521,16 @@ function collectVercelEvidence(input) {
 export {
   DEFAULT_DISPATCH_LEASE_MS,
   DEFAULT_HARNESS_VERIFY_COMMANDS,
+  DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES,
+  DEFAULT_WSL_HOST_MOUNT,
+  DEFAULT_WSL_HOST_WARN_FREE_BYTES,
   FORBIDDEN_WORKER_ENV_KEYS,
   PACKAGE_VERSION,
+  applyProductionDatabaseToProcess,
   assessAutoCompleteEligibility,
   assessBuildAdmission,
   assessExitedWorkerSalvage,
+  assessOrphanWorktreeSafety,
   assessPrHandoffRequirement,
   assessWorkerLanding,
   assessWorkerLandingContract,
@@ -7862,6 +8563,7 @@ export {
   getHarnessPaths,
   getMonitorStatus,
   gitRepoRoot,
+  harnessStorageSnapshot,
   hashPlanBody,
   isDashboardVercelUrl,
   isEngagementRequiredSkip,
@@ -7869,9 +8571,11 @@ export {
   isForbiddenWorkerEnvKey,
   isKynverMonorepoRoot,
   isLandingBlockedWorkerStatus,
+  isPipelineCleanupEnabled,
   isSystemdRunAvailable,
   isTerminalHeartbeatPhase,
   isVercelStatusContext,
+  isWslHost,
   landingContractAttentionReason,
   listForbiddenWorkerEnvKeys,
   listMonitors,
@@ -7882,6 +8586,7 @@ export {
   mergeNodeOptionsForBuildCheck,
   normalizeCursorModelAlias,
   observeRunnerDiskGate,
+  observeWslHostDisk,
   parseArgs,
   parseClaudeStream,
   parseHarnessStream,
@@ -7892,6 +8597,7 @@ export {
   postJson,
   preflightCursorModel,
   readMemAvailableBytes,
+  readProductionDbKeysFromEnvFile,
   reconcileRunsCli,
   reconcileStaleWorkers,
   redactHarness,
@@ -7901,12 +8607,16 @@ export {
   resolveCallbackSecretWithMint,
   resolveDefaultRepo,
   resolveHarnessRoot,
+  resolveProductionDatabaseUrl,
   resolveVercelInspectTarget,
   runBoundedBuildCheck,
   runDaemon,
+  runHarnessCleanup,
   runHarnessVerifyCommands,
   runMonitorTick,
+  runPipelineHarnessCleanup,
   runStatus,
+  safeDatabaseUrlHint,
   saveUserConfig,
   scrubClaudeEnv,
   scrubWorkerEnv,
@@ -7918,6 +8628,7 @@ export {
   summarizeEvent,
   summarizeNpmAuditReport,
   summarizeShellToolCallEvent,
+  summarizeWslRecoverySteps,
   sweepRun,
   tailWorker,
   terminalFinalResultFromHeartbeat,