@kynver-app/runtime 0.1.120 → 0.1.122

package/dist/server/cleanup.js

@@ -317,23 +317,23 @@ function isWslHost() {
 function observeWslHostDisk(options = {}) {
   const wsl = options.forceWsl === void 0 ? isWslHost() : options.forceWsl;
   if (!wsl) return null;
-  const path24 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
+  const path26 = 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(path24);
+    stats = statfs(path26);
   } catch (error) {
     return {
       ok: false,
-      path: path24,
+      path: path26,
       freeBytes: 0,
       totalBytes: 0,
       usedPercent: 100,
       warnBelowBytes,
       criticalBelowBytes,
-      reason: `Windows host disk probe failed at ${path24}: ${error.message}`,
+      reason: `Windows host disk probe failed at ${path26}: ${error.message}`,
       probeError: error.message
     };
   }
@@ -347,11 +347,11 @@ function observeWslHostDisk(options = {}) {
   let reason = null;
   if (!ok) {
     const tag = criticalFree ? "critical" : "warning";
-    reason = `Windows host disk ${path24} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+    reason = `Windows host disk ${path26} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
   }
   return {
     ok,
-    path: path24,
+    path: path26,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -377,12 +377,12 @@ var init_wsl_host = __esm({
 // src/disk-gate.ts
 import { statfsSync as statfsSync2 } from "node:fs";
 function observeRunnerDiskGate(input = {}) {
-  const path24 = input.diskPath?.trim() || "/";
+  const path26 = 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 = statfsSync2(path24);
+  const stats = statfsSync2(path26);
   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;
@@ -405,7 +405,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path24,
+    path: path26,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -1917,11 +1917,11 @@ var init_paths = __esm({
 
 // src/cleanup.ts
 init_paths();
-import path23 from "node:path";
+import path25 from "node:path";
 
 // src/cleanup-guards.ts
 init_landing_gate();
-import path8 from "node:path";
+import path11 from "node:path";
 
 // src/cleanup-index-status.ts
 init_git();
@@ -2126,6 +2126,148 @@ function finalizeStaleRuns() {
 // src/cleanup-run-liveness.ts
 init_status();
 
+// src/cleanup-worker-harness-live.ts
+init_heartbeat();
+
+// src/run-metadata-retention.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readdirSync as readdirSync4, renameSync, statSync as statSync3 } from "node:fs";
+import path9 from "node:path";
+
+// src/default-repo.ts
+init_config();
+init_default_repo_discovery();
+init_path_values();
+
+// src/run-metadata-retention.ts
+init_heartbeat();
+init_paths();
+init_run_store();
+
+// src/worker-metadata-paths.ts
+init_paths();
+init_util();
+import path8 from "node:path";
+var NESTED_RUNS = `${path8.sep}runs${path8.sep}runs${path8.sep}`;
+function workerArtifactPaths(workerDir) {
+  return {
+    workerJsonPath: path8.join(workerDir, "worker.json"),
+    stdoutPath: path8.join(workerDir, "stdout.jsonl"),
+    stderrPath: path8.join(workerDir, "stderr.log"),
+    heartbeatPath: path8.join(workerDir, "heartbeat.jsonl"),
+    lastStatusPath: path8.join(workerDir, "last-status.json")
+  };
+}
+
+// src/run-metadata-retention.ts
+init_util();
+var RUN_METADATA_ACTIVE_SIGNAL_MS = 15 * 60 * 1e3;
+var TERMINAL_WORKER_ARCHIVE_AGE_MS = 60 * 60 * 1e3;
+function isHarnessRunMetadataPath(targetPath, harnessRoot) {
+  const resolved = path9.resolve(targetPath);
+  const runsDir = path9.resolve(harnessRunsDir(harnessRoot));
+  const rel = path9.relative(runsDir, resolved);
+  return rel !== ".." && !rel.startsWith("..") && !path9.isAbsolute(rel);
+}
+function listRunDirIds(runsDir) {
+  if (!existsSync9(runsDir)) return [];
+  try {
+    return readdirSync4(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "runs").map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function listWorkerNamesOnDisk(runDir2) {
+  const workersDir = path9.join(runDir2, "workers");
+  if (!existsSync9(workersDir)) return [];
+  try {
+    return readdirSync4(workersDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function pathRecentlyTouched(target, now, windowMs) {
+  if (!existsSync9(target)) return false;
+  try {
+    const age = now - statSync3(target).mtimeMs;
+    return Number.isFinite(age) && age >= 0 && age < windowMs;
+  } catch {
+    return false;
+  }
+}
+function workerDirHasActiveRetentionSignals(workerDir, now = Date.now(), windowMs = RUN_METADATA_ACTIVE_SIGNAL_MS) {
+  if (!existsSync9(workerDir)) return false;
+  const artifacts = workerArtifactPaths(workerDir);
+  const worker = readJson(
+    artifacts.workerJsonPath,
+    void 0
+  );
+  if (worker?.status === "running" && isPidAlive(worker.pid)) return true;
+  const heartbeat = parseHeartbeat(artifacts.heartbeatPath);
+  if (heartbeat.lastHeartbeatAt) {
+    const age = now - Date.parse(heartbeat.lastHeartbeatAt);
+    if (Number.isFinite(age) && age >= 0 && age < windowMs) return true;
+  }
+  if (pathRecentlyTouched(artifacts.stdoutPath, now, windowMs)) return true;
+  if (pathRecentlyTouched(artifacts.heartbeatPath, now, windowMs)) return true;
+  return false;
+}
+function runDirHasActiveRetentionSignals(runDir2, now = Date.now(), windowMs = RUN_METADATA_ACTIVE_SIGNAL_MS) {
+  for (const name of listWorkerNamesOnDisk(runDir2)) {
+    if (workerDirHasActiveRetentionSignals(path9.join(runDir2, "workers", name), now, windowMs)) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectFilesystemLiveRunKeys(harnessRoot, now = Date.now()) {
+  const keys = /* @__PURE__ */ new Set();
+  const runsDir = harnessRunsDir(harnessRoot);
+  for (const runId of listRunDirIds(runsDir)) {
+    const runDir2 = path9.join(runsDir, runId);
+    if (runDirHasActiveRetentionSignals(runDir2, now)) {
+      keys.add(`${harnessRoot}\0${runId}`);
+    }
+  }
+  return keys;
+}
+
+// src/cleanup-worker-harness-live.ts
+init_util();
+function heartbeatContentIsFresh(worker, now = Date.now(), windowMs = RUN_METADATA_ACTIVE_SIGNAL_MS) {
+  const heartbeat = parseHeartbeat(worker.heartbeatPath);
+  if (!heartbeat.lastHeartbeatAt) return false;
+  const age = now - Date.parse(heartbeat.lastHeartbeatAt);
+  return Number.isFinite(age) && age >= 0 && age < windowMs;
+}
+function isHarnessWorkerHarnessLive(worker, now = Date.now(), windowMs = RUN_METADATA_ACTIVE_SIGNAL_MS) {
+  if (isPidAlive(worker.pid)) return true;
+  return heartbeatContentIsFresh(worker, now, windowMs);
+}
+
+// src/cleanup-run-liveness.ts
+function deriveRunTerminal(indexed, ctx) {
+  if (ctx) return ctx.runTerminalCache.derive(indexed.run);
+  return deriveTerminalRunStatus(indexed.run);
+}
+function isWorkerProcessLive(indexed, now = Date.now()) {
+  return isHarnessWorkerHarnessLive(indexed.worker, now);
+}
+function isRunStaleActive(indexed, ctx) {
+  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
+  return deriveRunTerminal(indexed, ctx) !== null;
+}
+function runBlocksWorktreeRemoval(indexed, ctx, now = Date.now()) {
+  if (isWorkerProcessLive(indexed, now)) return true;
+  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
+  if (isRunStaleActive(indexed, ctx)) return false;
+  const status = indexedWorktreeStatus(indexed);
+  if (!isFinishedWorkerStatus(status)) {
+    if (!isWorkerProcessLive(indexed, now)) return false;
+    return true;
+  }
+  return false;
+}
+
 // src/cleanup-completion-blocker.ts
 init_landing_gate();
 init_status();
@@ -2147,51 +2289,80 @@ function completionBlockerBlocksWorktreeRemoval(indexed, status) {
   return false;
 }
 
-// src/cleanup-run-liveness.ts
+// src/cleanup-salvage-evidence.ts
+init_git();
 init_util();
-var TERMINAL_WORKER_JSON_STATUSES = /* @__PURE__ */ new Set([
-  "done",
-  "exited",
-  "blocked",
-  "failed",
-  "abandoned"
-]);
-function deriveRunTerminal(indexed, ctx) {
-  if (ctx) return ctx.runTerminalCache.derive(indexed.run);
-  return deriveTerminalRunStatus(indexed.run);
-}
-function isWorkerProcessLive(indexed) {
-  if (isPidAlive(indexed.worker.pid)) return true;
-  if (typeof indexed.worker.completionReportedAt === "string" && indexed.worker.completionReportedAt.trim().length > 0) {
-    return false;
-  }
-  const workerStatus = indexed.worker.status;
-  if (workerStatus && TERMINAL_WORKER_JSON_STATUSES.has(workerStatus)) return false;
-  if (!indexed.worker.pid) {
-    if (workerStatus !== "running") return false;
-    return indexedWorktreeStatus(indexed).alive;
-  }
-  return false;
-}
-function isRunStaleActive(indexed, ctx) {
-  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
-  return deriveRunTerminal(indexed, ctx) !== null;
-}
-function runBlocksWorktreeRemoval(indexed, ctx) {
-  if (isWorkerProcessLive(indexed)) return true;
-  const workerStatus = indexed.worker.status;
-  if (workerStatus && TERMINAL_WORKER_JSON_STATUSES.has(workerStatus) && !indexed.worker.completionBlocker) {
-    return false;
-  }
-  const status = indexedWorktreeStatus(indexed);
-  if (completionBlockerBlocksWorktreeRemoval(indexed, status)) return true;
-  if (isFinishedWorkerStatus(status)) return false;
-  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
-  if (isRunStaleActive(indexed, ctx)) return false;
-  return deriveRunTerminal(indexed, ctx) === null;
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import path10 from "node:path";
+function salvageEvidenceDir(harnessRoot, runId, workerName) {
+  return path10.join(harnessRoot, "salvage", safeSlug(runId), safeSlug(workerName));
+}
+function hasSalvageEvidence(input) {
+  return existsSync10(path10.join(salvageEvidenceDir(input.harnessRoot, input.runId, input.workerName), "evidence.json"));
+}
+function writeWorktreeSalvageEvidence(input) {
+  const dir = salvageEvidenceDir(input.harnessRoot, input.indexed.runId, input.indexed.workerName);
+  mkdirSync4(dir, { recursive: true });
+  const patchPath = path10.join(dir, "salvage.patch");
+  let wrotePatch = false;
+  if (existsSync10(input.indexed.worktreePath)) {
+    const diff = gitCapture(input.indexed.worktreePath, ["diff", "HEAD"]);
+    const staged = gitCapture(input.indexed.worktreePath, ["diff", "--cached"]);
+    const patch = [diff.stdout, staged.stdout].filter((chunk) => chunk.trim()).join("\n");
+    if (patch.trim()) {
+      writeFileSync3(patchPath, patch.endsWith("\n") ? patch : `${patch}
+`);
+      wrotePatch = true;
+    }
+  }
+  const record = {
+    capturedAt: new Date(input.now ?? Date.now()).toISOString(),
+    skipReason: input.skipReason,
+    runId: input.indexed.runId,
+    workerName: input.indexed.workerName,
+    worktreePath: input.indexed.worktreePath,
+    taskId: input.indexed.worker.taskId,
+    agentOsId: input.indexed.worker.agentOsId,
+    branch: input.indexed.worker.branch,
+    completionBlocker: input.indexed.worker.completionBlocker,
+    finalResult: input.status.finalResult,
+    changedFiles: input.status.changedFiles,
+    gitAncestry: input.status.gitAncestry,
+    prUrl: input.status.prUrl ?? null,
+    ...wrotePatch ? { patchPath } : {}
+  };
+  writeFileSync3(path10.join(dir, "evidence.json"), `${JSON.stringify(record, null, 2)}
+`);
+  return record;
 }
 
 // src/cleanup-guards.ts
+var SALVAGE_ELIGIBLE_SKIP_REASONS = /* @__PURE__ */ new Set([
+  "completion_blocked",
+  "dirty_worktree",
+  "pr_or_unmerged_commits",
+  "landing_blocked"
+]);
+function maybeSalvageBlockedWorktree(input) {
+  if (!SALVAGE_ELIGIBLE_SKIP_REASONS.has(input.skipReason)) return false;
+  if (isWorkerProcessLive(input.indexed, input.now)) return false;
+  if (hasSalvageEvidence({
+    harnessRoot: input.harnessRoot,
+    runId: input.indexed.runId,
+    workerName: input.indexed.workerName
+  })) {
+    return true;
+  }
+  if (!input.writeSalvageEvidence) return false;
+  writeWorktreeSalvageEvidence({
+    harnessRoot: input.harnessRoot,
+    indexed: input.indexed,
+    skipReason: input.skipReason,
+    status: input.status,
+    now: input.now
+  });
+  return true;
+}
 function effectiveWorktreeAgeMs(input) {
   const { indexed, includeOrphans, worktreesAgeMs, terminalWorktreesAgeMs } = input;
   if (!indexed) return includeOrphans ? terminalWorktreesAgeMs : worktreesAgeMs;
@@ -2206,8 +2377,18 @@ function effectiveWorktreeAgeMs(input) {
   }
   return worktreesAgeMs;
 }
+function resolveHarnessRoot2(input, indexed) {
+  if (input.harnessRoot?.trim()) return path11.resolve(input.harnessRoot);
+  const workerDir = indexed.worker.workerDir;
+  if (!workerDir) return null;
+  const runsMarker = `${path11.sep}runs${path11.sep}`;
+  const idx = workerDir.indexOf(runsMarker);
+  if (idx < 0) return null;
+  return workerDir.slice(0, idx + runsMarker.length - 1);
+}
 function skipWorktreeRemoval(input) {
   const { indexed, includeOrphans, worktreesAgeMs, ageMs, orphanSafety, worktreeRemovalGuard } = input;
+  const now = input.now ?? Date.now();
   if (!indexed) {
     if (!includeOrphans) return "orphan_without_flag";
     return orphanSafety ?? null;
@@ -2215,25 +2396,55 @@ function skipWorktreeRemoval(input) {
   const ageThresholdMs = effectiveWorktreeAgeMs(input);
   if (worktreesAgeMs <= 0 && !includeOrphans && ageThresholdMs <= 0) return "worktrees_disabled";
   if (ageThresholdMs > 0 && ageMs < ageThresholdMs) return "below_age_threshold";
-  if (isWorkerProcessLive(indexed)) return "active_worker";
+  if (isWorkerProcessLive(indexed, now)) return "active_worker";
+  const status = resolveWorktreeGuardStatus(indexed, input.liveness);
+  const salvageHarnessRoot = resolveHarnessRoot2(input, indexed);
+  const salvageOrBlock = (skipReason) => {
+    if (salvageHarnessRoot && maybeSalvageBlockedWorktree({
+      indexed,
+      harnessRoot: salvageHarnessRoot,
+      skipReason,
+      status,
+      now,
+      writeSalvageEvidence: input.writeSalvageEvidence === true
+    })) {
+      return null;
+    }
+    return skipReason;
+  };
+  if (completionBlockerBlocksWorktreeRemoval(indexed, status)) {
+    const blocked = salvageOrBlock("completion_blocked");
+    if (blocked) return blocked;
+  }
   if (indexedWorktreeHasMaterialChanges(indexed, input.liveness?.gitStatusCache)) {
-    return "dirty_worktree";
+    const blocked = salvageOrBlock("dirty_worktree");
+    if (blocked) return blocked;
   }
   const ahead = input.liveness?.gitRevCache?.countAheadOfMain(input.worktreePath);
-  if (ahead !== null && ahead !== void 0 && ahead > 0) return "pr_or_unmerged_commits";
-  const status = resolveWorktreeGuardStatus(indexed, input.liveness);
-  if (completionBlockerBlocksWorktreeRemoval(indexed, status)) return "completion_blocked";
-  if (runBlocksWorktreeRemoval(indexed, input.liveness)) return "run_still_active";
+  if (ahead !== null && ahead !== void 0 && ahead > 0) {
+    const blocked = salvageOrBlock("pr_or_unmerged_commits");
+    if (blocked) return blocked;
+  }
+  if (runBlocksWorktreeRemoval(indexed, input.liveness, now)) return "run_still_active";
   if (!isFinishedWorkerStatus(status)) return "run_still_active";
-  if (isPrOrUnmergedWork(status)) return "pr_or_unmerged_commits";
-  if (materialWorktreeChanges(status.changedFiles).length > 0) return "dirty_worktree";
+  if (isPrOrUnmergedWork(status)) {
+    const blocked = salvageOrBlock("pr_or_unmerged_commits");
+    if (blocked) return blocked;
+  }
+  if (materialWorktreeChanges(status.changedFiles).length > 0) {
+    const blocked = salvageOrBlock("dirty_worktree");
+    if (blocked) return blocked;
+  }
   const landing = assessWorkerLanding({
     finalResult: status.finalResult,
     changedFiles: status.changedFiles,
     gitAncestry: status.gitAncestry,
     prUrl: prUrlFromFinalResult(status.finalResult)
   });
-  if (landing.blocked) return "landing_blocked";
+  if (landing.blocked) {
+    const blocked = salvageOrBlock("landing_blocked");
+    if (blocked) return blocked;
+  }
   if (worktreeRemovalGuard && input.worktreePath) {
     const overlay = worktreeRemovalGuard({
       worktreePath: input.worktreePath,
@@ -2250,7 +2461,7 @@ function skipWorktreeRemoval(input) {
 function skipDependencyCacheRemoval(input) {
   const { indexed, nodeModulesAgeMs, ageMs, worktreePath, activeWorktreePaths, diskPressure } = input;
   if (!diskPressure && ageMs < nodeModulesAgeMs) return "below_age_threshold";
-  if (activeWorktreePaths.has(path8.resolve(worktreePath))) return "active_worker";
+  if (activeWorktreePaths.has(path11.resolve(worktreePath))) return "active_worker";
   if (indexed && isWorkerProcessLive(indexed)) return "active_worker";
   if (indexed && indexedWorktreeHasMaterialChanges(indexed, input.gitStatusCache)) {
     return "dirty_worktree";
@@ -2279,11 +2490,11 @@ var LIVE_SKIP_REASONS = /* @__PURE__ */ new Set([
 function collectPreservedLivePaths(actions, skips) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const push = (path24, reason, detail) => {
-    const key = `${path24}\0${reason}`;
+  const push = (path26, reason, detail) => {
+    const key = `${path26}\0${reason}`;
     if (seen.has(key) || out.length >= MAX_PRESERVED_LIVE_PATH_SAMPLES) return;
     seen.add(key);
-    out.push({ path: path24, reason, ...detail ? { detail } : {} });
+    out.push({ path: path26, reason, ...detail ? { detail } : {} });
   };
   for (const skip of skips) {
     if (!LIVE_SKIP_REASONS.has(skip.reason)) continue;
@@ -2298,134 +2509,16 @@ function collectPreservedLivePaths(actions, skips) {
 }
 
 // src/cleanup-run-directory.ts
-import { existsSync as existsSync11, readdirSync as readdirSync6, statSync as statSync5 } from "node:fs";
-import path12 from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
+import path13 from "node:path";
 
 // src/cleanup-active-worktrees.ts
 init_run_store();
 init_paths();
-import { existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
-import path11 from "node:path";
-
-// src/run-metadata-retention.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
-import path10 from "node:path";
-
-// src/default-repo.ts
-init_config();
-init_default_repo_discovery();
-init_path_values();
-
-// src/run-metadata-retention.ts
-init_heartbeat();
-init_paths();
-init_run_store();
-
-// src/worker-metadata-paths.ts
-init_paths();
-init_util();
-import path9 from "node:path";
-var NESTED_RUNS = `${path9.sep}runs${path9.sep}runs${path9.sep}`;
-function workerArtifactPaths(workerDir) {
-  return {
-    workerJsonPath: path9.join(workerDir, "worker.json"),
-    stdoutPath: path9.join(workerDir, "stdout.jsonl"),
-    stderrPath: path9.join(workerDir, "stderr.log"),
-    heartbeatPath: path9.join(workerDir, "heartbeat.jsonl"),
-    lastStatusPath: path9.join(workerDir, "last-status.json")
-  };
-}
-
-// src/run-metadata-retention.ts
-init_util();
-var RUN_METADATA_ACTIVE_SIGNAL_MS = 15 * 60 * 1e3;
-function isHarnessRunMetadataPath(targetPath, harnessRoot) {
-  const resolved = path10.resolve(targetPath);
-  const runsDir = path10.resolve(harnessRunsDir(harnessRoot));
-  const rel = path10.relative(runsDir, resolved);
-  return rel !== ".." && !rel.startsWith("..") && !path10.isAbsolute(rel);
-}
-function listRunDirIds(runsDir) {
-  if (!existsSync9(runsDir)) return [];
-  try {
-    return readdirSync4(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "runs").map((entry) => entry.name);
-  } catch {
-    return [];
-  }
-}
-function listWorkerNamesOnDisk(runDir2) {
-  const workersDir = path10.join(runDir2, "workers");
-  if (!existsSync9(workersDir)) return [];
-  try {
-    return readdirSync4(workersDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch {
-    return [];
-  }
-}
-function pathRecentlyTouched(target, now, windowMs) {
-  if (!existsSync9(target)) return false;
-  try {
-    const age = now - statSync3(target).mtimeMs;
-    return Number.isFinite(age) && age >= 0 && age < windowMs;
-  } catch {
-    return false;
-  }
-}
-function workerDirHasActiveRetentionSignals(workerDir, now = Date.now(), windowMs = RUN_METADATA_ACTIVE_SIGNAL_MS) {
-  if (!existsSync9(workerDir)) return false;
-  const artifacts = workerArtifactPaths(workerDir);
-  const worker = readJson(
-    artifacts.workerJsonPath,
-    void 0
-  );
-  if (worker?.status === "running" && isPidAlive(worker.pid)) return true;
-  const heartbeat = parseHeartbeat(artifacts.heartbeatPath);
-  if (heartbeat.lastHeartbeatAt) {
-    const age = now - Date.parse(heartbeat.lastHeartbeatAt);
-    if (Number.isFinite(age) && age >= 0 && age < windowMs) return true;
-  }
-  if (pathRecentlyTouched(artifacts.stdoutPath, now, windowMs)) return true;
-  if (pathRecentlyTouched(artifacts.heartbeatPath, now, windowMs)) return true;
-  return false;
-}
-function runDirHasActiveRetentionSignals(runDir2, now = Date.now(), windowMs = RUN_METADATA_ACTIVE_SIGNAL_MS) {
-  for (const name of listWorkerNamesOnDisk(runDir2)) {
-    if (workerDirHasActiveRetentionSignals(path10.join(runDir2, "workers", name), now, windowMs)) {
-      return true;
-    }
-  }
-  return false;
-}
-function collectFilesystemLiveRunKeys(harnessRoot, now = Date.now()) {
-  const keys = /* @__PURE__ */ new Set();
-  const runsDir = harnessRunsDir(harnessRoot);
-  for (const runId of listRunDirIds(runsDir)) {
-    const runDir2 = path10.join(runsDir, runId);
-    if (runDirHasActiveRetentionSignals(runDir2, now)) {
-      keys.add(`${harnessRoot}\0${runId}`);
-    }
-  }
-  return keys;
-}
-
-// src/cleanup-active-worktrees.ts
+import path12 from "node:path";
 init_util();
-function workerHasRecentHarnessActivity(worker, now) {
-  const paths = [worker.heartbeatPath, worker.stdoutPath, worker.stderrPath];
-  for (const target of paths) {
-    if (!existsSync10(target)) continue;
-    try {
-      const age = now - statSync4(target).mtimeMs;
-      if (Number.isFinite(age) && age >= 0 && age < RUN_METADATA_ACTIVE_SIGNAL_MS) return true;
-    } catch {
-    }
-  }
-  return false;
-}
 function isActiveHarnessWorker2(worker, now) {
-  if (isPidAlive(worker.pid)) return true;
-  if (worker.status === "running" && workerHasRecentHarnessActivity(worker, now)) return true;
-  return false;
+  return isHarnessWorkerHarnessLive(worker, now);
 }
 function collectActiveWorktreeGuards(harnessRoots, now = Date.now()) {
   const activeWorktreePaths = /* @__PURE__ */ new Set();
@@ -2435,11 +2528,11 @@ function collectActiveWorktreeGuards(harnessRoots, now = Date.now()) {
       let runHasLive = false;
       for (const name of Object.keys(run.workers || {})) {
         const worker = readJson(
-          path11.join(runDirectoryAt(harnessRoot, run.id), "workers", safeSlug(name), "worker.json"),
+          path12.join(runDirectoryAt(harnessRoot, run.id), "workers", safeSlug(name), "worker.json"),
           void 0
         );
         if (!worker?.worktreePath) continue;
-        const worktreePath = path11.resolve(worker.worktreePath);
+        const worktreePath = path12.resolve(worker.worktreePath);
         if (!isActiveHarnessWorker2(worker, now)) continue;
         runHasLive = true;
         activeWorktreePaths.add(worktreePath);
@@ -2461,20 +2554,20 @@ function isWorktreeOnLiveRun(worktreePath, harnessRoot, runId, liveRunKeys) {
 init_util();
 function pathAgeMs(target, now) {
   try {
-    const mtime = statSync5(target).mtimeMs;
+    const mtime = statSync4(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
   }
 }
 function loadRunStatus(harnessRoot, runId) {
-  const runPath = path12.join(harnessRoot, "runs", runId, "run.json");
+  const runPath = path13.join(harnessRoot, "runs", runId, "run.json");
   if (!existsSync11(runPath)) return null;
   return readJson(runPath, null);
 }
 function runDirectoryIsEmpty(runPath) {
   try {
-    const entries = readdirSync6(runPath);
+    const entries = readdirSync5(runPath);
     return entries.length === 0;
   } catch {
     return false;
@@ -2498,7 +2591,7 @@ function scanStaleRunDirectoryCandidates(opts) {
   const candidates = [];
   let entries;
   try {
-    entries = readdirSync6(opts.worktreesDir, { withFileTypes: true });
+    entries = readdirSync5(opts.worktreesDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -2506,7 +2599,7 @@ function scanStaleRunDirectoryCandidates(opts) {
     if (!runEntry.isDirectory()) continue;
     const runId = runEntry.name;
     if (opts.runIdFilter && runId !== opts.runIdFilter) continue;
-    const runPath = path12.join(opts.worktreesDir, runId);
+    const runPath = path13.join(opts.worktreesDir, runId);
     if (!runDirectoryIsEmpty(runPath)) continue;
     candidates.push({
       kind: "remove_run_directory",
@@ -2526,8 +2619,8 @@ import { existsSync as existsSync14, rmSync as rmSync2 } from "node:fs";
 
 // src/cleanup-dir-size.ts
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync12, readdirSync as readdirSync7, statSync as statSync6 } from "node:fs";
-import path13 from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync6, statSync as statSync5 } from "node:fs";
+import path14 from "node:path";
 var DEFAULT_DU_TIMEOUT_MS = 2500;
 function directorySizeBytesDu(root, timeoutMs = DEFAULT_DU_TIMEOUT_MS) {
   if (!existsSync12(root)) return 0;
@@ -2555,16 +2648,16 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     const current = stack.pop();
     let entries;
     try {
-      entries = readdirSync7(current);
+      entries = readdirSync6(current);
     } catch {
       continue;
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path13.join(current, name);
+      const full = path14.join(current, name);
       let st;
       try {
-        st = statSync6(full);
+        st = statSync5(full);
       } catch {
         continue;
       }
@@ -2580,7 +2673,7 @@ import { existsSync as existsSync13, rmSync } from "node:fs";
 init_paths();
 
 // src/cleanup-path-ownership.ts
-import { lstatSync, readdirSync as readdirSync8 } from "node:fs";
+import { lstatSync, readdirSync as readdirSync7 } from "node:fs";
 function readPathOwnership(targetPath) {
   try {
     const st = lstatSync(targetPath);
@@ -2597,7 +2690,7 @@ function pathHasForeignOwnedEntry(targetPath, maxEntries = 32) {
   if (!root) return false;
   if (root.foreign) return true;
   try {
-    const names = readdirSync8(targetPath);
+    const names = readdirSync7(targetPath);
     let checked = 0;
     for (const name of names) {
       if (checked >= maxEntries) break;
@@ -2613,20 +2706,20 @@ function pathHasForeignOwnedEntry(targetPath, maxEntries = 32) {
 
 // src/cleanup-privileged-remove.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // src/cleanup-harness-path-validate.ts
-import path14 from "node:path";
+import path15 from "node:path";
 function isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, cacheDirName) {
-  const resolved = path14.resolve(targetPath);
-  const suffix = `${path14.sep}${cacheDirName}`;
+  const resolved = path15.resolve(targetPath);
+  const suffix = `${path15.sep}${cacheDirName}`;
   const cachePath = resolved.endsWith(suffix) ? resolved : null;
   if (!cachePath) return "path_outside_harness";
-  const rel = path14.relative(worktreesDir, cachePath);
-  if (rel.startsWith("..") || path14.isAbsolute(rel)) return "path_outside_harness";
-  const parts = rel.split(path14.sep);
+  const rel = path15.relative(worktreesDir, cachePath);
+  if (rel.startsWith("..") || path15.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path15.sep);
   if (parts.length < 3 || parts[parts.length - 1] !== cacheDirName) return "path_outside_harness";
-  if (!resolved.startsWith(path14.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path15.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
@@ -2636,16 +2729,16 @@ function isHarnessNextCachePath(targetPath, harnessRoot, worktreesDir) {
   return isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, ".next");
 }
 function isHarnessBuildCachePath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path14.resolve(targetPath);
-  const relToWt = path14.relative(worktreesDir, resolved);
-  if (relToWt.startsWith("..") || path14.isAbsolute(relToWt)) return "path_outside_harness";
-  const parts = relToWt.split(path14.sep);
+  const resolved = path15.resolve(targetPath);
+  const relToWt = path15.relative(worktreesDir, resolved);
+  if (relToWt.startsWith("..") || path15.isAbsolute(relToWt)) return "path_outside_harness";
+  const parts = relToWt.split(path15.sep);
   if (parts.length < 3) return "path_outside_harness";
-  if (!resolved.startsWith(path14.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path15.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 function isHarnessGeneratedCachePath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path14.resolve(targetPath);
+  const resolved = path15.resolve(targetPath);
   return isHarnessNodeModulesPath(resolved, harnessRoot, worktreesDir) === null || isHarnessNextCachePath(resolved, harnessRoot, worktreesDir) === null || isHarnessBuildCachePath(resolved, harnessRoot, worktreesDir) === null;
 }
 
@@ -2679,12 +2772,12 @@ function tryPrivilegedReclaimHarnessCache(targetPath, harnessRoot, worktreesDir)
     "chown",
     "-R",
     `${effectiveUid}:${effectiveGid}`,
-    path15.resolve(targetPath)
+    path16.resolve(targetPath)
   ]);
   if (chown.ok) {
     return { ok: true, method: "chown_then_rm" };
   }
-  const rm = runSudoNonInteractive(["rm", "-rf", path15.resolve(targetPath)]);
+  const rm = runSudoNonInteractive(["rm", "-rf", path16.resolve(targetPath)]);
   if (rm.ok) {
     return { ok: true, method: "sudo_rm" };
   }
@@ -2885,27 +2978,27 @@ function removeWorktree(candidate, execute) {
 }
 
 // src/cleanup-scan.ts
-import { existsSync as existsSync15, readdirSync as readdirSync9, statSync as statSync7 } from "node:fs";
-import path16 from "node:path";
+import { existsSync as existsSync15, readdirSync as readdirSync8, statSync as statSync6 } from "node:fs";
+import path17 from "node:path";
 function pathAgeMs2(target, now) {
   try {
-    const mtime = statSync7(target).mtimeMs;
+    const mtime = statSync6(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
   }
 }
 function isPathInside(child, parent) {
-  const rel = path16.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path16.isAbsolute(rel);
+  const rel = path17.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path17.isAbsolute(rel);
 }
 function collectBuildCacheForWorktree(worktreePath, opts, seen, meta) {
   const out = [];
   for (const rel of HARNESS_BUILD_CACHE_RELATIVE_PATHS) {
     if (rel === ".next") continue;
-    const target = path16.join(worktreePath, rel);
+    const target = path17.join(worktreePath, rel);
     if (!existsSync15(target)) continue;
-    const resolved = path16.resolve(target);
+    const resolved = path17.resolve(target);
     if (seen.has(resolved)) continue;
     if (!isPathInside(resolved, opts.harnessRoot)) continue;
     seen.add(resolved);
@@ -2935,12 +3028,12 @@ function scanBuildCacheCandidates(opts) {
     );
   }
   if (!opts.includeOrphans || !existsSync15(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync9(opts.worktreesDir, { withFileTypes: true })) {
+  for (const runEntry of readdirSync8(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path16.join(opts.worktreesDir, runEntry.name);
-    for (const workerEntry of readdirSync9(runPath, { withFileTypes: true })) {
+    const runPath = path17.join(opts.worktreesDir, runEntry.name);
+    for (const workerEntry of readdirSync8(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path16.join(runPath, workerEntry.name);
+      const worktreePath = path17.join(runPath, workerEntry.name);
       candidates.push(
         ...collectBuildCacheForWorktree(worktreePath, opts, seen, {
           runId: runEntry.name,
@@ -2978,21 +3071,21 @@ function scanWorktreeCandidates(opts) {
   if (!orphanEnabled || !existsSync15(opts.worktreesDir)) return candidates;
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path16.resolve(entry.worktreePath));
+    indexedPaths.add(path17.resolve(entry.worktreePath));
   }
-  for (const runEntry of readdirSync9(opts.worktreesDir, { withFileTypes: true })) {
+  for (const runEntry of readdirSync8(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path16.join(opts.worktreesDir, runEntry.name);
+    const runPath = path17.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
-      workerEntries = readdirSync9(runPath, { withFileTypes: true });
+      workerEntries = readdirSync8(runPath, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path16.resolve(path16.join(runPath, workerEntry.name));
+      const worktreePath = path17.resolve(path17.join(runPath, workerEntry.name));
       if (seen.has(worktreePath)) continue;
       if (indexedPaths.has(worktreePath)) continue;
       if (!isPathInside(worktreePath, opts.harnessRoot)) continue;
@@ -3011,27 +3104,27 @@ function scanWorktreeCandidates(opts) {
 }
 
 // src/cleanup-dependency-scan.ts
-import { existsSync as existsSync16, readdirSync as readdirSync10, statSync as statSync8 } from "node:fs";
-import path17 from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync9, statSync as statSync7 } from "node:fs";
+import path18 from "node:path";
 var DEPENDENCY_CACHE_DIRS = [
   { dirName: "node_modules", kind: "remove_node_modules" },
   { dirName: ".next", kind: "remove_next_cache" }
 ];
 function pathAgeMs3(target, now) {
   try {
-    const mtime = statSync8(target).mtimeMs;
+    const mtime = statSync7(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
   }
 }
 function isPathInside2(child, parent) {
-  const rel = path17.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path17.isAbsolute(rel);
+  const rel = path18.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path18.isAbsolute(rel);
 }
 function pushCandidate(candidates, seen, opts, targetPath, kind, meta) {
   if (!existsSync16(targetPath)) return;
-  const resolved = path17.resolve(targetPath);
+  const resolved = path18.resolve(targetPath);
   if (seen.has(resolved)) return;
   if (!isPathInside2(resolved, opts.harnessRoot)) return;
   seen.add(resolved);
@@ -3048,7 +3141,7 @@ function pushCandidate(candidates, seen, opts, targetPath, kind, meta) {
 }
 function scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, meta) {
   for (const entry of DEPENDENCY_CACHE_DIRS) {
-    pushCandidate(candidates, seen, opts, path17.join(worktreePath, entry.dirName), entry.kind, meta);
+    pushCandidate(candidates, seen, opts, path18.join(worktreePath, entry.dirName), entry.kind, meta);
   }
 }
 function scanDependencyCacheCandidates(opts) {
@@ -3063,19 +3156,19 @@ function scanDependencyCacheCandidates(opts) {
     });
   }
   if (!opts.includeOrphans || !existsSync16(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync10(opts.worktreesDir, { withFileTypes: true })) {
+  for (const runEntry of readdirSync9(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path17.join(opts.worktreesDir, runEntry.name);
+    const runPath = path18.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
-      workerEntries = readdirSync10(runPath, { withFileTypes: true });
+      workerEntries = readdirSync9(runPath, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path17.join(runPath, workerEntry.name);
+      const worktreePath = path18.join(runPath, workerEntry.name);
       scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, {
         runId: runEntry.name,
         worker: workerEntry.name
@@ -3087,11 +3180,11 @@ function scanDependencyCacheCandidates(opts) {
 
 // src/cleanup-duplicate-worktrees.ts
 init_git();
-import { existsSync as existsSync17, statSync as statSync9 } from "node:fs";
-import path18 from "node:path";
+import { existsSync as existsSync17, statSync as statSync8 } from "node:fs";
+import path19 from "node:path";
 function pathAgeMs4(target, now) {
   try {
-    const mtime = statSync9(target).mtimeMs;
+    const mtime = statSync8(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
@@ -3118,32 +3211,24 @@ function parseWorktreePorcelain(output) {
   return records;
 }
 function isUnderWorktreesDir(worktreePath, worktreesDir) {
-  const rel = path18.relative(path18.resolve(worktreesDir), path18.resolve(worktreePath));
-  return rel !== "" && !rel.startsWith("..") && !path18.isAbsolute(rel);
-}
-function isCleanWorktree(worktreePath, repoRoot) {
-  try {
-    const porcelain = git(repoRoot, ["-C", worktreePath, "status", "--porcelain"], {
-      allowFailure: true
-    });
-    return !String(porcelain || "").trim();
-  } catch {
-    return false;
-  }
+  const rel = path19.relative(path19.resolve(worktreesDir), path19.resolve(worktreePath));
+  return rel !== "" && !rel.startsWith("..") && !path19.isAbsolute(rel);
 }
+var MAX_DUPLICATE_WORKTREE_CANDIDATES_PER_REPO = 200;
 function scanDuplicateWorktreeCandidates(opts) {
   if (!opts.includeOrphans || !existsSync17(opts.worktreesDir)) return [];
   const repos = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    if (entry.run.repo) repos.add(path18.resolve(entry.run.repo));
+    if (entry.run.repo) repos.add(path19.resolve(entry.run.repo));
   }
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path18.resolve(entry.worktreePath));
+    indexedPaths.add(path19.resolve(entry.worktreePath));
   }
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoRoot of repos) {
+    let repoCandidateCount = 0;
     let porcelain;
     try {
       porcelain = git(repoRoot, ["worktree", "list", "--porcelain"], { allowFailure: true });
@@ -3152,18 +3237,19 @@ function scanDuplicateWorktreeCandidates(opts) {
     }
     const worktrees = parseWorktreePorcelain(porcelain);
     for (const wt of worktrees) {
-      const resolved = path18.resolve(wt.path);
-      if (resolved === path18.resolve(repoRoot)) continue;
+      if (repoCandidateCount >= MAX_DUPLICATE_WORKTREE_CANDIDATES_PER_REPO) break;
+      const resolved = path19.resolve(wt.path);
+      if (resolved === path19.resolve(repoRoot)) continue;
       if (!isUnderWorktreesDir(resolved, opts.worktreesDir)) continue;
       if (indexedPaths.has(resolved)) continue;
       if (seen.has(resolved)) continue;
       if (!existsSync17(resolved)) continue;
-      if (!isCleanWorktree(resolved, repoRoot)) continue;
-      const rel = path18.relative(opts.worktreesDir, resolved);
-      const parts = rel.split(path18.sep);
+      const rel = path19.relative(opts.worktreesDir, resolved);
+      const parts = rel.split(path19.sep);
       const runId = parts[0];
       const worker = parts[1] ?? "unknown";
       seen.add(resolved);
+      repoCandidateCount += 1;
       candidates.push({
         kind: "remove_worktree",
         path: resolved,
@@ -3181,12 +3267,22 @@ function scanDuplicateWorktreeCandidates(opts) {
 // src/cleanup-worktree-index.ts
 init_run_store();
 init_util();
-import path19 from "node:path";
+import path20 from "node:path";
+function filterWorktreeIndexForRoot(index, harnessRoot) {
+  const resolvedRoot = path20.resolve(harnessRoot);
+  const scoped = /* @__PURE__ */ new Map();
+  for (const [key, entry] of index) {
+    const entryRoot = entry.harnessRoot ? path20.resolve(entry.harnessRoot) : null;
+    if (entryRoot && entryRoot !== resolvedRoot) continue;
+    scoped.set(key, entry);
+  }
+  return scoped;
+}
 function buildWorktreeIndexAt(harnessRoot) {
   const index = /* @__PURE__ */ new Map();
   for (const run of listRunRecordsForHarnessRoot(harnessRoot)) {
     for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path19.join(
+      const workerPath = path20.join(
         runDirectoryAt(harnessRoot, run.id),
         "workers",
         safeSlug(name),
@@ -3194,9 +3290,9 @@ function buildWorktreeIndexAt(harnessRoot) {
       );
       const worker = readJson(workerPath, void 0);
       if (!worker?.worktreePath) continue;
-      index.set(path19.resolve(worker.worktreePath), {
+      index.set(path20.resolve(worker.worktreePath), {
         harnessRoot,
-        worktreePath: path19.resolve(worker.worktreePath),
+        worktreePath: path20.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -3222,6 +3318,7 @@ function resolveHarnessRetention(options = {}) {
   const execute = options.execute === true || options.execute !== false && envFlag("KYNVER_CLEANUP_EXECUTE");
   const finalizeStaleRuns2 = options.finalizeStaleRuns !== false && !envFlag("KYNVER_CLEANUP_SKIP_FINALIZE");
   const nodeModulesAgeMs = options.nodeModulesAgeMs ?? envMs("KYNVER_CLEANUP_NODE_MODULES_AGE_MS", DEFAULT_NODE_MODULES_AGE_MS);
+  const scanDependencyCaches = options.scanDependencyCaches ?? (options.nodeModulesAgeMs !== void 0 || process.env.KYNVER_CLEANUP_NODE_MODULES_AGE_MS != null);
   const worktreesAgeMs = options.worktreesAgeMs ?? envMs("KYNVER_CLEANUP_WORKTREES_AGE_MS", 0);
   const terminalWorktreesAgeMs = options.terminalWorktreesAgeMs ?? envMs("KYNVER_CLEANUP_TERMINAL_WORKTREES_AGE_MS", DEFAULT_TERMINAL_WORKTREES_AGE_MS);
   const runDirectoriesAgeMs = options.runDirectoriesAgeMs ?? envMs("KYNVER_CLEANUP_RUN_DIRECTORIES_AGE_MS", DEFAULT_RUN_DIRECTORIES_AGE_MS);
@@ -3237,6 +3334,7 @@ function resolveHarnessRetention(options = {}) {
   return {
     execute,
     finalizeStaleRuns: finalizeStaleRuns2,
+    scanDependencyCaches,
     nodeModulesAgeMs,
     worktreesAgeMs: worktreesAgeMs > 0 ? worktreesAgeMs : 0,
     terminalWorktreesAgeMs: terminalWorktreesAgeMs >= 0 ? terminalWorktreesAgeMs : 0,
@@ -3252,29 +3350,31 @@ function resolveHarnessRetention(options = {}) {
 
 // src/cleanup-orphan-safety.ts
 init_git();
-import { existsSync as existsSync18, statSync as statSync10 } from "node:fs";
-import path20 from "node:path";
+import { existsSync as existsSync18 } from "node:fs";
+import path21 from "node:path";
+init_util();
 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 (!existsSync18(input.worktreePath)) return null;
   if (input.runId && input.workerName) {
-    const heartbeatPath = path20.join(
+    const workerDir = path21.join(
       input.harnessRoot,
       "runs",
       input.runId,
       "workers",
-      input.workerName,
-      "heartbeat.jsonl"
+      input.workerName
     );
-    try {
-      const mtime = statSync10(heartbeatPath).mtimeMs;
-      if (now - mtime < heartbeatFreshMs) return "active_worker";
-    } catch {
+    const worker = readJson(
+      path21.join(workerDir, "worker.json"),
+      void 0
+    );
+    if (worker && heartbeatContentIsFresh(worker, now, heartbeatFreshMs)) {
+      return "active_worker";
     }
   }
-  const gitDir = path20.join(input.worktreePath, ".git");
+  const gitDir = path21.join(input.worktreePath, ".git");
   if (!existsSync18(gitDir)) return null;
   const porcelain = gitCapture(input.worktreePath, ["status", "--porcelain"]);
   if (porcelain.status !== 0) return "pr_or_unmerged_commits";
@@ -3305,8 +3405,8 @@ function assessOrphanWorktreeSafety(input) {
 
 // src/harness-storage-snapshot.ts
 init_paths();
-import { existsSync as existsSync19, readdirSync as readdirSync11, statSync as statSync11 } from "node:fs";
-import path21 from "node:path";
+import { existsSync as existsSync19, readdirSync as readdirSync10, statSync as statSync9 } from "node:fs";
+import path22 from "node:path";
 function harnessStorageSnapshot(opts = {}) {
   const harnessRoot = normalizeHarnessRoot(opts.harnessRoot ?? resolveHarnessRoot());
   const worktreesDir = harnessWorktreesDir(harnessRoot);
@@ -3329,7 +3429,7 @@ function harnessStorageSnapshot(opts = {}) {
   let oldestMs = null;
   let entries;
   try {
-    entries = readdirSync11(worktreesDir, { withFileTypes: true });
+    entries = readdirSync10(worktreesDir, { withFileTypes: true });
   } catch {
     return {
       harnessRoot,
@@ -3344,14 +3444,14 @@ function harnessStorageSnapshot(opts = {}) {
   for (const runEntry of entries) {
     if (!runEntry.isDirectory()) continue;
     runCount += 1;
-    const runPath = path21.join(worktreesDir, runEntry.name);
+    const runPath = path22.join(worktreesDir, runEntry.name);
     try {
-      const st = statSync11(runPath);
+      const st = statSync9(runPath);
       oldestMs = oldestMs === null ? st.mtimeMs : Math.min(oldestMs, st.mtimeMs);
     } catch {
     }
     try {
-      for (const workerEntry of readdirSync11(runPath, { withFileTypes: true })) {
+      for (const workerEntry of readdirSync10(runPath, { withFileTypes: true })) {
         if (workerEntry.isDirectory()) workerCount += 1;
       }
     } catch {
@@ -3382,10 +3482,10 @@ function harnessStorageSnapshot(opts = {}) {
 init_paths();
 import { existsSync as existsSync20 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import path22 from "node:path";
+import path23 from "node:path";
 var WELL_KNOWN_HARNESS_SCAN_ROOTS = [
   "/var/tmp/kynver-harness",
-  path22.join(homedir4(), ".openclaw", "harness")
+  path23.join(homedir4(), ".openclaw", "harness")
 ];
 function addRoot(seen, roots, candidate) {
   if (!candidate?.trim()) return;
@@ -3407,7 +3507,7 @@ function resolveHarnessScanRoots(options = {}) {
   for (const candidate of extra ?? []) addRoot(seen, roots, candidate);
   if (shouldScanWellKnownRoots(options)) {
     for (const candidate of WELL_KNOWN_HARNESS_SCAN_ROOTS) {
-      const resolved = path22.resolve(candidate);
+      const resolved = path23.resolve(candidate);
       if (!seen.has(resolved) && existsSync20(resolved)) addRoot(seen, roots, resolved);
     }
   }
@@ -3486,15 +3586,52 @@ var CleanupGitRevCache = class {
   }
 };
 
+// src/cleanup-git-probe.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync21 } from "node:fs";
+import path24 from "node:path";
+var CLEANUP_GIT_PROBE_TIMEOUT_MS = 5e3;
+function cleanupGitCapture(cwd, args) {
+  if (!existsSync21(path24.join(cwd, ".git"))) {
+    return { status: null, stdout: "", stderr: "", error: "not_a_git_repo" };
+  }
+  try {
+    const res = spawnSync3("git", args, {
+      cwd,
+      encoding: "utf8",
+      timeout: CLEANUP_GIT_PROBE_TIMEOUT_MS
+    });
+    const timedOut = res.error?.message?.includes("ETIMEDOUT") === true;
+    return {
+      status: timedOut ? null : res.status,
+      stdout: res.stdout || "",
+      stderr: res.stderr || "",
+      error: timedOut ? "git_timeout" : res.error ? res.error.message : null
+    };
+  } catch (error) {
+    return {
+      status: null,
+      stdout: "",
+      stderr: "",
+      error: error.message
+    };
+  }
+}
+function gitStatusShortForCleanup(worktreePath) {
+  const captured = cleanupGitCapture(worktreePath, ["status", "--short"]);
+  if (captured.error === "not_a_git_repo") return [];
+  if (captured.error === "git_timeout" || captured.status !== 0) return null;
+  return captured.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+
 // src/cleanup-git-status-cache.ts
-init_git();
 var CleanupGitStatusCache = class {
   cache = /* @__PURE__ */ new Map();
   porcelain(worktreePath) {
     const resolved = worktreePath;
     const cached = this.cache.get(resolved);
     if (cached !== void 0) return cached;
-    const lines = gitStatusShort(resolved);
+    const lines = gitStatusShortForCleanup(resolved) ?? [];
     this.cache.set(resolved, lines);
     return lines;
   }
@@ -3599,9 +3736,9 @@ function mergeWorktreeIndexes(scanRoots) {
 }
 function worktreePathForCandidate(candidate, worktreesDir) {
   if (candidate.runId && candidate.worker) {
-    return path23.join(worktreesDir, candidate.runId, candidate.worker);
+    return path25.join(worktreesDir, candidate.runId, candidate.worker);
   }
-  return path23.resolve(candidate.path, "..");
+  return path25.resolve(candidate.path, "..");
 }
 function runHarnessCleanup(options = {}) {
   let retention = resolveHarnessRetention(options);
@@ -3630,7 +3767,8 @@ function runHarnessCleanup(options = {}) {
   for (const harnessRoot of paths.scanRoots) {
     if (atSweepCap()) break;
     emitCleanupProgress("root", harnessRoot);
-    const worktreesDir = path23.join(harnessRoot, "worktrees");
+    const worktreesDir = path25.join(harnessRoot, "worktrees");
+    const rootIndex = filterWorktreeIndexForRoot(index, harnessRoot);
     const scanOpts = {
       harnessRoot,
       worktreesDir,
@@ -3638,11 +3776,14 @@ function runHarnessCleanup(options = {}) {
       worktreesAgeMs: retention.worktreesAgeMs,
       includeOrphans: retention.includeOrphans,
       runIdFilter: retention.runIdFilter,
-      index,
+      index: rootIndex,
       now: paths.now
     };
-    const dependencyCandidates = scanDependencyCacheCandidates(scanOpts);
-    emitCleanupProgress("dependency", `${dependencyCandidates.length} cache candidate(s) at ${harnessRoot}`);
+    const dependencyCandidates = retention.scanDependencyCaches ? scanDependencyCacheCandidates(scanOpts) : [];
+    emitCleanupProgress(
+      "dependency",
+      retention.scanDependencyCaches ? `${dependencyCandidates.length} cache candidate(s) at ${harnessRoot}` : "skipped (worktree-only sweep)"
+    );
     let dependencyProcessed = 0;
     for (const raw of dependencyCandidates) {
       if (atSweepCap()) break;
@@ -3650,7 +3791,7 @@ function runHarnessCleanup(options = {}) {
       if (dependencyProcessed % 50 === 0) {
         emitCleanupProgress("dependency", `${dependencyProcessed}/${dependencyCandidates.length} evaluated`);
       }
-      const resolved = path23.resolve(raw.path);
+      const resolved = path25.resolve(raw.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const candidate = { ...raw, path: resolved };
@@ -3661,7 +3802,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path23.resolve(worktreePath)) ?? null;
+      const indexed = rootIndex.get(path25.resolve(worktreePath)) ?? null;
       const guardReason = skipDependencyCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -3684,9 +3825,9 @@ function runHarnessCleanup(options = {}) {
         )
       );
     }
-    for (const raw of scanBuildCacheCandidates(scanOpts)) {
+    if (retention.scanDependencyCaches) for (const raw of scanBuildCacheCandidates(scanOpts)) {
       if (atSweepCap()) break;
-      const resolved = path23.resolve(raw.path);
+      const resolved = path25.resolve(raw.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const candidate = { ...raw, path: resolved };
@@ -3697,7 +3838,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path23.resolve(worktreePath)) ?? null;
+      const indexed = rootIndex.get(path25.resolve(worktreePath)) ?? null;
       const guardReason = skipBuildCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -3733,11 +3874,11 @@ function runHarnessCleanup(options = {}) {
       if (worktreeProcessed % 50 === 0) {
         emitCleanupProgress("worktrees", `${worktreeProcessed}/${worktreeCandidates.length} evaluated`);
       }
-      const resolved = path23.resolve(raw.path);
+      const resolved = path25.resolve(raw.path);
       if (worktreeSeen.has(resolved)) continue;
       worktreeSeen.add(resolved);
       const candidate = { ...raw, path: resolved };
-      const indexed = index.get(path23.resolve(candidate.path)) ?? null;
+      const indexed = rootIndex.get(path25.resolve(candidate.path)) ?? null;
       const orphanSafety = indexed ? null : assessOrphanWorktreeSafety({
         worktreePath: candidate.path,
         harnessRoot,
@@ -3747,14 +3888,17 @@ function runHarnessCleanup(options = {}) {
       });
       const guardSkip = skipWorktreeRemoval({
         indexed,
-        worktreePath: path23.resolve(candidate.path),
+        worktreePath: path25.resolve(candidate.path),
         includeOrphans: retention.includeOrphans,
         worktreesAgeMs: retention.worktreesAgeMs,
         terminalWorktreesAgeMs: retention.terminalWorktreesAgeMs,
         ageMs: candidate.ageMs,
         orphanSafety,
         worktreeRemovalGuard: options.worktreeRemovalGuard,
-        liveness
+        liveness,
+        now: paths.now,
+        harnessRoot,
+        writeSalvageEvidence: retention.execute
       });
       if (guardSkip) {
         const { reason: guardReason, detail: guardDetail } = normalizeGuardSkip(guardSkip);
@@ -3779,11 +3923,11 @@ function runHarnessCleanup(options = {}) {
         now: paths.now
       })) {
         if (atSweepCap()) break;
-        const resolved = path23.resolve(raw.path);
+        const resolved = path25.resolve(raw.path);
         if (processedPaths.has(resolved)) continue;
         processedPaths.add(resolved);
         const candidate = { ...raw, path: resolved };
-        const runId = candidate.runId ?? path23.basename(resolved);
+        const runId = candidate.runId ?? path25.basename(resolved);
         const dirSkip = skipRunDirectoryRemoval({
           harnessRoot,
           runId,