@kynver-app/runtime 0.1.56 → 0.1.59

package/dist/cli.js

@@ -136,12 +136,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",
@@ -412,7 +414,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;
@@ -464,17 +466,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"
@@ -498,7 +500,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) {
@@ -661,6 +663,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
   };
@@ -704,18 +711,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 existsSync4, readFileSync as readFileSync4, 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 (!existsSync4(probe)) continue;
+      const text = readFileSync4(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 path43 = 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(path43);
+  } catch (error) {
+    return {
+      ok: false,
+      path: path43,
+      freeBytes: 0,
+      totalBytes: 0,
+      usedPercent: 100,
+      warnBelowBytes,
+      criticalBelowBytes,
+      reason: `Windows host disk probe failed at ${path43}: ${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 ${path43} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+  }
+  return {
+    ok,
+    path: path43,
+    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 path43 = 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(path43);
   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;
@@ -723,19 +800,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: path43,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -743,7 +823,8 @@ function observeRunnerDiskGate(input = {}) {
     criticalBelowBytes,
     maxUsedPercent,
     hardMaxUsedPercent,
-    reason
+    reason,
+    wslHost
   };
 }
 
@@ -751,7 +832,7 @@ function observeRunnerDiskGate(input = {}) {
 import os2 from "node:os";
 
 // src/bounded-build/meminfo.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 import os from "node:os";
 function readMemAvailableBytes(meminfoText) {
   if (meminfoText !== void 0) {
@@ -761,7 +842,7 @@ function readMemAvailableBytes(meminfoText) {
   }
   if (process.platform === "linux") {
     try {
-      const meminfo = readFileSync4("/proc/meminfo", "utf8");
+      const meminfo = readFileSync5("/proc/meminfo", "utf8");
       const match = meminfo.match(/^MemAvailable:\s+(\d+)\s*kB/m);
       if (match) return Number(match[1]) * 1024;
     } catch {
@@ -774,11 +855,11 @@ function readMemAvailableBytes(meminfoText) {
 import path7 from "node:path";
 
 // src/run-store.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "node:fs";
 import path6 from "node:path";
 
 // src/paths.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import path5 from "node:path";
 var LEGACY_ROOT = path5.join(homedir4(), ".openclaw", "harness");
@@ -788,8 +869,8 @@ function resolveHarnessRoot() {
   const configured = loadUserConfig().harnessRoot?.trim();
   if (configured) return resolveUserPath(configured);
   const kynverRoot = path5.join(homedir4(), ".kynver", "harness");
-  if (existsSync4(kynverRoot)) return kynverRoot;
-  if (existsSync4(LEGACY_ROOT)) return LEGACY_ROOT;
+  if (existsSync5(kynverRoot)) return kynverRoot;
+  if (existsSync5(LEGACY_ROOT)) return LEGACY_ROOT;
   return kynverRoot;
 }
 function getHarnessPaths() {
@@ -814,7 +895,7 @@ function loadRun(id) {
 }
 function listRunRecords() {
   const { runsDir } = getPaths();
-  if (!existsSync5(runsDir)) return [];
+  if (!existsSync6(runsDir)) return [];
   const runs = [];
   for (const entry of readdirSync2(runsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
@@ -846,7 +927,7 @@ function runDirectory(id) {
 }
 
 // src/heartbeat.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 var HEARTBEAT_FUTURE_SKEW_MS = 6e4;
 function isTerminalHeartbeatPhase(phase) {
   return phase === "complete";
@@ -865,10 +946,10 @@ function parseHeartbeat(file) {
     heartbeatBlocker: null,
     timestampAnomalies: []
   };
-  if (!existsSync6(file)) return result;
+  if (!existsSync7(file)) return result;
   const maxFutureMs = Date.now() + HEARTBEAT_FUTURE_SKEW_MS;
   const clampedTo = new Date(maxFutureMs).toISOString();
-  const lines = readFileSync5(file, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync6(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const entry = safeJson(line);
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
@@ -895,7 +976,7 @@ function parseHeartbeat(file) {
 }
 
 // src/stream.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
 
 // src/shell-command-outcome.ts
 var NPM_AUDIT_RE = /\bnpm\s+audit\b/i;
@@ -1099,8 +1180,8 @@ function parseHarnessStream(file) {
     error: null,
     lastShellOutcome: null
   };
-  if (!existsSync7(file)) return result;
-  const lines = readFileSync6(file, "utf8").split("\n").filter(Boolean);
+  if (!existsSync8(file)) return result;
+  const lines = readFileSync7(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const event = safeJson(line);
     if (!event) continue;
@@ -2123,7 +2204,7 @@ function hasLiveWorkerForTask(runId, taskId) {
 }
 
 // src/supervisor.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync3 } from "node:fs";
 import path14 from "node:path";
 
 // src/prompt.ts
@@ -2144,7 +2225,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.",
@@ -2171,7 +2252,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.",
@@ -2193,12 +2274,12 @@ function buildPrompt(input) {
 }
 
 // src/providers/cursor.ts
-import { closeSync as closeSync2, existsSync as existsSync9, openSync as openSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync10, 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 existsSync8, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync9, 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) {
@@ -2211,7 +2292,7 @@ function parseCursorVersionSortKey(versionName) {
 }
 function pickLatestCursorVersionDir(agentRoot) {
   const versionsRoot = path9.join(agentRoot, "versions");
-  if (!existsSync8(versionsRoot)) return null;
+  if (!existsSync9(versionsRoot)) return null;
   let bestDir = null;
   let bestKey = -1;
   for (const entry of readdirSync3(versionsRoot, { withFileTypes: true })) {
@@ -2227,14 +2308,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 (existsSync8(directNode) && existsSync8(directIndex)) {
+  if (existsSync9(directNode) && existsSync9(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 (!existsSync8(nodeExe) || !existsSync8(indexJs)) return null;
+  if (!existsSync9(nodeExe) || !existsSync9(indexJs)) return null;
   return { nodeExe, indexJs, versionDir };
 }
 
@@ -2252,7 +2333,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) && existsSync9(path10.join(path10.dirname(agentBin), "index.js"));
+    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync10(path10.join(path10.dirname(agentBin), "index.js"));
     const isDefaultShim = agentBin === "agent";
     if (isCursorWrapper || isBundledNode || isDefaultShim) {
       const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path10.dirname(agentBin)) : isBundledNode ? {
@@ -2279,7 +2360,7 @@ function resolveAgentBin() {
     );
     if (bundled) return bundled.nodeExe;
     const localAgent = path10.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
-    if (existsSync9(localAgent)) return localAgent;
+    if (existsSync10(localAgent)) return localAgent;
   }
   return "agent";
 }
@@ -2362,7 +2443,7 @@ function resolveWorkerProvider(name) {
 
 // src/auto-complete.ts
 import { spawn as spawn3 } from "node:child_process";
-import { existsSync as existsSync10, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
+import { existsSync as existsSync11, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
 import path13 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -2861,6 +2942,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 path43 = normalizeRelativePath(pathFromGitStatusLine(line));
+    return removedSet.has(path43);
+  });
+}
+
+// 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([
@@ -2957,7 +3165,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) {
@@ -3034,26 +3242,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,
@@ -3062,10 +3292,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
@@ -3206,8 +3437,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) : [];
@@ -3488,7 +3719,7 @@ function resolveDefaultCliPath() {
 }
 function spawnCompletionSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath();
-  if (!existsSync10(cliPath)) return void 0;
+  if (!existsSync11(cliPath)) return void 0;
   const logPath = path13.join(opts.workerDir, "auto-complete.log");
   let logFd;
   try {
@@ -3575,7 +3806,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 (existsSync11(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
+  if (existsSync12(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");
@@ -3631,6 +3862,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) } : {},
@@ -3965,8 +4197,8 @@ function isTmpOnlyPath(filePath) {
 
 // src/plan-persist/outbox-store.ts
 import {
-  existsSync as existsSync13,
-  readFileSync as readFileSync7,
+  existsSync as existsSync14,
+  readFileSync as readFileSync8,
   renameSync,
   readdirSync as readdirSync4,
   writeFileSync as writeFileSync3,
@@ -3992,9 +4224,9 @@ function findOutboxByIdempotencyKey(key) {
   return null;
 }
 function readOutboxItem(jsonPath) {
-  if (!existsSync13(jsonPath)) return null;
+  if (!existsSync14(jsonPath)) return null;
   try {
-    return JSON.parse(readFileSync7(jsonPath, "utf8"));
+    return JSON.parse(readFileSync8(jsonPath, "utf8"));
   } catch {
     return null;
   }
@@ -4002,7 +4234,7 @@ function readOutboxItem(jsonPath) {
 function readOutboxBody(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
   const bodyFile = path16.join(outboxDir, item.bodyPath);
-  return readFileSync7(bodyFile, "utf8");
+  return readFileSync8(bodyFile, "utf8");
 }
 function writeOutboxItem(input, opts) {
   const { outboxDir } = ensurePlanOutboxDirs();
@@ -4056,8 +4288,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 (existsSync13(jsonSrc)) renameSync(jsonSrc, jsonDst);
-  if (existsSync13(bodySrc)) renameSync(bodySrc, bodyDst);
+  if (existsSync14(jsonSrc)) renameSync(jsonSrc, jsonDst);
+  if (existsSync14(bodySrc)) renameSync(bodySrc, bodyDst);
 }
 function outboxItemPaths(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
@@ -4326,10 +4558,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,
@@ -4518,6 +4752,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,
@@ -4648,7 +4883,7 @@ async function sweepRun(args) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5 } from "node:fs";
 import path22 from "node:path";
 
 // src/default-repo.ts
@@ -4721,7 +4956,7 @@ function createRun(args) {
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync14(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync15(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();
@@ -4754,8 +4989,61 @@ function failExists(message) {
   process.exit(1);
 }
 
+// src/discard-disposable.ts
+import { existsSync as existsSync16, rmSync } from "node:fs";
+import path23 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 = path23.resolve(worker.worktreePath);
+  const removed = [];
+  for (const raw of paths) {
+    const rel = normalizeRelativePath2(raw);
+    const abs = path23.resolve(worktreeRoot, rel);
+    if (!abs.startsWith(worktreeRoot + path23.sep) && abs !== worktreeRoot) {
+      return { ok: false, removed, reason: `path escapes worktree: ${raw}` };
+    }
+    if (!existsSync16(abs)) {
+      return { ok: false, removed, reason: `path not found: ${raw}` };
+    }
+    rmSync(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 path32 from "node:path";
+import path35 from "node:path";
 
 // src/pipeline-dispatch.ts
 var RESERVED_REVIEW_STARTS = 1;
@@ -4809,10 +5097,10 @@ async function runPipelineDispatch(args, slots) {
 }
 
 // src/stale-reconcile.ts
-import path24 from "node:path";
+import path25 from "node:path";
 
 // src/finalize.ts
-import path23 from "node:path";
+import path24 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set([
   "running",
   "dispatching",
@@ -4830,7 +5118,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"),
+      path24.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) continue;
@@ -4882,7 +5170,7 @@ function reconcileStaleWorkers() {
   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 workerPath = path25.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker || worker.status !== "running") {
         outcomes.push({
@@ -4976,7 +5264,7 @@ function reconcileRunsCli() {
 }
 
 // src/plan-progress-daemon-sync.ts
-import path25 from "node:path";
+import path26 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -5000,7 +5288,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path25.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path26.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -5049,7 +5337,7 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 }
 
 // src/cleanup.ts
-import path30 from "node:path";
+import path33 from "node:path";
 
 // src/cleanup-run-liveness.ts
 function isWorkerProcessLive(indexed) {
@@ -5070,6 +5358,15 @@ function runBlocksWorktreeRemoval(indexed) {
   return deriveTerminalRunStatus(indexed.run) === null;
 }
 
+// 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-guards.ts
 function prUrlFromFinalResult(finalResult) {
   if (typeof finalResult === "string") {
@@ -5092,29 +5389,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,
@@ -5122,6 +5415,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) {
@@ -5138,21 +5442,21 @@ 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 existsSync16, rmSync } from "node:fs";
-import path27 from "node:path";
+import { existsSync as existsSync18, rmSync as rmSync2 } from "node:fs";
+import path28 from "node:path";
 
 // src/cleanup-dir-size.ts
-import { existsSync as existsSync15, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
-import path26 from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
+import path27 from "node:path";
 function directorySizeBytes(root, maxEntries = 5e4) {
-  if (!existsSync15(root)) return 0;
+  if (!existsSync17(root)) return 0;
   let total = 0;
   let seen = 0;
   const stack = [root];
@@ -5166,7 +5470,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path26.join(current, name);
+      const full = path27.join(current, name);
       let st;
       try {
         st = statSync2(full);
@@ -5182,7 +5486,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
 
 // src/cleanup-execute.ts
 function removeNodeModules(candidate, execute) {
-  if (!existsSync16(candidate.path)) {
+  if (!existsSync18(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -5195,7 +5499,7 @@ function removeNodeModules(candidate, execute) {
   }
   try {
     const bytesBefore = candidate.bytes ?? directorySizeBytes(candidate.path);
-    rmSync(candidate.path, { recursive: true, force: true });
+    rmSync2(candidate.path, { recursive: true, force: true });
     return {
       ...candidate,
       bytes: bytesBefore,
@@ -5213,7 +5517,7 @@ function removeNodeModules(candidate, execute) {
   }
 }
 function removeWorktree(candidate, execute) {
-  if (!existsSync16(candidate.path)) {
+  if (!existsSync18(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -5230,8 +5534,8 @@ function removeWorktree(candidate, execute) {
     if (repo) {
       git(repo, ["worktree", "remove", "--force", candidate.path], { allowFailure: true });
     }
-    if (existsSync16(candidate.path)) {
-      rmSync(candidate.path, { recursive: true, force: true });
+    if (existsSync18(candidate.path)) {
+      rmSync2(candidate.path, { recursive: true, force: true });
     }
     return {
       ...candidate,
@@ -5250,20 +5554,20 @@ 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 existsSync17, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
-import path28 from "node:path";
+import { existsSync as existsSync19, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import path29 from "node:path";
 function pathAgeMs(target, now) {
   try {
     const mtime = statSync3(target).mtimeMs;
@@ -5273,17 +5577,17 @@ function pathAgeMs(target, now) {
   }
 }
 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 (!existsSync17(nm)) continue;
-    const resolved = path28.resolve(nm);
+    const nm = path29.join(entry.worktreePath, "node_modules");
+    if (!existsSync19(nm)) continue;
+    const resolved = path29.resolve(nm);
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     candidates.push({
@@ -5296,16 +5600,16 @@ function scanNodeModulesCandidates(opts) {
       ageMs: pathAgeMs(resolved, opts.now)
     });
   }
-  if (!opts.includeOrphans || !existsSync17(opts.worktreesDir)) return candidates;
+  if (!opts.includeOrphans || !existsSync19(opts.worktreesDir)) return candidates;
   for (const runEntry of readdirSync6(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path28.join(opts.worktreesDir, runEntry.name);
+    const runPath = path29.join(opts.worktreesDir, runEntry.name);
     for (const workerEntry of readdirSync6(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path28.join(runPath, workerEntry.name);
-      const nm = path28.join(worktreePath, "node_modules");
-      if (!existsSync17(nm)) continue;
-      const resolved = path28.resolve(nm);
+      const worktreePath = path29.join(runPath, workerEntry.name);
+      const nm = path29.join(worktreePath, "node_modules");
+      if (!existsSync19(nm)) continue;
+      const resolved = path29.resolve(nm);
       if (seen.has(resolved)) continue;
       if (!isPathInside(resolved, opts.harnessRoot)) continue;
       seen.add(resolved);
@@ -5322,40 +5626,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 (!existsSync19(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 || !existsSync19(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 (!existsSync17(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 readdirSync6(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 = readdirSync6(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,
@@ -5413,13 +5753,143 @@ function resolvePipelineHarnessRetention(runId) {
   });
 }
 
+// src/cleanup-orphan-safety.ts
+import { existsSync as existsSync20, statSync as statSync4 } from "node:fs";
+import path31 from "node:path";
+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 = path31.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 = path31.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/harness-storage-snapshot.ts
+import { existsSync as existsSync21, readdirSync as readdirSync7, statSync as statSync5 } from "node:fs";
+import path32 from "node:path";
+function harnessStorageSnapshot(opts = {}) {
+  const harnessRoot = opts.harnessRoot ?? resolveHarnessRoot();
+  const worktreesDir = path32.join(harnessRoot, "worktrees");
+  const now = opts.now ?? Date.now();
+  const scannedAt = new Date(now).toISOString();
+  if (!existsSync21(worktreesDir)) {
+    return {
+      harnessRoot,
+      worktreesDir,
+      worktreesBytes: 0,
+      runCount: 0,
+      workerCount: 0,
+      oldestRunAt: null,
+      scannedAt
+    };
+  }
+  let totalBytes = 0;
+  let runCount = 0;
+  let workerCount = 0;
+  let oldestMs = null;
+  let entries;
+  try {
+    entries = readdirSync7(worktreesDir, { withFileTypes: true });
+  } catch {
+    return {
+      harnessRoot,
+      worktreesDir,
+      worktreesBytes: null,
+      runCount: 0,
+      workerCount: 0,
+      oldestRunAt: null,
+      scannedAt
+    };
+  }
+  for (const runEntry of entries) {
+    if (!runEntry.isDirectory()) continue;
+    runCount += 1;
+    const runPath = path32.join(worktreesDir, runEntry.name);
+    try {
+      const st = statSync5(runPath);
+      oldestMs = oldestMs === null ? st.mtimeMs : Math.min(oldestMs, st.mtimeMs);
+    } catch {
+    }
+    try {
+      for (const workerEntry of readdirSync7(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 {
+    harnessRoot,
+    worktreesDir,
+    worktreesBytes: totalBytes,
+    runCount,
+    workerCount,
+    oldestRunAt: oldestMs === null ? null : new Date(oldestMs).toISOString(),
+    scannedAt
+  };
+}
+
 // 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 { worktreesDir } = options.harnessRoot ? { worktreesDir: path33.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 } : {} });
 }
@@ -5464,7 +5934,7 @@ function runHarnessCleanup(options = {}) {
       actions.push({ ...candidate, executed: false, skipped: true, skipReason: pathSkip });
       continue;
     }
-    const worktreePath = path30.resolve(candidate.path, "..");
+    const worktreePath = path33.resolve(candidate.path, "..");
     const indexed = index.get(worktreePath) ?? null;
     const guardReason = skipNodeModulesRemoval({
       indexed,
@@ -5481,15 +5951,26 @@ function runHarnessCleanup(options = {}) {
   }
   for (const raw of scanWorktreeCandidates(scanOpts)) {
     const candidate = attachCandidateBytes(raw, retention.accountBytes);
-    const indexed = index.get(path30.resolve(candidate.path)) ?? null;
-    const guardReason = skipWorktreeRemoval({
+    const indexed = index.get(path33.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: path33.resolve(candidate.path),
       includeOrphans: retention.includeOrphans,
       worktreesAgeMs: retention.worktreesAgeMs,
-      ageMs: candidate.ageMs
+      ageMs: candidate.ageMs,
+      orphanSafety,
+      worktreeRemovalGuard: options.worktreeRemovalGuard
     });
-    if (guardReason) {
-      recordSkip(skips, candidate.path, guardReason);
+    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;
     }
@@ -5511,6 +5992,7 @@ function runHarnessCleanup(options = {}) {
       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,
@@ -5529,7 +6011,8 @@ function runHarnessCleanup(options = {}) {
       removedPaths,
       skippedPaths,
       skipReasons: tallySkipReasons(actions, skips)
-    }
+    },
+    ...storage ? { storage } : {}
   };
 }
 function runPipelineHarnessCleanup(runId) {
@@ -5551,7 +6034,7 @@ function isPipelineCleanupEnabled() {
 // src/installed-package-versions.ts
 import { readFile } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import path31 from "node:path";
+import path34 from "node:path";
 var MANAGED_PACKAGES = [
   "@kynver-app/runtime",
   "@kynver-app/openclaw-agent-os",
@@ -5566,12 +6049,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) ?? path34.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) ? path34.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path34.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")
+    path34.join(openClawPrefix, "lib", "node_modules"),
+    path34.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path34.join(npmGlobalRoot, "lib", "node_modules")
   ]);
 }
 async function readVersion(packageJsonPath) {
@@ -5587,7 +6070,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 = path34.join(root, packageName, "package.json");
       const version = await readVersion(packageJsonPath);
       if (!version) continue;
       out[packageName] = { version, observedAt, path: packageJsonPath };
@@ -5603,7 +6086,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"),
+      path35.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -5745,7 +6228,7 @@ async function runDaemon(args) {
 }
 
 // src/plan-progress.ts
-import path33 from "node:path";
+import path36 from "node:path";
 
 // src/bounded-build/constants.ts
 var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
@@ -6031,7 +6514,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 = path36.resolve(worktree);
   const summary = runHarnessVerifyCommands(cwd);
   const emitJson = args.json === true || args.json === "true";
   const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
@@ -6080,9 +6563,9 @@ async function verifyPlan(args) {
 }
 
 // src/harness-verify-cli.ts
-import path34 from "node:path";
+import path37 from "node:path";
 function runHarnessVerifyCli(args) {
-  const cwd = path34.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const cwd = path37.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;
@@ -6126,7 +6609,7 @@ function runHarnessVerifyCli(args) {
 }
 
 // src/plan-persist-cli.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 var OPERATIONS = ["create", "add_version", "update_metadata"];
 var FAILURE_KINDS = [
   "approval_guard",
@@ -6138,7 +6621,7 @@ var FAILURE_KINDS = [
 function readBodyArg(args) {
   const bodyFile = args.bodyFile ? String(args.bodyFile) : void 0;
   if (bodyFile) {
-    return { body: readFileSync8(bodyFile, "utf8"), bodyPathHint: bodyFile };
+    return { body: readFileSync9(bodyFile, "utf8"), bodyPathHint: bodyFile };
   }
   const inline = args.body ? String(args.body) : void 0;
   if (inline) return { body: inline };
@@ -6228,7 +6711,7 @@ function runCleanupCli(args) {
 }
 
 // src/monitor/monitor.service.ts
-import path36 from "node:path";
+import path39 from "node:path";
 
 // src/monitor/monitor.classify.ts
 function expectedLeaseOwner(runId) {
@@ -6284,11 +6767,11 @@ function classifyWorkerHealth(input) {
 }
 
 // src/monitor/monitor.store.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync6, readdirSync as readdirSync7, unlinkSync as unlinkSync2 } from "node:fs";
-import path35 from "node:path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync6, readdirSync as readdirSync8, unlinkSync as unlinkSync2 } from "node:fs";
+import path38 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path35.join(harnessRoot, "monitors");
+  const dir = path38.join(harnessRoot, "monitors");
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
@@ -6296,7 +6779,7 @@ function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path35.join(monitorsDir(), `${monitorId}.json`);
+  return path38.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -6306,18 +6789,18 @@ function saveMonitorSession(session) {
 }
 function deleteMonitorSession(monitorId) {
   const file = monitorPath(monitorId);
-  if (!existsSync18(file)) return false;
+  if (!existsSync22(file)) return false;
   unlinkSync2(file);
   return true;
 }
 function listMonitorSessions() {
   const dir = monitorsDir();
-  if (!existsSync18(dir)) return [];
+  if (!existsSync22(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),
+      path38.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -6408,7 +6891,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"),
+    path39.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -6610,18 +7093,18 @@ async function runMonitorLoop(args) {
 
 // src/monitor/monitor-spawn.ts
 import { spawn as spawn4 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync19, openSync as openSync4 } from "node:fs";
-import path37 from "node:path";
+import { closeSync as closeSync4, existsSync as existsSync23, openSync as openSync4 } from "node:fs";
+import path40 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path37.join(fileURLToPath3(new URL(".", import.meta.url)), "..", "cli.js");
+  return path40.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
-  if (!existsSync19(cliPath)) return void 0;
+  if (!existsSync23(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path37.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path40.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
     logFd = openSync4(logPath, "a");
@@ -6741,13 +7224,13 @@ async function monitorTickCli(args) {
 }
 
 // src/package-version.ts
-import { existsSync as existsSync20, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync24, readFileSync as readFileSync10 } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function resolvePackageRoot(moduleUrl) {
   let dir = dirname(fileURLToPath4(moduleUrl));
   for (let depth = 0; depth < 6; depth += 1) {
-    if (existsSync20(join(dir, "package.json"))) return dir;
+    if (existsSync24(join(dir, "package.json"))) return dir;
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -6756,7 +7239,7 @@ function resolvePackageRoot(moduleUrl) {
 }
 function readOwnPackageVersion(moduleUrl = import.meta.url) {
   const pkgPath = join(resolvePackageRoot(moduleUrl), "package.json");
-  const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
   if (typeof pkg.version !== "string" || !pkg.version.trim()) {
     throw new Error(`Missing package.json version at ${pkgPath}`);
   }
@@ -6777,12 +7260,12 @@ function handleCliVersionFlag(argv, moduleUrl = import.meta.url, binName) {
 }
 
 // src/doctor/runtime-takeover.ts
-import path39 from "node:path";
+import path42 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 existsSync25, readFileSync as readFileSync11 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import path38 from "node:path";
+import path41 from "node:path";
 import { spawnSync as spawnSync6 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
@@ -6811,7 +7294,7 @@ function tokenPrefix(token) {
   return trimmed.length <= 12 ? `${trimmed}\u2026` : `${trimmed.slice(0, 12)}\u2026`;
 }
 function isWritable(target) {
-  if (!existsSync21(target)) return false;
+  if (!existsSync25(target)) return false;
   try {
     accessSync(target, constants.W_OK);
     return true;
@@ -6824,15 +7307,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: () => path41.join(homedir7(), ".kynver", "config.json"),
+  credentialsFilePath: () => path41.join(homedir7(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path38.join(homedir7(), ".kynver", "credentials");
-    if (!existsSync21(credPath)) {
+    const credPath = path41.join(homedir7(), ".kynver", "credentials");
+    if (!existsSync25(credPath)) {
       return { hasApiKey: false };
     }
     try {
-      const parsed = JSON.parse(readFileSync10(credPath, "utf8"));
+      const parsed = JSON.parse(readFileSync11(credPath, "utf8"));
       return {
         hasApiKey: Boolean(parsed.apiKey?.trim()),
         runnerTokenPrefix: tokenPrefix(parsed.runnerToken),
@@ -6851,6 +7334,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();
@@ -6858,18 +7342,59 @@ var defaultRuntimeTakeoverProbes = {
     })()
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path38.join(homedir7(), ".openclaw", "harness"),
-  pathExists: (target) => existsSync21(target),
+  legacyOpenclawHarnessRoot: () => path41.join(homedir7(), ".openclaw", "harness"),
+  pathExists: (target) => existsSync25(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);
@@ -7146,8 +7671,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 = path42.join(harnessRoot, "runs");
+  const worktreesDir = path42.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -7256,7 +7781,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",
@@ -7362,6 +7888,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]",
@@ -7371,6 +7898,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]",
@@ -7431,6 +7959,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);