@kynver-app/runtime 0.1.62 → 0.1.66

package/dist/index.js

@@ -120,10 +120,6 @@ function tailFile(file, lines) {
 function readMaybeFile(file) {
   return file ? readFileSync2(path.resolve(file), "utf8") : "";
 }
-function listRunIds(runsDir) {
-  if (!existsSync2(runsDir)) return [];
-  return readdirSync(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-}
 function sleepMs(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
@@ -661,7 +657,7 @@ async function runSetup(args) {
     ...existing,
     ...inferSetupFields(existing, args),
     ...maxWorkersRaw ? { maxConcurrentWorkers: Math.max(1, Math.floor(Number(maxWorkersRaw))) } : {},
-    workerProvider: typeof args.provider === "string" ? args.provider : existing.workerProvider || "claude"
+    workerProvider: typeof args.provider === "string" ? args.provider : existing.workerProvider || "cursor"
   });
   saveUserConfig(config);
   let runnerCredentialNote;
@@ -780,23 +776,23 @@ function isWslHost() {
 function observeWslHostDisk(options = {}) {
   const wsl = options.forceWsl === void 0 ? isWslHost() : options.forceWsl;
   if (!wsl) return null;
-  const path44 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
+  const path51 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
   const warnBelowBytes = options.wslHostFreeWarnBytes ?? DEFAULT_WSL_HOST_WARN_FREE_BYTES;
   const criticalBelowBytes = options.wslHostFreeCriticalBytes ?? DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES;
   const statfs = options.statfs ?? statfsSync;
   let stats;
   try {
-    stats = statfs(path44);
+    stats = statfs(path51);
   } catch (error) {
     return {
       ok: false,
-      path: path44,
+      path: path51,
       freeBytes: 0,
       totalBytes: 0,
       usedPercent: 100,
       warnBelowBytes,
       criticalBelowBytes,
-      reason: `Windows host disk probe failed at ${path44}: ${error.message}`,
+      reason: `Windows host disk probe failed at ${path51}: ${error.message}`,
       probeError: error.message
     };
   }
@@ -810,11 +806,11 @@ function observeWslHostDisk(options = {}) {
   let reason = null;
   if (!ok) {
     const tag = criticalFree ? "critical" : "warning";
-    reason = `Windows host disk ${path44} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+    reason = `Windows host disk ${path51} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
   }
   return {
     ok,
-    path: path44,
+    path: path51,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -834,12 +830,12 @@ var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
 var DEFAULT_MAX_USED_PERCENT = 80;
 var DEFAULT_HARD_MAX_USED_PERCENT = 90;
 function observeRunnerDiskGate(input = {}) {
-  const path44 = input.diskPath?.trim() || "/";
+  const path51 = 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(path44);
+  const stats = statfsSync2(path51);
   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;
@@ -862,7 +858,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path44,
+    path: path51,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -942,6 +938,12 @@ function loadRun(id) {
 }
 function listRunRecords() {
   const { runsDir } = getPaths();
+  return listRunRecordsAt(runsDir);
+}
+function listRunRecordsForHarnessRoot(harnessRoot) {
+  return listRunRecordsAt(path6.join(harnessRoot, "runs"));
+}
+function listRunRecordsAt(runsDir) {
   if (!existsSync7(runsDir)) return [];
   const runs = [];
   for (const entry of readdirSync2(runsDir, { withFileTypes: true })) {
@@ -970,7 +972,10 @@ function saveWorker(runId, worker) {
 }
 function runDirectory(id) {
   const { runsDir } = getPaths();
-  return runDir(runsDir, safeSlug(id));
+  return runDirectoryAt(runsDir, id);
+}
+function runDirectoryAt(harnessRoot, id) {
+  return runDir(path6.join(harnessRoot, "runs"), safeSlug(id));
 }
 
 // src/heartbeat.ts
@@ -991,7 +996,9 @@ function parseHeartbeat(file) {
     lastHeartbeatPhase: null,
     lastHeartbeatSummary: null,
     heartbeatBlocker: null,
-    timestampAnomalies: []
+    timestampAnomalies: [],
+    lastBoxResourceSnapshot: null,
+    lastPrEvidence: []
   };
   if (!existsSync8(file)) return result;
   const maxFutureMs = Date.now() + HEARTBEAT_FUTURE_SKEW_MS;
@@ -1018,6 +1025,14 @@ function parseHeartbeat(file) {
     if (row.phase !== void 0 && row.phase !== null) result.lastHeartbeatPhase = String(row.phase);
     if (row.summary !== void 0 && row.summary !== null) result.lastHeartbeatSummary = String(row.summary);
     result.heartbeatBlocker = row.blocker ? String(row.blocker) : null;
+    if (row.boxResourceSnapshot && typeof row.boxResourceSnapshot === "object" && !Array.isArray(row.boxResourceSnapshot)) {
+      result.lastBoxResourceSnapshot = row.boxResourceSnapshot;
+    }
+    if (Array.isArray(row.prEvidence)) {
+      result.lastPrEvidence = row.prEvidence.filter(
+        (entry2) => !!entry2 && typeof entry2 === "object" && typeof entry2.prUrl === "string"
+      );
+    }
   }
   return result;
 }
@@ -1506,8 +1521,8 @@ function normalizePrUrl(url) {
 }
 function parseReconciliation(finalResult) {
   if (!finalResult || typeof finalResult !== "object" || Array.isArray(finalResult)) return [];
-  const record = finalResult;
-  const raw = record.targetPrReconciliation ?? record.target_pr_reconciliation;
+  const record3 = finalResult;
+  const raw = record3.targetPrReconciliation ?? record3.target_pr_reconciliation;
   if (!Array.isArray(raw)) return [];
   const out = [];
   for (const item of raw) {
@@ -1538,10 +1553,35 @@ function workerPrUrls(snapshot, finalResult) {
 function assessWorkerLandingContract(input) {
   const { contract, snapshot } = input;
   const finalResult = input.finalResult ?? snapshot.finalResult;
-  if (!contract.landingOnly && contract.targetPrUrls.length === 0) {
+  if (!contract.landingOnly && contract.targetPrUrls.length === 0 && !contract.repairEnforceOriginalPr) {
     return { blocked: false };
   }
   if (!hasFinalResult3(finalResult)) return { blocked: false };
+  const repairTarget = contract.repairEnforceOriginalPr ? normalizePrUrl(trimOrNull3(contract.targetPrUrl) ?? "") ?? (contract.targetPrUrls.length === 1 ? normalizePrUrl(contract.targetPrUrls[0]) : null) : null;
+  if (repairTarget) {
+    const workerPrs2 = workerPrUrls(snapshot, finalResult);
+    const supersedes = finalResult && typeof finalResult === "object" && !Array.isArray(finalResult) && finalResult.supersedesOriginalTargetPr === true;
+    if (!supersedes) {
+      for (const pr of workerPrs2) {
+        if (pr !== repairTarget) {
+          return {
+            blocked: true,
+            reason: "duplicate_repair_pr",
+            detail: `Repair worker opened or attached PR ${pr} instead of canonical target ${repairTarget}`
+          };
+        }
+      }
+    }
+    const reconciliation2 = parseReconciliation(finalResult);
+    const entry = reconciliation2.find((r) => r.prUrl === repairTarget);
+    if (!entry || entry.outcome !== "merged" && !(entry.reason?.trim() && (entry.outcome === "skipped" || entry.outcome === "blocked"))) {
+      return {
+        blocked: true,
+        reason: "missing_repair_target_reconciliation",
+        detail: `Repair worker must reconcile target PR ${repairTarget}`
+      };
+    }
+  }
   const reconciliation = parseReconciliation(finalResult);
   const byUrl = new Map(reconciliation.map((r) => [r.prUrl, r]));
   const targetSet = new Set(
@@ -1696,6 +1736,12 @@ function computeWorkerStatus(worker, options = {}) {
   ]);
   const error = parsed.error || (!alive && !finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0);
   const completionBlocker = typeof worker.completionBlocker === "string" && worker.completionBlocker.trim() ? worker.completionBlocker.trim() : null;
+  const landingContract = worker.repairTargetPrUrl ? {
+    landingOnly: false,
+    targetPrUrls: [worker.repairTargetPrUrl],
+    targetPrUrl: worker.repairTargetPrUrl,
+    repairEnforceOriginalPr: true
+  } : null;
   const attention = computeAttention({
     alive,
     finalResult,
@@ -1708,7 +1754,9 @@ function computeWorkerStatus(worker, options = {}) {
     error,
     changedFiles,
     gitAncestry,
-    completionBlocker
+    completionBlocker,
+    landingContract,
+    prUrl: worker.repairTargetPrUrl ?? worker.taskPrUrl ?? null
   });
   const workerStatusLabel = completionBlocker || attention.state === "blocked" ? "blocked" : completionAcknowledged || attention.state === "done" ? "done" : finalResult ? "exited" : alive ? "running" : "exited";
   return {
@@ -1830,9 +1878,16 @@ function observeRunnerResourceGate(input) {
   const slotsByCapacity = Math.max(0, maxConcurrentWorkers - activeWorkers);
   const slotsByFreeMem = capacityFromFree;
   let slotsAvailable = Math.min(slotsByCapacity, slotsByFreeMem);
+  const skipDisk = input.skipDiskGate || process.env.KYNVER_RESOURCE_GATE_SKIP_DISK === "1";
+  const diskGate = skipDisk ? void 0 : observeRunnerDiskGate({
+    diskPath: input.diskPath?.trim() || process.env.KYNVER_DISK_GUARD_PATH?.trim() || "/"
+  });
+  if (diskGate && !diskGate.ok) slotsAvailable = 0;
   let reason = null;
   if (slotsAvailable <= 0) {
-    if (activeWorkers >= maxConcurrentWorkers) {
+    if (diskGate && !diskGate.ok) {
+      reason = diskGate.reason ?? "disk gate blocked worker admission";
+    } else if (activeWorkers >= maxConcurrentWorkers) {
       reason = `at worker limit (${activeWorkers}/${maxConcurrentWorkers} running)`;
     } else if (capacityFromFree <= 0) {
       reason = "insufficient free memory \u2014 waiting for workers to finish";
@@ -1852,7 +1907,8 @@ function observeRunnerResourceGate(input) {
     maxConcurrentWorkers,
     activeWorkers,
     slotsAvailable,
-    reason
+    reason,
+    ...diskGate ? { diskGate } : {}
   };
 }
 
@@ -2040,10 +2096,86 @@ var claudeProvider = {
   }
 };
 
+// src/worker-provider-policy.ts
+var DEFAULT_WORKER_PROVIDER = "cursor";
+var CLAUDE_FAMILY = /* @__PURE__ */ new Set(["claude", "opus", "anthropic"]);
+var TASK_OVERRIDE_MARKERS = [
+  /\[worker-provider:\s*claude\]/i,
+  /\[use-claude-worker\]/i,
+  /\[operator-worker-provider:\s*claude\]/i
+];
+function taskString2(task, key) {
+  const v = task[key];
+  return typeof v === "string" ? v.trim() : "";
+}
+function isClaudeFamilyProvider(provider) {
+  if (!provider?.trim()) return false;
+  const normalized = provider.trim().toLowerCase();
+  if (CLAUDE_FAMILY.has(normalized)) return true;
+  return normalized.includes("claude") || normalized.includes("opus");
+}
+function taskAllowsClaudeWorker(task) {
+  if (!task) return false;
+  const override = task.workerProviderOverride;
+  if (typeof override === "string" && isClaudeFamilyProvider(override)) return true;
+  const ref = taskString2(task, "executorRef").toLowerCase();
+  if (ref === "provider:claude" || ref.startsWith("provider:claude:")) return true;
+  if (ref.includes("claude-worker-override") || ref.includes("operator-claude")) return true;
+  const description = taskString2(task, "description");
+  if (TASK_OVERRIDE_MARKERS.some((re) => re.test(description))) return true;
+  const title = taskString2(task, "title");
+  if (/\[use-claude-worker\]/i.test(title)) return true;
+  return false;
+}
+function coerceCursorModel(model, ruleSuffix) {
+  const coerced = {
+    provider: DEFAULT_WORKER_PROVIDER,
+    model: CURSOR_DEFAULT_MODEL,
+    rule: `policy:cursor_default${ruleSuffix}`,
+    requestedModel: model
+  };
+  return coerced;
+}
+function enforceCursorWorkerProvider(input) {
+  const { routing, task } = input;
+  const explicit = input.explicitProvider?.trim().toLowerCase();
+  if (input.explicitProviderIsOperatorOverride && isClaudeFamilyProvider(explicit)) {
+    return {
+      ...routing,
+      provider: "claude",
+      rule: routing.rule.startsWith("explicit:") ? routing.rule : "explicit:operator_provider"
+    };
+  }
+  if (taskAllowsClaudeWorker(task)) {
+    return routing;
+  }
+  if (!isClaudeFamilyProvider(routing.provider)) {
+    return routing;
+  }
+  const suffix = routing.rule && routing.rule !== "default:global" ? `:${routing.rule.replace(/:/g, "_")}` : "";
+  return coerceCursorModel(routing.model, suffix);
+}
+function resolveConfiguredWorkerProvider(configured, fallback = DEFAULT_WORKER_PROVIDER) {
+  const trimmed = configured?.trim();
+  if (!trimmed) return fallback;
+  if (isClaudeFamilyProvider(trimmed)) return DEFAULT_WORKER_PROVIDER;
+  return trimmed;
+}
+function preferCursorExecutor(executors) {
+  const unique2 = [...new Set(executors.map((e) => e.trim().toLowerCase()).filter(Boolean))];
+  if (unique2.includes(DEFAULT_WORKER_PROVIDER)) {
+    return [...new Set(unique2.map((e) => isClaudeFamilyProvider(e) ? DEFAULT_WORKER_PROVIDER : e))];
+  }
+  if (unique2.every((e) => isClaudeFamilyProvider(e))) {
+    return [DEFAULT_WORKER_PROVIDER];
+  }
+  return unique2;
+}
+
 // src/model-routing.ts
 var GLOBAL_DEFAULT_MODEL = "claude-sonnet-4-6";
 var CURSOR_DEFAULT_MODEL = "composer-2.5";
-function taskString2(task, key) {
+function taskString3(task, key) {
   const v = task[key];
   return typeof v === "string" ? v.trim() : "";
 }
@@ -2059,11 +2191,14 @@ function resolveGlobalDefaultModel(config = loadUserConfig()) {
 }
 function inferProviderFromModel(model) {
   const m = (model ?? "").toLowerCase();
-  if (!m) return "claude";
+  if (!m) return "cursor";
   if (m.includes("composer") || m.includes("cursor") || m.includes("codex") || m.startsWith("gpt-") || m.startsWith("gpt5")) {
     return "cursor";
   }
-  return "claude";
+  if (/^claude[-_]/i.test(m) || /^(?:opus|sonnet|haiku)\b/i.test(m)) {
+    return "claude";
+  }
+  return "cursor";
 }
 function normalizeProviderAliasModel(model, explicitProvider) {
   const alias = model.trim().toLowerCase();
@@ -2097,41 +2232,33 @@ function isOpusLane(ref, title) {
   return false;
 }
 function inferModelRoutingFromTask(task) {
-  const ref = normalizeRef(taskString2(task, "executorRef"));
-  const title = taskString2(task, "title").toLowerCase();
-  const priority = taskString2(task, "priority") || "normal";
-  const roleLane = normalizeRef(taskString2(task, "roleLane"));
+  const ref = normalizeRef(taskString3(task, "executorRef"));
+  const title = taskString3(task, "title").toLowerCase();
+  const priority = taskString3(task, "priority") || "normal";
+  const roleLane = normalizeRef(taskString3(task, "roleLane"));
   if (ref.includes("cursor") || ref.includes("codex") || ref.includes("composer") || ref.includes("copilot") || roleLane === "implementer" || roleLane === "repair_implementer") {
     return { provider: "cursor", rule: "lane:implementation" };
   }
   if (ref.includes("landing") || title.startsWith("land:") || title.includes(" merge")) {
-    return {
-      model: "claude-haiku-4-5-20251001",
-      provider: "claude",
-      rule: "lane:landing"
-    };
+    return { provider: "cursor", rule: "lane:landing" };
   }
   if (ref.includes("review") || /^review[\s:]/.test(title) || roleLane.includes("review")) {
     if (isOpusLane(ref, title) || roleLane === "deep_reviewer") {
-      return { model: "claude-opus-4-7", provider: "claude", rule: "lane:deep_review" };
+      return { provider: "cursor", rule: "lane:deep_review" };
     }
-    return { model: "claude-sonnet-4-6", provider: "claude", rule: "lane:review" };
+    return { provider: "cursor", rule: "lane:review" };
   }
   if (isOpusLane(ref, title) || roleLane === "plan_author") {
-    return { model: "claude-opus-4-7", provider: "claude", rule: "lane:planning" };
+    return { provider: "cursor", rule: "lane:planning" };
   }
   if (priority === "critical") {
-    return { model: "claude-opus-4-7", provider: "claude", rule: "priority:critical" };
+    return { provider: "cursor", rule: "priority:critical" };
   }
   if (priority === "high") {
-    return { model: "claude-sonnet-4-6", provider: "claude", rule: "priority:high" };
+    return { provider: "cursor", rule: "priority:high" };
   }
   if (priority === "low") {
-    return {
-      model: "claude-haiku-4-5-20251001",
-      provider: "claude",
-      rule: "priority:low"
-    };
+    return { provider: "cursor", rule: "priority:low" };
   }
   const model = resolveGlobalDefaultModel();
   return {
@@ -2141,31 +2268,41 @@ function inferModelRoutingFromTask(task) {
   };
 }
 function resolveWorkerLaunch(input) {
+  let decision;
   if (input.explicitModel?.trim()) {
-    const model2 = input.explicitModel.trim();
-    const providerAlias = normalizeProviderAliasModel(model2, input.explicitProvider);
-    if (providerAlias) return providerAlias;
-    return {
-      model: model2,
-      provider: input.explicitProvider?.trim() || inferProviderFromModel(model2),
-      rule: "explicit:cli",
-      requestedModel: model2
-    };
-  }
-  if (input.task && Object.keys(input.task).length > 0) {
+    const model = input.explicitModel.trim();
+    const providerAlias = normalizeProviderAliasModel(model, input.explicitProvider);
+    if (providerAlias) {
+      decision = providerAlias;
+    } else {
+      decision = {
+        model,
+        provider: input.explicitProvider?.trim() || inferProviderFromModel(model),
+        rule: "explicit:cli",
+        requestedModel: model
+      };
+    }
+  } else if (input.task && Object.keys(input.task).length > 0) {
     const inferred = inferModelRoutingFromTask(input.task);
-    return {
+    decision = {
       ...inferred,
       requestedModel: inferred.model
     };
+  } else {
+    const model = resolveGlobalDefaultModel();
+    decision = {
+      model,
+      provider: input.explicitProvider?.trim() || inferProviderFromModel(model),
+      rule: "default:global",
+      requestedModel: model
+    };
   }
-  const model = resolveGlobalDefaultModel();
-  return {
-    model,
-    provider: input.explicitProvider?.trim() || inferProviderFromModel(model),
-    rule: "default:global",
-    requestedModel: model
-  };
+  return enforceCursorWorkerProvider({
+    routing: decision,
+    task: input.task,
+    explicitProvider: input.explicitProvider,
+    explicitProviderIsOperatorOverride: input.explicitProviderIsOperatorOverride
+  });
 }
 function resolveModelFallback(startedModel, launchModel, providerDefault) {
   return startedModel || launchModel || providerDefault || resolveGlobalDefaultModel() || CLAUDE_DEFAULT_MODEL;
@@ -2257,6 +2394,76 @@ function hasLiveWorkerForTask(runId, taskId) {
 import { existsSync as existsSync13, mkdirSync as mkdirSync3 } from "node:fs";
 import path14 from "node:path";
 
+// src/harness-repair-target.ts
+var HARNESS_CONTRACT_RE = /<!--\s*harness-contract:\s*(\{[\s\S]*?\})\s*-->/i;
+var FIX_EXECUTOR_REF_PREFIX = "next-action-fix:";
+function trimOrNull4(value) {
+  if (typeof value !== "string") return null;
+  const t = value.trim();
+  return t.length ? t : null;
+}
+function normalizePrUrl2(url) {
+  const m = url.trim().match(/github\.com\/([^/]+\/[^/]+)\/(?:pull|pulls)\/(\d+)/i);
+  if (!m) return trimOrNull4(url);
+  return `https://github.com/${m[1]}/pull/${m[2]}`;
+}
+function isHarnessRepairTask(task) {
+  const title = (task.title ?? "").trim().toLowerCase();
+  if (title.startsWith("fix:") || title.startsWith("repair:")) return true;
+  const ref = (task.executorRef ?? "").toLowerCase();
+  if (ref.startsWith(FIX_EXECUTOR_REF_PREFIX)) return true;
+  if (ref.includes("repair") || ref.includes("unblock")) return true;
+  return false;
+}
+function parseRepairTargetContractFromDescription(description) {
+  const empty = {
+    repairEnforceOriginalPr: false,
+    targetPrUrl: null,
+    targetPrBranch: null
+  };
+  if (!description) return empty;
+  const m = description.match(HARNESS_CONTRACT_RE);
+  if (!m?.[1]) return empty;
+  try {
+    const parsed = JSON.parse(m[1]);
+    const url = trimOrNull4(
+      String(parsed.targetPrUrl ?? parsed.target_pr_url ?? "")
+    );
+    const branch = trimOrNull4(
+      String(parsed.targetPrBranch ?? parsed.target_pr_branch ?? "")
+    );
+    const enforce = parsed.repairEnforceOriginalPr === true || parsed.repair_enforce_original_pr === true;
+    return {
+      repairEnforceOriginalPr: enforce || Boolean(url),
+      targetPrUrl: url ? normalizePrUrl2(url) : null,
+      targetPrBranch: branch
+    };
+  } catch {
+    return empty;
+  }
+}
+function resolveHarnessRepairTargetFromTask(task) {
+  if (!isHarnessRepairTask(task)) return null;
+  const block = parseRepairTargetContractFromDescription(task.description);
+  const taskPr = task.prUrl ? normalizePrUrl2(task.prUrl) : null;
+  const targetPrUrl = block.targetPrUrl ?? taskPr;
+  if (!targetPrUrl) return null;
+  return {
+    targetPrUrl,
+    targetPrBranch: block.targetPrBranch ?? trimOrNull4(task.branch)
+  };
+}
+function repairTargetPromptLines(target) {
+  return [
+    "Repair target PR policy:",
+    `- Work on the existing target PR branch \u2014 do not open a duplicate repair PR by default.`,
+    `- Canonical target PR: ${target.targetPrUrl}`,
+    ...target.targetPrBranch ? [`- Canonical target branch: \`${target.targetPrBranch}\` (checkout is already on this branch).`] : [],
+    `- Reconcile ${target.targetPrUrl} in structured finalResult.targetPrReconciliation.`,
+    `- Only supersede the original when the branch is inaccessible: set supersedesOriginalTargetPr: true with reason and close/comment on the original PR.`
+  ];
+}
+
 // src/prompt.ts
 function buildPrompt(input) {
   const ownership = input.ownedPaths.length ? `Owned paths: ${input.ownedPaths.join(", ")}. Do not edit outside these paths without stopping and reporting why.` : "Owned paths: unrestricted for this worker, but keep edits tightly scoped.";
@@ -2301,7 +2508,7 @@ function buildPrompt(input) {
     `Progress heartbeat file: ${input.heartbeatPath}`,
     "After each major step, append one JSON line to the heartbeat file with fields: ts, phase, summary, changedFiles, blocker.",
     "Final response must include files changed, verification commands, and unresolved risks.",
-    "Structured final result (recommended): record completion as JSON with summary, laneExpertise { whatChanged, why, files, prUrls, verification, risks, blockers, lessonsLearned, laneGuidance }, and targetPrReconciliation [{ prUrl, outcome: merged|skipped|blocked, mergeCommit?, reason? }] for every target PR on landing-only tasks.",
+    "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. Persona-attributed tasks: put repeatable lane lessons in lessonsLearned/laneGuidance (with evidence); substantive rows auto-persist as persona-scoped Lane A rules \u2014 global cross-lane policy stays in owner memory, not worker lessons.",
     "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.",
@@ -2318,6 +2525,13 @@ function buildPrompt(input) {
     "",
     ...input.personaMarkdown?.trim() ? [input.personaMarkdown.trim(), ""] : [],
     ...input.instructionPolicyMarkdown?.trim() ? ["Operating rules (Lane A \u2014 from AgentOS memory policy):", input.instructionPolicyMarkdown.trim(), ""] : [],
+    ...input.repairTargetPrUrl ? [
+      ...repairTargetPromptLines({
+        targetPrUrl: input.repairTargetPrUrl,
+        targetPrBranch: input.repairTargetBranch ?? null
+      }),
+      ""
+    ] : [],
     "Task:",
     input.task
   ].join("\n");
@@ -2483,7 +2697,15 @@ var BUILTIN = {
 var overrideProvider = null;
 function resolveWorkerProvider(name) {
   if (overrideProvider) return overrideProvider;
-  const configured = (name || loadUserConfig().workerProvider || "claude").trim();
+  const explicit = name?.trim();
+  if (explicit) {
+    const provider2 = BUILTIN[explicit];
+    if (!provider2) {
+      throw new Error(`unknown worker provider "${explicit}" \u2014 supported: ${Object.keys(BUILTIN).join(", ")}`);
+    }
+    return provider2;
+  }
+  const configured = resolveConfiguredWorkerProvider(loadUserConfig().workerProvider);
   const provider = BUILTIN[configured];
   if (!provider) {
     throw new Error(`unknown worker provider "${configured}" \u2014 supported: ${Object.keys(BUILTIN).join(", ")}`);
@@ -2527,13 +2749,13 @@ var ADVANCED_OUTCOMES = /* @__PURE__ */ new Set([
   "review_already_scheduled"
 ]);
 function summarizeHarnessCompletionResponse(parsed) {
-  const record = asRecord(parsed);
-  if (!record) {
+  const record3 = asRecord(parsed);
+  if (!record3) {
     return { routeOutcome: null, taskAdvanced: false, detail: null };
   }
-  const outcome = asString(record.outcome);
-  const detail = asString(record.detail) ?? asString(record.error);
-  const task = asRecord(record.task);
+  const outcome = asString(record3.outcome);
+  const detail = asString(record3.detail) ?? asString(record3.error);
+  const task = asRecord(record3.task);
   const taskStatus = task ? asString(task.status) : null;
   const taskAdvanced = outcome !== null && ADVANCED_OUTCOMES.has(outcome) || taskStatus === "awaiting_review" || taskStatus === "done";
   return {
@@ -2579,7 +2801,7 @@ var NO_PR_COMMITS_BETWEEN_RE = /no commits between/i;
 function isGhNoCommitsBetweenError(detail) {
   return Boolean(detail && NO_PR_COMMITS_BETWEEN_RE.test(detail));
 }
-function trimOrNull4(value) {
+function trimOrNull5(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   return trimmed.length ? trimmed : null;
@@ -2587,7 +2809,7 @@ function trimOrNull4(value) {
 function committedHead(ancestry) {
   if (!ancestry?.checked) return null;
   if (ancestry.headIsAncestorOfBase !== false) return null;
-  return trimOrNull4(ancestry.head);
+  return trimOrNull5(ancestry.head);
 }
 function extractPrUrlFromText(value) {
   if (value === void 0 || value === null) return null;
@@ -2595,7 +2817,7 @@ function extractPrUrlFromText(value) {
   const m = text.match(
     /https?:\/\/[^\s)>"]+\/(?:pull|pulls|merge_requests|pull-requests)\/\d+/i
   );
-  return m ? trimOrNull4(m[0]) : null;
+  return m ? trimOrNull5(m[0]) : null;
 }
 function countCommitsAheadOfBase(worktreePath, baseRef, exec) {
   const base = baseRef.trim();
@@ -2607,21 +2829,21 @@ function countCommitsAheadOfBase(worktreePath, baseRef, exec) {
 }
 function isReviewArtifactWorker(worker, snapshot) {
   if (snapshot.changedFiles.length > 0) return false;
-  const persona = trimOrNull4(worker.personaSlug)?.toLowerCase();
+  const persona = trimOrNull5(worker.personaSlug)?.toLowerCase();
   if (persona && REVIEW_PERSONA_SLUGS.has(persona)) return true;
-  const rule = trimOrNull4(worker.routingRule) ?? "";
+  const rule = trimOrNull5(worker.routingRule) ?? "";
   if (rule && REVIEW_LANE_RULE.test(rule)) return true;
   return false;
 }
 function hasWorkProduct(snapshot, options) {
   if (snapshot.changedFiles.length > 0) return true;
-  const baseRef = trimOrNull4(options?.baseRef);
+  const baseRef = trimOrNull5(options?.baseRef);
   if (baseRef && options?.exec && options.worktreePath) {
     const ahead = countCommitsAheadOfBase(options.worktreePath, baseRef, options.exec);
     if (ahead === 0) return false;
     if (ahead !== null && ahead > 0) return true;
   }
-  if (trimOrNull4(snapshot.headCommit)) return true;
+  if (trimOrNull5(snapshot.headCommit)) return true;
   if (committedHead(snapshot.gitAncestry)) return true;
   return false;
 }
@@ -2637,7 +2859,7 @@ function assessPrHandoffRequirement(input) {
   })) {
     return { required: false, reason: "expert_review_task" };
   }
-  const rule = trimOrNull4(input.routingRule) ?? "";
+  const rule = trimOrNull5(input.routingRule) ?? "";
   if (rule && REVIEW_LANE_RULE.test(rule)) {
     return { required: false, reason: "review_lane" };
   }
@@ -2648,10 +2870,14 @@ function assessPrHandoffRequirement(input) {
   if (isReviewArtifactWorker(workerCtx, input.snapshot)) {
     return { required: false, reason: "review_artifact" };
   }
-  if (trimOrNull4(input.patchPath) || trimOrNull4(input.artifactBundlePath)) {
+  if (trimOrNull5(input.patchPath) || trimOrNull5(input.artifactBundlePath)) {
     return { required: false, reason: "patch_or_bundle" };
   }
-  const prUrl = trimOrNull4(input.prUrl) ?? trimOrNull4(input.taskPrUrl) ?? trimOrNull4(input.snapshot.prUrl);
+  const repairTarget = trimOrNull5(input.repairTargetPrUrl);
+  if (repairTarget) {
+    return { required: false, reason: "repair_target_pr" };
+  }
+  const prUrl = trimOrNull5(input.prUrl) ?? trimOrNull5(input.taskPrUrl) ?? trimOrNull5(input.snapshot.prUrl);
   if (prUrl) {
     return { required: false, reason: "already_has_pr" };
   }
@@ -2672,8 +2898,8 @@ function buildPrHandoffSnapshotFromStatus(status, extras) {
     worktreePath: status.worktreePath,
     gitAncestry: status.gitAncestry,
     finalResult: status.finalResult,
-    headCommit: trimOrNull4(extras?.headCommit) ?? committedHead(status.gitAncestry),
-    prUrl: trimOrNull4(extras?.prUrl) ?? null
+    headCommit: trimOrNull5(extras?.headCommit) ?? committedHead(status.gitAncestry),
+    prUrl: trimOrNull5(extras?.prUrl) ?? null
   };
 }
 
@@ -2879,6 +3105,7 @@ function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
     executorRef: input.worker.executorRef,
     parentTaskId: input.worker.parentTaskId,
     taskPrUrl: input.worker.taskPrUrl,
+    repairTargetPrUrl: input.worker.repairTargetPrUrl,
     baseRef,
     exec,
     worker: input.worker,
@@ -2907,6 +3134,48 @@ function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
       nextAction: "Ensure `origin` points at GitHub, push the branch, open a PR, and rerun `kynver worker complete`."
     };
   }
+  const repairTarget = input.worker.repairTargetPrUrl?.trim();
+  if (repairTarget) {
+    let committed2 = false;
+    let pushed2 = false;
+    let headCommit2 = snapshot.headCommit ?? resolveHeadCommit(snapshot.worktreePath, exec) ?? void 0;
+    if (snapshot.changedFiles.length > 0) {
+      const pushResult2 = commitAndPushBranch({
+        worktreePath: snapshot.worktreePath,
+        branch: snapshot.branch,
+        commitMessage: `fix(harness): repair target PR ${repairTarget}`,
+        hasDirtyFiles: true,
+        exec
+      });
+      if (!pushResult2.ok) {
+        return {
+          ok: false,
+          reason: `PR-ready handoff blocked: ${pushResult2.detail ?? "git commit/push failed"}`,
+          nextAction: "Commit and push to the target PR branch, then rerun `kynver worker complete`."
+        };
+      }
+      committed2 = pushResult2.committed;
+      pushed2 = pushResult2.pushed;
+      headCommit2 = pushResult2.headCommit ?? headCommit2;
+    } else {
+      const pushOnly = exec.git(snapshot.worktreePath, ["push", "-u", "origin", snapshot.branch]);
+      if (pushOnly.status !== 0 && !/already up to date/i.test(pushOnly.stderr || pushOnly.stdout)) {
+        return {
+          ok: false,
+          reason: `PR-ready handoff blocked: ${pushOnly.stderr || pushOnly.stdout || "git push failed"}`,
+          nextAction: "Push the target branch to origin, then rerun `kynver worker complete`."
+        };
+      }
+      pushed2 = pushOnly.status === 0;
+    }
+    return {
+      ok: true,
+      prUrl: repairTarget,
+      headCommit: headCommit2,
+      committed: committed2,
+      pushed: pushed2
+    };
+  }
   const existing = findOpenPrUrl(snapshot.worktreePath, repo, snapshot.branch, exec);
   if (existing) {
     return {
@@ -3018,12 +3287,12 @@ 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 record3 = asRecord2(finalResult);
+  if (!record3) return [];
+  const nested = asRecord2(record3.worktreeHandoff);
   const fromNested = stringList(nested?.disposableArtifactsRemoved);
   if (fromNested.length) return fromNested;
-  return stringList(record.disposableArtifactsRemoved);
+  return stringList(record3.disposableArtifactsRemoved);
 }
 function normalizeRelativePath(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
@@ -3034,13 +3303,13 @@ function dirtyPathsCoveredByDisposableRemoval(changedFiles, removed) {
   if (removed.length === 0) return false;
   const removedSet = new Set(removed.map((p) => normalizeRelativePath(p)));
   return material.every((line) => {
-    const path44 = normalizeRelativePath(pathFromGitStatusLine(line));
-    return removedSet.has(path44);
+    const path51 = normalizeRelativePath(pathFromGitStatusLine(line));
+    return removedSet.has(path51);
   });
 }
 
 // src/worktree-completion-handoff.ts
-function trimOrNull5(value) {
+function trimOrNull6(value) {
   if (typeof value !== "string") return null;
   const t = value.trim();
   return t.length ? t : null;
@@ -3067,7 +3336,7 @@ function assessWorktreeCompletionHandoff(input) {
   const materialDirty = materialWorktreeChanges(rawDirty);
   const removed = mergedDisposableRemoved(input);
   const effectivelyClean = materialDirty.length === 0 || dirtyPathsCoveredByDisposableRemoval(rawDirty, removed);
-  if (trimOrNull5(input.prUrl)) {
+  if (trimOrNull6(input.prUrl)) {
     if (!effectivelyClean) {
       return {
         allowed: false,
@@ -3078,7 +3347,7 @@ function assessWorktreeCompletionHandoff(input) {
     }
     return { allowed: true, state: "pr_handoff", materialDirtyCount: 0 };
   }
-  if (trimOrNull5(input.headCommit)) {
+  if (trimOrNull6(input.headCommit)) {
     if (!effectivelyClean) {
       return {
         allowed: false,
@@ -3089,7 +3358,7 @@ function assessWorktreeCompletionHandoff(input) {
     }
     return { allowed: true, state: "commit_handoff", materialDirtyCount: 0 };
   }
-  if (trimOrNull5(input.artifactBundlePath) || trimOrNull5(input.patchPath)) {
+  if (trimOrNull6(input.artifactBundlePath) || trimOrNull6(input.patchPath)) {
     if (!effectivelyClean) {
       return {
         allowed: false,
@@ -3819,6 +4088,19 @@ function spawnCompletionSidecar(opts) {
   }
 }
 
+// src/repair-target-worktree.ts
+function addWorktreeForRepairBranch(repo, worktreePath, branch) {
+  git(repo, ["fetch", "origin", branch, "--prune"], { allowFailure: true });
+  const remoteRef = `origin/${branch}`;
+  const added = gitCapture(repo, ["worktree", "add", "-B", branch, worktreePath, remoteRef]);
+  if (added.status === 0) return;
+  const fallback = gitCapture(repo, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+  if (fallback.status !== 0) {
+    const detail = added.stderr || added.stdout || fallback.stderr || fallback.stdout || "git worktree add failed for repair target branch";
+    throw new Error(detail);
+  }
+}
+
 // src/supervisor.ts
 function spawnWorkerProcess(run, opts) {
   const rawName = typeof opts.name === "string" ? opts.name.trim() : "";
@@ -3829,13 +4111,14 @@ function spawnWorkerProcess(run, opts) {
   if (run.workers?.[name]) throw new Error(`worker already exists in run ${run.id}: ${name}`);
   if (!opts.task) throw new Error(`missing task text for worker ${name}`);
   const routing = opts.routingRule || opts.requestedModel ? {
-    provider: opts.provider || "claude",
+    provider: opts.provider || DEFAULT_WORKER_PROVIDER,
     model: opts.model,
     rule: opts.routingRule || "explicit:spawn",
     requestedModel: opts.requestedModel ?? opts.model
   } : resolveWorkerLaunch({
     explicitModel: opts.model,
-    explicitProvider: opts.provider
+    explicitProvider: opts.provider,
+    explicitProviderIsOperatorOverride: Boolean(opts.provider?.trim())
   });
   const provider = resolveWorkerProvider(routing.provider);
   let launchModel = routing.model;
@@ -3855,10 +4138,15 @@ function spawnWorkerProcess(run, opts) {
   const workerDir = path14.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
   const worktreePath = path14.join(worktreesDir, run.id, name);
-  const branch = opts.branch || `agent/${run.id}/${name}`;
+  const repairBranch = opts.repairTargetBranch?.trim() || void 0;
+  const branch = repairBranch || opts.branch || `agent/${run.id}/${name}`;
   if (existsSync13(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
   git(run.repo, ["fetch", "origin", "--prune"], { allowFailure: true });
-  git(run.repo, ["worktree", "add", "-b", branch, worktreePath, run.baseCommit], { throwError: true });
+  if (repairBranch) {
+    addWorktreeForRepairBranch(run.repo, worktreePath, repairBranch);
+  } else {
+    git(run.repo, ["worktree", "add", "-b", branch, worktreePath, run.baseCommit], { throwError: true });
+  }
   const stdoutPath = path14.join(workerDir, "stdout.jsonl");
   const stderrPath = path14.join(workerDir, "stderr.log");
   const heartbeatPath = path14.join(workerDir, "heartbeat.jsonl");
@@ -3871,7 +4159,9 @@ function spawnWorkerProcess(run, opts) {
     taskId: opts.taskId,
     instructionPolicyMarkdown: opts.instructionPolicyMarkdown,
     personaMarkdown: opts.personaMarkdown,
-    model: launchModel
+    model: launchModel,
+    repairTargetPrUrl: opts.repairTargetPrUrl,
+    repairTargetBranch: opts.repairTargetBranch ?? (repairBranch || void 0)
   });
   let started;
   try {
@@ -3924,6 +4214,8 @@ function spawnWorkerProcess(run, opts) {
     ...opts.parentTaskId ? { parentTaskId: String(opts.parentTaskId) } : {},
     ...opts.taskTitle ? { taskTitle: String(opts.taskTitle) } : {},
     ...opts.taskPrUrl ? { taskPrUrl: String(opts.taskPrUrl) } : {},
+    ...opts.repairTargetPrUrl ? { repairTargetPrUrl: String(opts.repairTargetPrUrl) } : {},
+    ...opts.repairTargetBranch ? { repairTargetBranch: String(opts.repairTargetBranch) } : {},
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveWorker(run.id, worker);
@@ -4595,6 +4887,24 @@ function extractPlanOutboxFromTask(task) {
   };
 }
 
+// src/runner-identity.ts
+import os3 from "node:os";
+function trimOrNull7(value) {
+  if (!value?.trim()) return null;
+  return value.trim();
+}
+function resolveRunnerPresencePayload(input = {}) {
+  const env = input.env ?? process.env;
+  const runnerId = trimOrNull7(env.KYNVER_RUNTIME_ID) ?? trimOrNull7(env.OPENCLAW_RUNTIME_ID) ?? trimOrNull7(env.HOSTNAME) ?? os3.hostname();
+  return {
+    runnerId,
+    hostname: trimOrNull7(env.HOSTNAME) ?? os3.hostname(),
+    profile: trimOrNull7(env.KYNVER_RUNNER_PROFILE) ?? trimOrNull7(env.OPENCLAW_RUNNER_PROFILE),
+    harnessRepo: trimOrNull7(env.KYNVER_HARNESS_REPO) ?? trimOrNull7(env.KYNVER_DEFAULT_REPO),
+    runId: input.runId ?? null
+  };
+}
+
 // src/dispatch.ts
 var DEFAULT_DISPATCH_LEASE_MS = 60 * 60 * 1e3;
 function readHarnessWorkerContext(decision) {
@@ -4659,7 +4969,8 @@ async function dispatchRun(args) {
     const secret = await resolveCallbackSecretWithMint(args.secret ? String(args.secret) : void 0, agentOsId, { baseUrl: base });
     const execute = args.execute === true || args.execute === "true";
     const dryRun = !execute;
-    const leaseOwner = `kynver-harness:${run.id}`;
+    const runnerPresence = resolveRunnerPresencePayload({ runId: run.id });
+    const leaseOwner = `kynver-harness:${run.id}@runner:${runnerPresence.runnerId}`;
     const runnerDiskGate = args.diskPath ? observeRunnerDiskGate({ diskPath: String(args.diskPath) }) : observeRunnerDiskGate({ diskPath: run.repo });
     const runnerResourceGate = observeRunnerResourceGate({ runId: run.id });
     const requestedStarts = Number(args.maxStarts) > 0 ? Math.floor(Number(args.maxStarts)) : 1;
@@ -4671,11 +4982,18 @@ async function dispatchRun(args) {
         void 0
       );
       if (!worker?.taskId || !isPidAlive(worker.pid)) continue;
+      const ownedPaths = Array.isArray(worker.ownedPaths) ? worker.ownedPaths.filter((p) => typeof p === "string") : [];
+      const writeSetPrefixes = Array.isArray(
+        worker.writeSetPrefixes
+      ) ? (worker.writeSetPrefixes ?? []).filter((p) => typeof p === "string") : [];
       activeHarnessWorkers.push({
         runId: run.id,
         workerName: name,
         taskId: worker.taskId,
-        pid: worker.pid
+        pid: worker.pid,
+        ...ownedPaths.length ? { ownedPaths } : {},
+        ...writeSetPrefixes.length ? { writeSetPrefixes } : {},
+        ...worker.allowConcurrentHotspot ? { allowConcurrentHotspot: true } : {}
       });
     }
     const dispatchUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/dispatch-next`;
@@ -4688,6 +5006,7 @@ async function dispatchRun(args) {
       runnerDiskGate,
       runnerResourceGate,
       activeHarnessWorkers,
+      runnerPresence,
       harnessBoardSnapshot: buildRunBoard(run.id),
       ...args.lane ? { lane: String(args.lane) } : {},
       executor: args.executor ? String(args.executor) : "harness",
@@ -4780,10 +5099,19 @@ async function dispatchRun(args) {
       const name = safeSlug(`t-${task.id}-a${task.attempt}`);
       const routing = resolveWorkerLaunch({
         explicitModel: args.model ? String(args.model) : void 0,
+        explicitProvider: args.provider ? String(args.provider) : void 0,
+        explicitProviderIsOperatorOverride: Boolean(args.provider),
         task: enrichTaskForModelRouting(task)
       });
       try {
         const planId = task.planId ? String(task.planId) : void 0;
+        const repairTarget = resolveHarnessRepairTargetFromTask({
+          title: task.title ? String(task.title) : void 0,
+          description: task.description ? String(task.description) : null,
+          executorRef: task.executorRef ? String(task.executorRef) : null,
+          prUrl: task.prUrl ? String(task.prUrl) : null,
+          branch: task.branch ? String(task.branch) : null
+        });
         const worker = spawnWorkerProcess(run, {
           name,
           task: buildDispatchTaskText(task, agentOsId),
@@ -4795,10 +5123,13 @@ async function dispatchRun(args) {
           agentOsId,
           taskId: String(task.id),
           planId,
+          branch: repairTarget?.targetPrBranch ?? void 0,
           executorRef: task.executorRef ? String(task.executorRef) : void 0,
           parentTaskId: task.parentTaskId ? String(task.parentTaskId) : void 0,
           taskTitle: task.title ? String(task.title) : void 0,
-          taskPrUrl: task.prUrl ? String(task.prUrl) : void 0,
+          taskPrUrl: repairTarget?.targetPrUrl ?? (task.prUrl ? String(task.prUrl) : void 0),
+          repairTargetPrUrl: repairTarget?.targetPrUrl,
+          repairTargetBranch: repairTarget?.targetPrBranch ?? void 0,
           instructionPolicyMarkdown: harnessContext?.instructionPolicyMarkdown ?? null,
           instructionPolicyFingerprint: harnessContext?.instructionPolicyFingerprint ?? null,
           instructionPolicyEvidence: harnessContext?.instructionPolicyEvidence ?? null,
@@ -4876,6 +5207,58 @@ async function dispatchRun(args) {
   }
 }
 
+// src/box-resource-snapshot.ts
+import os5 from "node:os";
+
+// src/box-resource-snapshot-shared.ts
+import os4 from "node:os";
+function resolveBoxKindFromEnv(env = process.env) {
+  const kind = (env.KYNVER_BOX_KIND ?? env.KYNVER_AGENT_OS_SLUG ?? "forge").trim().toLowerCase();
+  if (kind === "ghost" || kind === "forge") return kind;
+  return kind || "forge";
+}
+function defaultBoxId(boxKind, hostLabel) {
+  const host = (hostLabel ?? os4.hostname()).trim().toLowerCase().replace(/\s+/g, "-") || "unknown-host";
+  return `${boxKind}:${host}`;
+}
+
+// src/box-resource-snapshot.ts
+function buildBoxResourceSnapshotFromGate(gate, input = {}) {
+  const boxKind = (input.boxKind ?? resolveBoxKindFromEnv()).trim().toLowerCase() || "forge";
+  const hostLabel = input.hostLabel ?? os5.hostname();
+  const boxId = input.boxId ?? defaultBoxId(boxKind, hostLabel);
+  return {
+    boxId,
+    boxKind,
+    displayName: input.displayName ?? null,
+    hostLabel,
+    observedAt: input.observedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    totalMemBytes: gate.totalMemBytes,
+    freeMemBytes: gate.freeMemBytes,
+    activeWorkers: gate.activeWorkers,
+    maxConcurrentWorkers: gate.maxConcurrentWorkers,
+    autoCap: gate.autoCap,
+    slotsAvailable: gate.slotsAvailable,
+    harnessRunId: input.harnessRunId ?? null,
+    queuedTasks: input.queuedTasks ?? null,
+    reason: gate.reason,
+    ...input.prEvidence?.length ? { prEvidence: input.prEvidence } : {}
+  };
+}
+function formatHeartbeatLine(input) {
+  const row = {
+    ts: input.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    phase: input.phase,
+    summary: input.summary,
+    changedFiles: input.changedFiles ?? [],
+    blocker: input.blocker ?? null
+  };
+  if (input.boxResourceSnapshot) row.boxResourceSnapshot = input.boxResourceSnapshot;
+  if (input.prEvidence?.length) row.prEvidence = input.prEvidence;
+  return `${JSON.stringify(row)}
+`;
+}
+
 // src/fortress-engagement-gate.ts
 function isEngagementRequiredSkip(skip) {
   if (skip.skipReason === "engagement_required") return true;
@@ -5094,79 +5477,365 @@ function validateTailLines(lines) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync5 } from "node:fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync5 } from "node:fs";
+import path25 from "node:path";
+
+// src/run-list.ts
+import { existsSync as existsSync17, readFileSync as readFileSync11 } from "node:fs";
+import path23 from "node:path";
+
+// src/stale-reconcile.ts
 import path22 from "node:path";
 
-// src/default-repo.ts
+// src/finalize.ts
 import path21 from "node:path";
-function expandConfiguredRepo(value) {
-  return path21.resolve(resolveUserPath(value.trim()));
-}
-function fromConfigured(value, source, persistedInConfig) {
-  const trimmed = value?.trim();
-  if (!trimmed) return null;
-  return {
-    repo: expandConfiguredRepo(trimmed),
-    source,
-    persistedInConfig
-  };
-}
-function resolveDefaultRepo(opts = {}) {
-  const env = opts.env ?? process.env;
-  const config = opts.config ?? loadUserConfig();
-  const fromConfig = fromConfigured(config.defaultRepo, "config", true);
-  if (fromConfig) return fromConfig;
-  const fromDefaultEnv = fromConfigured(env.KYNVER_DEFAULT_REPO, "env_default_repo", false);
-  if (fromDefaultEnv) return fromDefaultEnv;
-  const fromHarnessEnv = fromConfigured(env.KYNVER_HARNESS_REPO, "env_harness_repo", false);
-  if (fromHarnessEnv) return fromHarnessEnv;
-  const discovered = discoverDefaultRepo({
-    cwd: opts.cwd,
-    runtimeModuleUrl: opts.runtimeModuleUrl
-  });
-  if (!discovered) return null;
-  return {
-    repo: discovered.repo,
-    source: discovered.source,
-    persistedInConfig: false
-  };
-}
-function persistDefaultRepo(repo, existing) {
-  const config = {
-    ...existing ?? loadUserConfig(),
-    defaultRepo: redactHomePath(path21.resolve(repo))
-  };
-  saveUserConfig(config);
-  return config;
-}
-function remediateDefaultRepo(opts) {
-  const existing = opts?.config ?? loadUserConfig();
-  const resolved = resolveDefaultRepo({ ...opts, config: existing });
-  if (!resolved) {
-    return {
-      ok: false,
-      reason: "No Kynver git checkout found. Clone the repo, cd into it, then run `kynver setup --repo /path/to/Kynver` (or export KYNVER_DEFAULT_REPO)."
-    };
-  }
-  if (resolved.persistedInConfig) {
-    return { ok: true, resolved, config: existing };
+var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "running",
+  "dispatching",
+  "pending",
+  "queued",
+  "needs_attention"
+]);
+var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "done"]);
+function deriveTerminalRunStatus(run) {
+  const names = Object.keys(run.workers || {});
+  if (names.length === 0) return "failed";
+  let anyAlive = false;
+  let anyResult = false;
+  let anyCompletionBlocked = false;
+  let anyLandingBlocked = false;
+  for (const name of names) {
+    const worker = readJson(
+      path21.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
+    );
+    if (!worker) continue;
+    const status = computeWorkerStatus(worker, {
+      base: run.base,
+      baseCommit: run.baseCommit
+    });
+    if (status.alive && !status.finalResult) {
+      anyAlive = true;
+      break;
+    }
+    if (typeof worker.completionBlocker === "string" && worker.completionBlocker) {
+      anyCompletionBlocked = true;
+    }
+    if (isLandingBlockedWorkerStatus(status)) {
+      anyLandingBlocked = true;
+    }
+    if (status.finalResult && status.attention.state === "done") anyResult = true;
   }
-  const config = persistDefaultRepo(resolved.repo, existing);
-  return {
-    ok: true,
-    resolved: { ...resolved, persistedInConfig: true, source: "config" },
-    config
-  };
+  if (anyAlive) return null;
+  if (anyCompletionBlocked) return null;
+  if (anyLandingBlocked) return null;
+  return anyResult ? "completed" : "failed";
 }
-function formatResolvedDefaultRepo(resolved) {
-  return {
-    defaultRepo: displayUserPath(resolved.repo),
-    source: resolved.source,
-    persistedInConfig: resolved.persistedInConfig
-  };
+function finalizeStaleRuns() {
+  const finalized = [];
+  for (const run of listRunRecords()) {
+    if (!ACTIVE_RUN_STATUSES.has(run.status)) continue;
+    const next = deriveTerminalRunStatus(run);
+    if (!next || next === run.status) continue;
+    const from = run.status;
+    run.status = next;
+    saveRun(run);
+    finalized.push({ runId: run.id, from, to: next });
+  }
+  return finalized;
 }
 
-// src/worktree.ts
+// src/stale-reconcile.ts
+var STALE_RECONCILE_HEARTBEAT_MS = 15 * 60 * 1e3;
+function staleReconcileDisabled() {
+  return process.env.KYNVER_NO_STALE_CLEANUP === "1";
+}
+function reconcileStaleWorkers() {
+  if (staleReconcileDisabled()) {
+    return { workers: [], finalizedRuns: finalizeStaleRuns() };
+  }
+  const outcomes = [];
+  const now = Date.now();
+  for (const run of listRunRecords()) {
+    for (const name of Object.keys(run.workers || {})) {
+      const workerPath = path22.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const worker = readJson(workerPath, void 0);
+      if (!worker || worker.status !== "running") {
+        outcomes.push({
+          runId: run.id,
+          worker: name,
+          action: "skipped",
+          reason: worker ? `worker status is ${worker.status}` : "worker.json missing"
+        });
+        continue;
+      }
+      const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
+      if (status.finalResult) {
+        if (worker.status === "running") {
+          const nextStatus = status.attention.state === "blocked" ? "blocked" : status.attention.state === "done" || status.status === "done" ? "done" : "exited";
+          worker.status = nextStatus;
+          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+          worker.reconcileReason = "synced finished worker record after terminal stdout/heartbeat";
+          saveWorker(run.id, worker);
+          outcomes.push({
+            runId: run.id,
+            worker: name,
+            action: "marked_exited",
+            reason: worker.reconcileReason
+          });
+        } else {
+          outcomes.push({ runId: run.id, worker: name, action: "skipped", reason: "final result present" });
+        }
+        continue;
+      }
+      if (!status.alive) {
+        const nextStatus = status.attention.state === "blocked" ? "blocked" : status.status === "done" ? "done" : "exited";
+        worker.status = nextStatus;
+        worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+        worker.reconcileReason = status.attention.reason;
+        saveWorker(run.id, worker);
+        outcomes.push({
+          runId: run.id,
+          worker: name,
+          action: "marked_exited",
+          reason: status.attention.reason
+        });
+        continue;
+      }
+      if (status.attention.state === "stale" && worker.pid && isPidAlive(worker.pid)) {
+        const hbMs = status.lastHeartbeatAt ? Date.parse(status.lastHeartbeatAt) : NaN;
+        const actMs = status.lastActivityAt ? Date.parse(status.lastActivityAt) : NaN;
+        const hbStale = !Number.isFinite(hbMs) || now - hbMs > STALE_RECONCILE_HEARTBEAT_MS;
+        const actStale = Number.isFinite(actMs) && now - actMs > STALE_MS;
+        if (hbStale && actStale) {
+          killWorkerProcess(worker.pid, "SIGTERM");
+          worker.status = "exited";
+          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+          worker.reconcileReason = `reconciled stale worker: ${status.attention.reason}`;
+          saveWorker(run.id, worker);
+          outcomes.push({
+            runId: run.id,
+            worker: name,
+            action: "killed_stale",
+            reason: status.attention.reason
+          });
+          continue;
+        }
+      }
+      outcomes.push({
+        runId: run.id,
+        worker: name,
+        action: "skipped",
+        reason: status.attention.reason
+      });
+    }
+  }
+  return { workers: outcomes, finalizedRuns: finalizeStaleRuns() };
+}
+function reconcileRunsCli() {
+  const result = reconcileStaleWorkers();
+  const markedExited = result.workers.filter((w) => w.action === "marked_exited").length;
+  const killedStale = result.workers.filter((w) => w.action === "killed_stale").length;
+  const skipped = result.workers.filter((w) => w.action === "skipped").length;
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        workers: { markedExited, killedStale, skipped, total: result.workers.length },
+        finalizedRuns: result.finalizedRuns.length,
+        details: { workers: result.workers, finalizedRuns: result.finalizedRuns }
+      },
+      null,
+      2
+    )
+  );
+}
+
+// src/run-list.ts
+function heartbeatByteLength(heartbeatPath) {
+  if (!heartbeatPath || !existsSync17(heartbeatPath)) return 0;
+  try {
+    return readFileSync11(heartbeatPath, "utf8").trim().length;
+  } catch {
+    return 0;
+  }
+}
+function workerEvidence(run, workerName) {
+  const workerPath = path23.join(runDirectory(run.id), "workers", safeSlug(workerName), "worker.json");
+  const worker = readJson(workerPath, void 0);
+  if (!worker) {
+    return {
+      worker: workerName,
+      workerStatus: "missing",
+      attention: "needs_attention",
+      attentionReason: "worker.json missing",
+      missingHeartbeat: true,
+      missingFinalResult: true,
+      landingBlocked: false,
+      completionBlocked: false
+    };
+  }
+  const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
+  const missingHeartbeat = heartbeatByteLength(worker.heartbeatPath) === 0;
+  const missingFinalResult = !status.finalResult && !status.alive;
+  const completionBlocked = typeof worker.completionBlocker === "string" && worker.completionBlocker.length > 0;
+  return {
+    worker: workerName,
+    workerStatus: worker.status,
+    attention: status.attention.state,
+    attentionReason: status.attention.reason,
+    missingHeartbeat,
+    missingFinalResult,
+    landingBlocked: isLandingBlockedWorkerStatus(status),
+    completionBlocked
+  };
+}
+function deriveFinalizeBlockedReason(input) {
+  if (input.openWorkerCount > 0) return "active_workers";
+  if (input.workers.some((w) => w.completionBlocked)) return "completion_blocked";
+  if (input.workers.some((w) => w.landingBlocked)) return "landing_blocked";
+  return null;
+}
+function aggregateRunAttention(workers) {
+  const rank = {
+    blocked: 5,
+    needs_attention: 4,
+    stale: 3,
+    done: 2,
+    ok: 1
+  };
+  let best = "ok";
+  let reason;
+  for (const w of workers) {
+    const state = w.attention;
+    if ((rank[state] ?? 0) >= (rank[best] ?? 0)) {
+      best = state;
+      reason = w.attentionReason;
+    }
+  }
+  return { attention: best, attentionReason: reason };
+}
+function countOpenWorkers(run) {
+  let open = 0;
+  for (const name of Object.keys(run.workers || {})) {
+    const workerPath = path23.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+    const worker = readJson(workerPath, void 0);
+    if (!worker) continue;
+    const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
+    if (status.alive && !status.finalResult) open += 1;
+  }
+  return open;
+}
+function buildRunListRows() {
+  reconcileStaleWorkers();
+  return listRunRecords().map((run) => {
+    const workerNames = Object.keys(run.workers || {});
+    const workers = workerNames.map((name) => workerEvidence(run, name));
+    const missingHeartbeatWorkers = workers.filter((w) => w.missingHeartbeat).map((w) => w.worker);
+    const missingFinalResultWorkers = workers.filter((w) => w.missingFinalResult).map((w) => w.worker);
+    const landingBlockedWorkers = workers.filter((w) => w.landingBlocked).map((w) => w.worker);
+    const completionBlockedWorkers = workers.filter((w) => w.completionBlocked).map((w) => w.worker);
+    const { attention, attentionReason } = aggregateRunAttention(workers);
+    const openWorkerCount = countOpenWorkers(run);
+    const effectiveStatus = deriveRunStatus(
+      run.status,
+      workers.map((w) => ({ attention: w.attention, status: w.workerStatus }))
+    );
+    return {
+      id: run.id,
+      name: run.name,
+      status: run.status,
+      effectiveStatus,
+      repo: run.repo,
+      createdAt: run.createdAt,
+      openWorkerCount,
+      attention,
+      attentionReason,
+      finalizeBlockedReason: deriveFinalizeBlockedReason({ run, workers, openWorkerCount }),
+      evidence: {
+        missingHeartbeatWorkers,
+        missingFinalResultWorkers,
+        landingBlockedWorkers,
+        completionBlockedWorkers,
+        workers
+      }
+    };
+  });
+}
+function listRunsCli() {
+  console.log(JSON.stringify(buildRunListRows(), null, 2));
+}
+
+// src/default-repo.ts
+import path24 from "node:path";
+function expandConfiguredRepo(value) {
+  return path24.resolve(resolveUserPath(value.trim()));
+}
+function fromConfigured(value, source, persistedInConfig) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  return {
+    repo: expandConfiguredRepo(trimmed),
+    source,
+    persistedInConfig
+  };
+}
+function resolveDefaultRepo(opts = {}) {
+  const env = opts.env ?? process.env;
+  const config = opts.config ?? loadUserConfig();
+  const fromConfig = fromConfigured(config.defaultRepo, "config", true);
+  if (fromConfig) return fromConfig;
+  const fromDefaultEnv = fromConfigured(env.KYNVER_DEFAULT_REPO, "env_default_repo", false);
+  if (fromDefaultEnv) return fromDefaultEnv;
+  const fromHarnessEnv = fromConfigured(env.KYNVER_HARNESS_REPO, "env_harness_repo", false);
+  if (fromHarnessEnv) return fromHarnessEnv;
+  const discovered = discoverDefaultRepo({
+    cwd: opts.cwd,
+    runtimeModuleUrl: opts.runtimeModuleUrl
+  });
+  if (!discovered) return null;
+  return {
+    repo: discovered.repo,
+    source: discovered.source,
+    persistedInConfig: false
+  };
+}
+function persistDefaultRepo(repo, existing) {
+  const config = {
+    ...existing ?? loadUserConfig(),
+    defaultRepo: redactHomePath(path24.resolve(repo))
+  };
+  saveUserConfig(config);
+  return config;
+}
+function remediateDefaultRepo(opts) {
+  const existing = opts?.config ?? loadUserConfig();
+  const resolved = resolveDefaultRepo({ ...opts, config: existing });
+  if (!resolved) {
+    return {
+      ok: false,
+      reason: "No Kynver git checkout found. Clone the repo, cd into it, then run `kynver setup --repo /path/to/Kynver` (or export KYNVER_DEFAULT_REPO)."
+    };
+  }
+  if (resolved.persistedInConfig) {
+    return { ok: true, resolved, config: existing };
+  }
+  const config = persistDefaultRepo(resolved.repo, existing);
+  return {
+    ok: true,
+    resolved: { ...resolved, persistedInConfig: true, source: "config" },
+    config
+  };
+}
+function formatResolvedDefaultRepo(resolved) {
+  return {
+    defaultRepo: displayUserPath(resolved.repo),
+    source: resolved.source,
+    persistedInConfig: resolved.persistedInConfig
+  };
+}
+
+// src/worktree.ts
 function resolveCreateRunRepo(args) {
   const explicit = typeof args.repo === "string" ? args.repo.trim() : "";
   if (explicit) return explicit;
@@ -5180,7 +5849,7 @@ function createRun(args) {
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync17(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync18(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();
@@ -5194,19 +5863,11 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path22.join(dir, "run.json"), run);
+  writeJson(path25.join(dir, "run.json"), run);
   console.log(JSON.stringify({ runId: id, runDir: dir, repo, base, baseCommit }, null, 2));
 }
 function listRuns() {
-  const { runsDir } = getPaths();
-  const rows = listRunIds(runsDir).map((id) => readJson(path22.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
-    id: run.id,
-    name: run.name,
-    status: run.status,
-    repo: run.repo,
-    createdAt: run.createdAt
-  }));
-  console.log(JSON.stringify(rows, null, 2));
+  listRunsCli();
 }
 function failExists(message) {
   console.error(message);
@@ -5214,7 +5875,7 @@ function failExists(message) {
 }
 
 // src/sweep.ts
-import path23 from "node:path";
+import path26 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -5227,7 +5888,7 @@ async function sweepRun(args) {
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path23.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path26.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
@@ -5270,14 +5931,14 @@ async function sweepRun(args) {
 }
 
 // src/harness-storage-snapshot.ts
-import { existsSync as existsSync19, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
-import path25 from "node:path";
+import { existsSync as existsSync20, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import path28 from "node:path";
 
 // src/cleanup-dir-size.ts
-import { existsSync as existsSync18, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
-import path24 from "node:path";
+import { existsSync as existsSync19, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
+import path27 from "node:path";
 function directorySizeBytes(root, maxEntries = 5e4) {
-  if (!existsSync18(root)) return 0;
+  if (!existsSync19(root)) return 0;
   let total = 0;
   let seen = 0;
   const stack = [root];
@@ -5291,7 +5952,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path24.join(current, name);
+      const full = path27.join(current, name);
       let st;
       try {
         st = statSync2(full);
@@ -5308,10 +5969,10 @@ function directorySizeBytes(root, maxEntries = 5e4) {
 // src/harness-storage-snapshot.ts
 function harnessStorageSnapshot(opts = {}) {
   const harnessRoot = opts.harnessRoot ?? resolveHarnessRoot();
-  const worktreesDir = path25.join(harnessRoot, "worktrees");
+  const worktreesDir = path28.join(harnessRoot, "worktrees");
   const now = opts.now ?? Date.now();
   const scannedAt = new Date(now).toISOString();
-  if (!existsSync19(worktreesDir)) {
+  if (!existsSync20(worktreesDir)) {
     return {
       harnessRoot,
       worktreesDir,
@@ -5343,7 +6004,7 @@ function harnessStorageSnapshot(opts = {}) {
   for (const runEntry of entries) {
     if (!runEntry.isDirectory()) continue;
     runCount += 1;
-    const runPath = path25.join(worktreesDir, runEntry.name);
+    const runPath = path28.join(worktreesDir, runEntry.name);
     try {
       const st = statSync3(runPath);
       oldestMs = oldestMs === null ? st.mtimeMs : Math.min(oldestMs, st.mtimeMs);
@@ -5377,149 +6038,58 @@ function harnessStorageSnapshot(opts = {}) {
   };
 }
 
-// src/cleanup-orphan-safety.ts
-import { existsSync as existsSync20, statSync as statSync4 } from "node:fs";
-import path26 from "node:path";
+// src/cleanup.ts
+import path38 from "node:path";
+
+// src/cleanup-guards.ts
+import path29 from "node:path";
+
+// src/cleanup-run-liveness.ts
+function isWorkerProcessLive(indexed) {
+  if (indexed.status.alive) return true;
+  if (indexed.worker.status === "running") return true;
+  return false;
+}
+function isRunStaleActive(indexed) {
+  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
+  return deriveTerminalRunStatus(indexed.run) !== null;
+}
+function runBlocksWorktreeRemoval(indexed) {
+  if (isWorkerProcessLive(indexed)) return true;
+  if (indexed.worker.completionBlocker) return true;
+  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
+  if (isRunStaleActive(indexed)) return false;
+  if (!isFinishedWorkerStatus(indexed.status)) return true;
+  return deriveTerminalRunStatus(indexed.run) === null;
+}
+
+// src/cleanup-build-cache-paths.ts
+var HARNESS_BUILD_CACHE_RELATIVE_PATHS = [
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  ".cache",
+  "node_modules/.cache"
+];
+function isGeneratedHarnessPath(pathPart) {
+  const normalized = pathPart.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (normalized === "node_modules" || normalized.startsWith("node_modules/")) return true;
+  for (const rel of HARNESS_BUILD_CACHE_RELATIVE_PATHS) {
+    if (normalized === rel || normalized.startsWith(`${rel}/`)) return true;
+  }
+  return false;
+}
 
 // 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/");
+    return !isGeneratedHarnessPath(pathPart);
   });
 }
 
-// src/cleanup-orphan-safety.ts
-var DEFAULT_HEARTBEAT_FRESH_MS = 30 * 60 * 1e3;
-function assessOrphanWorktreeSafety(input) {
-  const now = input.now ?? Date.now();
-  const heartbeatFreshMs = input.heartbeatFreshMs ?? DEFAULT_HEARTBEAT_FRESH_MS;
-  if (!existsSync20(input.worktreePath)) return null;
-  if (input.runId && input.workerName) {
-    const heartbeatPath = path26.join(
-      input.harnessRoot,
-      "runs",
-      input.runId,
-      "workers",
-      input.workerName,
-      "heartbeat.jsonl"
-    );
-    try {
-      const mtime = statSync4(heartbeatPath).mtimeMs;
-      if (now - mtime < heartbeatFreshMs) return "active_worker";
-    } catch {
-    }
-  }
-  const gitDir = path26.join(input.worktreePath, ".git");
-  if (!existsSync20(gitDir)) return null;
-  const porcelain = gitCapture(input.worktreePath, ["status", "--porcelain"]);
-  if (porcelain.status !== 0) return "pr_or_unmerged_commits";
-  const dirtyLines = porcelain.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-  if (materialWorktreeChanges2(dirtyLines).length > 0) return "dirty_worktree";
-  const upstreamAhead = gitCapture(input.worktreePath, [
-    "rev-list",
-    "--count",
-    "@{u}..HEAD"
-  ]);
-  if (upstreamAhead.status === 0) {
-    const count = Number(upstreamAhead.stdout.trim());
-    if (Number.isFinite(count) && count > 0) return "pr_or_unmerged_commits";
-  }
-  const mainAhead = gitCapture(input.worktreePath, [
-    "rev-list",
-    "--count",
-    "origin/main..HEAD"
-  ]);
-  if (mainAhead.status !== 0) {
-    if (upstreamAhead.status !== 0) return "pr_or_unmerged_commits";
-    return null;
-  }
-  const mainCount = Number(mainAhead.stdout.trim());
-  if (Number.isFinite(mainCount) && mainCount > 0) return "pr_or_unmerged_commits";
-  return null;
-}
-
-// src/cleanup.ts
-import path31 from "node:path";
-
-// src/finalize.ts
-import path27 from "node:path";
-var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set([
-  "running",
-  "dispatching",
-  "pending",
-  "queued",
-  "needs_attention"
-]);
-var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "done"]);
-function deriveTerminalRunStatus(run) {
-  const names = Object.keys(run.workers || {});
-  if (names.length === 0) return "failed";
-  let anyAlive = false;
-  let anyResult = false;
-  let anyCompletionBlocked = false;
-  let anyLandingBlocked = false;
-  for (const name of names) {
-    const worker = readJson(
-      path27.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-      void 0
-    );
-    if (!worker) continue;
-    const status = computeWorkerStatus(worker, {
-      base: run.base,
-      baseCommit: run.baseCommit
-    });
-    if (status.alive && !status.finalResult) {
-      anyAlive = true;
-      break;
-    }
-    if (typeof worker.completionBlocker === "string" && worker.completionBlocker) {
-      anyCompletionBlocked = true;
-    }
-    if (isLandingBlockedWorkerStatus(status)) {
-      anyLandingBlocked = true;
-    }
-    if (status.finalResult && status.attention.state === "done") anyResult = true;
-  }
-  if (anyAlive) return null;
-  if (anyCompletionBlocked) return null;
-  if (anyLandingBlocked) return null;
-  return anyResult ? "completed" : "failed";
-}
-function finalizeStaleRuns() {
-  const finalized = [];
-  for (const run of listRunRecords()) {
-    if (!ACTIVE_RUN_STATUSES.has(run.status)) continue;
-    const next = deriveTerminalRunStatus(run);
-    if (!next || next === run.status) continue;
-    const from = run.status;
-    run.status = next;
-    saveRun(run);
-    finalized.push({ runId: run.id, from, to: next });
-  }
-  return finalized;
-}
-
-// src/cleanup-run-liveness.ts
-function isWorkerProcessLive(indexed) {
-  if (indexed.status.alive) return true;
-  if (indexed.worker.status === "running") return true;
-  return false;
-}
-function isRunStaleActive(indexed) {
-  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
-  return deriveTerminalRunStatus(indexed.run) !== null;
-}
-function runBlocksWorktreeRemoval(indexed) {
-  if (isWorkerProcessLive(indexed)) return true;
-  if (indexed.worker.completionBlocker) return true;
-  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
-  if (isRunStaleActive(indexed)) return false;
-  if (!isFinishedWorkerStatus(indexed.status)) return true;
-  return deriveTerminalRunStatus(indexed.run) === null;
-}
-
 // src/cleanup-guards.ts
 function prUrlFromFinalResult(finalResult) {
   if (typeof finalResult === "string") {
@@ -5581,30 +6151,22 @@ function skipWorktreeRemoval(input) {
   }
   return null;
 }
-function skipNodeModulesRemoval(input) {
-  const { indexed, includeOrphans, nodeModulesAgeMs, ageMs } = input;
-  if (ageMs < nodeModulesAgeMs) return "below_age_threshold";
-  if (!indexed) return includeOrphans ? null : "orphan_without_flag";
-  if (isWorkerProcessLive(indexed)) return "active_worker";
-  if (indexed.worker.completionBlocker) return "completion_blocked";
-  if (!isFinishedWorkerStatus(indexed.status)) return "run_still_active";
-  if (hasUnrestorableWorktreeChanges(indexed.status)) return "dirty_worktree";
-  const landing = assessWorkerLanding({
-    finalResult: indexed.status.finalResult,
-    changedFiles: indexed.status.changedFiles,
-    gitAncestry: indexed.status.gitAncestry,
-    prUrl: prUrlFromFinalResult(indexed.status.finalResult)
-  });
-  if (landing.blocked && materialWorktreeChanges2(indexed.status.changedFiles).length > 0) {
-    return "landing_blocked";
-  }
+function skipDependencyCacheRemoval(input) {
+  const { indexed, nodeModulesAgeMs, ageMs, worktreePath, activeWorktreePaths, diskPressure } = input;
+  if (!diskPressure && ageMs < nodeModulesAgeMs) return "below_age_threshold";
+  if (activeWorktreePaths.has(path29.resolve(worktreePath))) return "active_worker";
+  if (indexed && isWorkerProcessLive(indexed)) return "active_worker";
+  if (indexed && hasUnrestorableWorktreeChanges(indexed.status)) return "dirty_worktree";
   return null;
 }
+function skipBuildCacheRemoval(input) {
+  return skipDependencyCacheRemoval(input);
+}
 
 // src/cleanup-execute.ts
 import { existsSync as existsSync21, rmSync } from "node:fs";
-import path28 from "node:path";
-function removeNodeModules(candidate, execute) {
+import path30 from "node:path";
+function removeDependencyCache(candidate, execute) {
   if (!existsSync21(candidate.path)) {
     return {
       ...candidate,
@@ -5635,6 +6197,15 @@ function removeNodeModules(candidate, execute) {
     };
   }
 }
+function removeNodeModules(candidate, execute) {
+  return removeDependencyCache(candidate, execute);
+}
+function removeNextCache(candidate, execute) {
+  return removeDependencyCache(candidate, execute);
+}
+function removeBuildCache(candidate, execute) {
+  return removeDependencyCache(candidate, execute);
+}
 function removeWorktree(candidate, execute) {
   if (!existsSync21(candidate.path)) {
     return {
@@ -5672,74 +6243,97 @@ function removeWorktree(candidate, execute) {
     };
   }
 }
+function isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, cacheDirName) {
+  const resolved = path30.resolve(targetPath);
+  const suffix = `${path30.sep}${cacheDirName}`;
+  const cachePath = resolved.endsWith(suffix) ? resolved : null;
+  if (!cachePath) return "path_outside_harness";
+  const rel = path30.relative(worktreesDir, cachePath);
+  if (rel.startsWith("..") || path30.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path30.sep);
+  if (parts.length < 3 || parts[parts.length - 1] !== cacheDirName) return "path_outside_harness";
+  if (!resolved.startsWith(path30.resolve(harnessRoot))) return "path_outside_harness";
+  return null;
+}
 function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path28.resolve(targetPath);
-  const nm = resolved.endsWith(`${path28.sep}node_modules`) ? resolved : null;
-  if (!nm) return "path_outside_harness";
-  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(path28.resolve(harnessRoot))) return "path_outside_harness";
+  return isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, "node_modules");
+}
+function isHarnessNextCachePath(targetPath, harnessRoot, worktreesDir) {
+  return isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, ".next");
+}
+function isHarnessBuildCachePath(targetPath, harnessRoot, worktreesDir) {
+  const resolved = path30.resolve(targetPath);
+  const relToWt = path30.relative(worktreesDir, resolved);
+  if (relToWt.startsWith("..") || path30.isAbsolute(relToWt)) return "path_outside_harness";
+  const parts = relToWt.split(path30.sep);
+  if (parts.length < 3) return "path_outside_harness";
+  if (!resolved.startsWith(path30.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 
 // src/cleanup-scan.ts
-import { existsSync as existsSync22, readdirSync as readdirSync7, statSync as statSync5 } from "node:fs";
-import path29 from "node:path";
+import { existsSync as existsSync22, readdirSync as readdirSync7, statSync as statSync4 } from "node:fs";
+import path31 from "node:path";
 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 isPathInside(child, parent) {
-  const rel = path29.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path29.isAbsolute(rel);
+  const rel = path31.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path31.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 = path29.join(entry.worktreePath, "node_modules");
-    if (!existsSync22(nm)) continue;
-    const resolved = path29.resolve(nm);
+function collectBuildCacheForWorktree(worktreePath, opts, seen, meta) {
+  const out = [];
+  for (const rel of HARNESS_BUILD_CACHE_RELATIVE_PATHS) {
+    if (rel === ".next") continue;
+    const target = path31.join(worktreePath, rel);
+    if (!existsSync22(target)) continue;
+    const resolved = path31.resolve(target);
     if (seen.has(resolved)) continue;
+    if (!isPathInside(resolved, opts.harnessRoot)) continue;
     seen.add(resolved);
-    candidates.push({
-      kind: "remove_node_modules",
+    out.push({
+      kind: "remove_build_cache",
       path: resolved,
       bytes: null,
-      runId: entry.runId,
-      worker: entry.workerName,
-      repo: entry.run.repo,
+      runId: meta.runId,
+      worker: meta.worker,
+      repo: meta.repo,
       ageMs: pathAgeMs(resolved, opts.now)
     });
   }
+  return out;
+}
+function scanBuildCacheCandidates(opts) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of opts.index.values()) {
+    if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
+    candidates.push(
+      ...collectBuildCacheForWorktree(entry.worktreePath, opts, seen, {
+        runId: entry.runId,
+        worker: entry.workerName,
+        repo: entry.run.repo
+      })
+    );
+  }
   if (!opts.includeOrphans || !existsSync22(opts.worktreesDir)) return candidates;
   for (const runEntry of readdirSync7(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path29.join(opts.worktreesDir, runEntry.name);
+    const runPath = path31.join(opts.worktreesDir, runEntry.name);
     for (const workerEntry of readdirSync7(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path29.join(runPath, workerEntry.name);
-      const nm = path29.join(worktreePath, "node_modules");
-      if (!existsSync22(nm)) continue;
-      const resolved = path29.resolve(nm);
-      if (seen.has(resolved)) continue;
-      if (!isPathInside(resolved, opts.harnessRoot)) continue;
-      seen.add(resolved);
-      candidates.push({
-        kind: "remove_node_modules",
-        path: resolved,
-        bytes: null,
-        runId: runEntry.name,
-        worker: workerEntry.name,
-        ageMs: pathAgeMs(resolved, opts.now)
-      });
+      const worktreePath = path31.join(runPath, workerEntry.name);
+      candidates.push(
+        ...collectBuildCacheForWorktree(worktreePath, opts, seen, {
+          runId: runEntry.name,
+          worker: workerEntry.name
+        })
+      );
     }
   }
   return candidates;
@@ -5771,12 +6365,12 @@ function scanWorktreeCandidates(opts) {
   if (!orphanEnabled || !existsSync22(opts.worktreesDir)) return candidates;
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path29.resolve(entry.worktreePath));
+    indexedPaths.add(path31.resolve(entry.worktreePath));
   }
   for (const runEntry of readdirSync7(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path29.join(opts.worktreesDir, runEntry.name);
+    const runPath = path31.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
       workerEntries = readdirSync7(runPath, { withFileTypes: true });
@@ -5785,7 +6379,7 @@ function scanWorktreeCandidates(opts) {
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path29.resolve(path29.join(runPath, workerEntry.name));
+      const worktreePath = path31.resolve(path31.join(runPath, workerEntry.name));
       if (seen.has(worktreePath)) continue;
       if (indexedPaths.has(worktreePath)) continue;
       if (!isPathInside(worktreePath, opts.harnessRoot)) continue;
@@ -5803,18 +6397,191 @@ function scanWorktreeCandidates(opts) {
   return candidates;
 }
 
+// src/cleanup-dependency-scan.ts
+import { existsSync as existsSync23, readdirSync as readdirSync8, statSync as statSync5 } from "node:fs";
+import path32 from "node:path";
+var DEPENDENCY_CACHE_DIRS = [
+  { dirName: "node_modules", kind: "remove_node_modules" },
+  { dirName: ".next", kind: "remove_next_cache" }
+];
+function pathAgeMs2(target, now) {
+  try {
+    const mtime = statSync5(target).mtimeMs;
+    return Math.max(0, now - mtime);
+  } catch {
+    return 0;
+  }
+}
+function isPathInside2(child, parent) {
+  const rel = path32.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path32.isAbsolute(rel);
+}
+function pushCandidate2(candidates, seen, opts, targetPath, kind, meta) {
+  if (!existsSync23(targetPath)) return;
+  const resolved = path32.resolve(targetPath);
+  if (seen.has(resolved)) return;
+  if (!isPathInside2(resolved, opts.harnessRoot)) return;
+  seen.add(resolved);
+  candidates.push({
+    kind,
+    path: resolved,
+    bytes: null,
+    harnessRoot: opts.harnessRoot,
+    runId: meta.runId,
+    worker: meta.worker,
+    repo: meta.repo,
+    ageMs: pathAgeMs2(resolved, opts.now)
+  });
+}
+function scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, meta) {
+  for (const entry of DEPENDENCY_CACHE_DIRS) {
+    pushCandidate2(candidates, seen, opts, path32.join(worktreePath, entry.dirName), entry.kind, meta);
+  }
+}
+function scanDependencyCacheCandidates(opts) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of opts.index.values()) {
+    if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
+    scanWorktreeDependencyCaches(candidates, seen, opts, entry.worktreePath, {
+      runId: entry.runId,
+      worker: entry.workerName,
+      repo: entry.run.repo
+    });
+  }
+  if (!existsSync23(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync8(opts.worktreesDir, { withFileTypes: true })) {
+    if (!runEntry.isDirectory()) continue;
+    if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
+    const runPath = path32.join(opts.worktreesDir, runEntry.name);
+    let workerEntries;
+    try {
+      workerEntries = readdirSync8(runPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const workerEntry of workerEntries) {
+      if (!workerEntry.isDirectory()) continue;
+      const worktreePath = path32.join(runPath, workerEntry.name);
+      scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, {
+        runId: runEntry.name,
+        worker: workerEntry.name
+      });
+    }
+  }
+  return candidates;
+}
+
+// src/cleanup-duplicate-worktrees.ts
+import { existsSync as existsSync24, statSync as statSync6 } from "node:fs";
+import path33 from "node:path";
+function pathAgeMs3(target, now) {
+  try {
+    const mtime = statSync6(target).mtimeMs;
+    return Math.max(0, now - mtime);
+  } catch {
+    return 0;
+  }
+}
+function parseWorktreePorcelain(output) {
+  const records = [];
+  let current = null;
+  for (const line of output.split("\n")) {
+    if (!line.trim()) continue;
+    const [key, ...rest] = line.split(" ");
+    const value = rest.join(" ");
+    if (key === "worktree") {
+      if (current) records.push(current);
+      current = { path: value };
+      continue;
+    }
+    if (!current) continue;
+    if (key === "branch") current.branch = value;
+    if (key === "HEAD") current.head = value;
+    if (key === "bare") current.bare = true;
+  }
+  if (current) records.push(current);
+  return records;
+}
+function isUnderWorktreesDir(worktreePath, worktreesDir) {
+  const rel = path33.relative(path33.resolve(worktreesDir), path33.resolve(worktreePath));
+  return rel !== "" && !rel.startsWith("..") && !path33.isAbsolute(rel);
+}
+function isCleanWorktree(worktreePath, repoRoot) {
+  try {
+    const porcelain = git(repoRoot, ["-C", worktreePath, "status", "--porcelain"], {
+      allowFailure: true
+    });
+    return !String(porcelain || "").trim();
+  } catch {
+    return false;
+  }
+}
+function scanDuplicateWorktreeCandidates(opts) {
+  if (!opts.includeOrphans || !existsSync24(opts.worktreesDir)) return [];
+  const repos = /* @__PURE__ */ new Set();
+  for (const entry of opts.index.values()) {
+    if (entry.run.repo) repos.add(path33.resolve(entry.run.repo));
+  }
+  const indexedPaths = /* @__PURE__ */ new Set();
+  for (const entry of opts.index.values()) {
+    indexedPaths.add(path33.resolve(entry.worktreePath));
+  }
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const repoRoot of repos) {
+    let porcelain;
+    try {
+      porcelain = git(repoRoot, ["worktree", "list", "--porcelain"], { allowFailure: true });
+    } catch {
+      continue;
+    }
+    const worktrees = parseWorktreePorcelain(porcelain);
+    for (const wt of worktrees) {
+      const resolved = path33.resolve(wt.path);
+      if (resolved === path33.resolve(repoRoot)) continue;
+      if (!isUnderWorktreesDir(resolved, opts.worktreesDir)) continue;
+      if (indexedPaths.has(resolved)) continue;
+      if (seen.has(resolved)) continue;
+      if (!existsSync24(resolved)) continue;
+      if (!isCleanWorktree(resolved, repoRoot)) continue;
+      const rel = path33.relative(opts.worktreesDir, resolved);
+      const parts = rel.split(path33.sep);
+      const runId = parts[0];
+      const worker = parts[1] ?? "unknown";
+      seen.add(resolved);
+      candidates.push({
+        kind: "remove_worktree",
+        path: resolved,
+        bytes: null,
+        runId,
+        worker,
+        repo: repoRoot,
+        ageMs: pathAgeMs3(resolved, opts.now)
+      });
+    }
+  }
+  return candidates;
+}
+
 // src/cleanup-worktree-index.ts
-import path30 from "node:path";
-function buildWorktreeIndex() {
+import path34 from "node:path";
+function buildWorktreeIndexAt(harnessRoot) {
   const index = /* @__PURE__ */ new Map();
-  for (const run of listRunRecords()) {
+  for (const run of listRunRecordsForHarnessRoot(harnessRoot)) {
     for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path30.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path34.join(
+        runDirectoryAt(harnessRoot, 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(path30.resolve(worker.worktreePath), {
-        worktreePath: path30.resolve(worker.worktreePath),
+      index.set(path34.resolve(worker.worktreePath), {
+        harnessRoot,
+        worktreePath: path34.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -5872,12 +6639,162 @@ function resolvePipelineHarnessRetention(runId) {
   });
 }
 
-// src/cleanup.ts
-function resolvePaths(options = {}) {
-  const harnessRoot = options.harnessRoot ? resolveUserPath(options.harnessRoot) : resolveHarnessRoot();
-  const { worktreesDir } = options.harnessRoot ? { worktreesDir: path31.join(harnessRoot, "worktrees") } : getHarnessPaths();
-  const now = options.now ?? Date.now();
-  return { harnessRoot, worktreesDir, now };
+// src/cleanup-orphan-safety.ts
+import { existsSync as existsSync25, statSync as statSync7 } from "node:fs";
+import path35 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 (!existsSync25(input.worktreePath)) return null;
+  if (input.runId && input.workerName) {
+    const heartbeatPath = path35.join(
+      input.harnessRoot,
+      "runs",
+      input.runId,
+      "workers",
+      input.workerName,
+      "heartbeat.jsonl"
+    );
+    try {
+      const mtime = statSync7(heartbeatPath).mtimeMs;
+      if (now - mtime < heartbeatFreshMs) return "active_worker";
+    } catch {
+    }
+  }
+  const gitDir = path35.join(input.worktreePath, ".git");
+  if (!existsSync25(gitDir)) return null;
+  const porcelain = gitCapture(input.worktreePath, ["status", "--porcelain"]);
+  if (porcelain.status !== 0) return "pr_or_unmerged_commits";
+  const dirtyLines = porcelain.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  if (materialWorktreeChanges2(dirtyLines).length > 0) return "dirty_worktree";
+  const upstreamAhead = gitCapture(input.worktreePath, [
+    "rev-list",
+    "--count",
+    "@{u}..HEAD"
+  ]);
+  if (upstreamAhead.status === 0) {
+    const count = Number(upstreamAhead.stdout.trim());
+    if (Number.isFinite(count) && count > 0) return "pr_or_unmerged_commits";
+  }
+  const mainAhead = gitCapture(input.worktreePath, [
+    "rev-list",
+    "--count",
+    "origin/main..HEAD"
+  ]);
+  if (mainAhead.status !== 0) {
+    if (upstreamAhead.status !== 0) return "pr_or_unmerged_commits";
+    return null;
+  }
+  const mainCount = Number(mainAhead.stdout.trim());
+  if (Number.isFinite(mainCount) && mainCount > 0) return "pr_or_unmerged_commits";
+  return null;
+}
+
+// src/cleanup-harness-roots.ts
+import { existsSync as existsSync26 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import path36 from "node:path";
+var WELL_KNOWN_HARNESS_SCAN_ROOTS = [
+  "/var/tmp/kynver-harness",
+  path36.join(homedir6(), ".openclaw", "harness")
+];
+function addRoot(seen, roots, candidate) {
+  if (!candidate?.trim()) return;
+  const resolved = path36.resolve(resolveUserPath(candidate.trim()));
+  if (seen.has(resolved)) return;
+  seen.add(resolved);
+  roots.push(resolved);
+}
+function shouldScanWellKnownRoots(options) {
+  if (options.scanWellKnown != null) return options.scanWellKnown;
+  if (process.env.VITEST === "true") return false;
+  return process.env.KYNVER_CLEANUP_SCAN_WELL_KNOWN !== "0" && !["0", "false", "no"].includes((process.env.KYNVER_CLEANUP_SCAN_WELL_KNOWN ?? "").toLowerCase());
+}
+function resolveHarnessScanRoots(options = {}) {
+  const seen = /* @__PURE__ */ new Set();
+  const roots = [];
+  addRoot(seen, roots, options.harnessRoot ?? resolveHarnessRoot());
+  const extra = process.env.KYNVER_CLEANUP_EXTRA_ROOTS?.split(",").map((part) => part.trim()).filter(Boolean);
+  for (const candidate of extra ?? []) addRoot(seen, roots, candidate);
+  if (shouldScanWellKnownRoots(options)) {
+    for (const candidate of WELL_KNOWN_HARNESS_SCAN_ROOTS) {
+      const resolved = path36.resolve(candidate);
+      if (!seen.has(resolved) && existsSync26(resolved)) addRoot(seen, roots, resolved);
+    }
+  }
+  return roots;
+}
+
+// src/cleanup-active-worktrees.ts
+import path37 from "node:path";
+function isActiveHarnessWorker2(worker, runBase, runBaseCommit) {
+  const status = computeWorkerStatus(worker, { base: runBase, baseCommit: runBaseCommit });
+  return status.alive && !status.finalResult && status.attention.state !== "done";
+}
+function collectActiveWorktreeGuards(harnessRoots) {
+  const activeWorktreePaths = /* @__PURE__ */ new Set();
+  const liveRunKeys = /* @__PURE__ */ new Set();
+  for (const harnessRoot of harnessRoots) {
+    for (const run of listRunRecordsForHarnessRoot(harnessRoot)) {
+      let runHasLive = false;
+      for (const name of Object.keys(run.workers || {})) {
+        const worker = readJson(
+          path37.join(runDirectoryAt(harnessRoot, run.id), "workers", safeSlug(name), "worker.json"),
+          void 0
+        );
+        if (!worker?.worktreePath) continue;
+        const worktreePath = path37.resolve(worker.worktreePath);
+        if (!isActiveHarnessWorker2(worker, run.base, run.baseCommit)) continue;
+        runHasLive = true;
+        activeWorktreePaths.add(worktreePath);
+      }
+      if (runHasLive) liveRunKeys.add(`${harnessRoot}\0${run.id}`);
+    }
+  }
+  return { activeWorktreePaths, liveRunKeys };
+}
+
+// src/cleanup-disk-pressure.ts
+function envFlag2(name) {
+  const v = process.env[name];
+  return v === "1" || v === "true" || v === "yes";
+}
+function envNumber(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : fallback;
+}
+function observeCleanupDiskPressure(input = {}) {
+  const diskPath = input.diskPath?.trim() || process.env.KYNVER_DISK_GUARD_PATH?.trim() || "/";
+  const maxUsedPercent = envNumber("KYNVER_DISK_GUARD_MAX_USED_PERCENT", 75);
+  const diskGate = observeRunnerDiskGate({
+    ...input,
+    diskPath,
+    diskMaxUsedPercent: input.diskMaxUsedPercent ?? maxUsedPercent
+  });
+  const pressured = !diskGate.ok || diskGate.usedPercent >= maxUsedPercent;
+  return { diskGate, pressured, maxUsedPercent };
+}
+function applyDiskPressureToRetention(retention, pressure) {
+  if (!pressure.pressured) return retention;
+  const executeOnPressure = retention.execute || envFlag2("KYNVER_CLEANUP_EXECUTE_ON_PRESSURE");
+  return {
+    ...retention,
+    execute: executeOnPressure,
+    nodeModulesAgeMs: 0,
+    diskPressure: true,
+    diskGate: pressure.diskGate
+  };
+}
+
+// src/cleanup.ts
+function resolvePaths(options = {}) {
+  const harnessRoot = options.harnessRoot ? resolveUserPath(options.harnessRoot) : resolveHarnessRoot();
+  const scanRoots = resolveHarnessScanRoots({ harnessRoot });
+  const now = options.now ?? Date.now();
+  return { harnessRoot, scanRoots, now };
 }
 function normalizeGuardSkip(skip) {
   if (typeof skip === "string") return { reason: skip };
@@ -5902,72 +6819,145 @@ function tallySkipReasons(actions, skips) {
   }
   return counts;
 }
+function removeDependencyCacheAction(candidate, execute) {
+  if (candidate.kind === "remove_next_cache") return removeNextCache(candidate, execute);
+  return removeNodeModules(candidate, execute);
+}
+function pathGuardForDependencyCache(candidate, harnessRoot, worktreesDir) {
+  if (candidate.kind === "remove_next_cache") {
+    return isHarnessNextCachePath(candidate.path, harnessRoot, worktreesDir);
+  }
+  return isHarnessNodeModulesPath(candidate.path, harnessRoot, worktreesDir);
+}
+function mergeWorktreeIndexes(scanRoots) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const root of scanRoots) {
+    for (const [key, value] of buildWorktreeIndexAt(root)) merged.set(key, value);
+  }
+  return merged;
+}
+function worktreePathForCandidate(candidate, worktreesDir) {
+  if (candidate.runId && candidate.worker) {
+    return path38.join(worktreesDir, candidate.runId, candidate.worker);
+  }
+  return path38.resolve(candidate.path, "..");
+}
 function runHarnessCleanup(options = {}) {
-  const retention = resolveHarnessRetention(options);
+  let retention = resolveHarnessRetention(options);
+  const diskPressure = observeCleanupDiskPressure();
+  retention = applyDiskPressureToRetention(retention, diskPressure);
   const paths = resolvePaths(options);
+  const activeGuards = collectActiveWorktreeGuards(paths.scanRoots);
+  const index = mergeWorktreeIndexes(paths.scanRoots);
   const finalizedRuns = retention.finalizeStaleRuns ? finalizeStaleRuns().map((f) => ({ runId: f.runId, from: f.from, to: f.to })) : [];
-  const index = buildWorktreeIndex();
-  const scanOpts = {
-    harnessRoot: paths.harnessRoot,
-    worktreesDir: paths.worktreesDir,
-    nodeModulesAgeMs: retention.nodeModulesAgeMs,
-    worktreesAgeMs: retention.worktreesAgeMs,
-    includeOrphans: retention.includeOrphans,
-    runIdFilter: retention.runIdFilter,
-    index,
-    now: paths.now
-  };
   const skips = [];
   const actions = [];
-  for (const raw of scanNodeModulesCandidates(scanOpts)) {
-    const candidate = attachCandidateBytes(raw, retention.accountBytes);
-    const pathSkip = isHarnessNodeModulesPath(candidate.path, paths.harnessRoot, paths.worktreesDir);
-    if (pathSkip) {
-      recordSkip(skips, candidate.path, pathSkip);
-      actions.push({ ...candidate, executed: false, skipped: true, skipReason: pathSkip });
-      continue;
-    }
-    const worktreePath = path31.resolve(candidate.path, "..");
-    const indexed = index.get(worktreePath) ?? null;
-    const guardReason = skipNodeModulesRemoval({
-      indexed,
-      includeOrphans: retention.includeOrphans,
+  const processedPaths = /* @__PURE__ */ new Set();
+  for (const harnessRoot of paths.scanRoots) {
+    const worktreesDir = path38.join(harnessRoot, "worktrees");
+    const scanOpts = {
+      harnessRoot,
+      worktreesDir,
       nodeModulesAgeMs: retention.nodeModulesAgeMs,
-      ageMs: candidate.ageMs
-    });
-    if (guardReason) {
-      recordSkip(skips, candidate.path, guardReason);
-      actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
-      continue;
-    }
-    actions.push(removeNodeModules(candidate, retention.execute));
-  }
-  for (const raw of scanWorktreeCandidates(scanOpts)) {
-    const candidate = attachCandidateBytes(raw, retention.accountBytes);
-    const indexed = index.get(path31.resolve(candidate.path)) ?? null;
-    const orphanSafety = indexed ? null : assessOrphanWorktreeSafety({
-      worktreePath: candidate.path,
-      harnessRoot: paths.harnessRoot,
-      runId: candidate.runId,
-      workerName: candidate.worker,
-      now: paths.now
-    });
-    const guardSkip = skipWorktreeRemoval({
-      indexed,
-      worktreePath: path31.resolve(candidate.path),
-      includeOrphans: retention.includeOrphans,
       worktreesAgeMs: retention.worktreesAgeMs,
-      ageMs: candidate.ageMs,
-      orphanSafety,
-      worktreeRemovalGuard: options.worktreeRemovalGuard
-    });
-    if (guardSkip) {
-      const { reason: guardReason, detail: guardDetail } = normalizeGuardSkip(guardSkip);
-      recordSkip(skips, candidate.path, guardReason, guardDetail);
-      actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
-      continue;
+      includeOrphans: retention.includeOrphans,
+      runIdFilter: retention.runIdFilter,
+      index,
+      now: paths.now
+    };
+    for (const raw of scanDependencyCacheCandidates(scanOpts)) {
+      const candidate = attachCandidateBytes(raw, retention.accountBytes);
+      const resolved = path38.resolve(candidate.path);
+      if (processedPaths.has(resolved)) continue;
+      processedPaths.add(resolved);
+      const pathSkip = pathGuardForDependencyCache(candidate, harnessRoot, worktreesDir);
+      if (pathSkip) {
+        recordSkip(skips, candidate.path, pathSkip);
+        actions.push({ ...candidate, executed: false, skipped: true, skipReason: pathSkip });
+        continue;
+      }
+      const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
+      const indexed = index.get(path38.resolve(worktreePath)) ?? null;
+      const guardReason = skipDependencyCacheRemoval({
+        indexed,
+        includeOrphans: true,
+        nodeModulesAgeMs: retention.nodeModulesAgeMs,
+        ageMs: candidate.ageMs,
+        worktreePath,
+        activeWorktreePaths: activeGuards.activeWorktreePaths,
+        diskPressure: retention.diskPressure
+      });
+      if (guardReason) {
+        recordSkip(skips, candidate.path, guardReason);
+        actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
+        continue;
+      }
+      actions.push(removeDependencyCacheAction(candidate, retention.execute));
+    }
+    for (const raw of scanBuildCacheCandidates(scanOpts)) {
+      const candidate = attachCandidateBytes(raw, retention.accountBytes);
+      const resolved = path38.resolve(candidate.path);
+      if (processedPaths.has(resolved)) continue;
+      processedPaths.add(resolved);
+      const pathSkip = isHarnessBuildCachePath(candidate.path, harnessRoot, worktreesDir);
+      if (pathSkip) {
+        recordSkip(skips, candidate.path, pathSkip);
+        actions.push({ ...candidate, executed: false, skipped: true, skipReason: pathSkip });
+        continue;
+      }
+      const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
+      const indexed = index.get(path38.resolve(worktreePath)) ?? null;
+      const guardReason = skipBuildCacheRemoval({
+        indexed,
+        includeOrphans: true,
+        nodeModulesAgeMs: retention.nodeModulesAgeMs,
+        ageMs: candidate.ageMs,
+        worktreePath,
+        activeWorktreePaths: activeGuards.activeWorktreePaths,
+        diskPressure: retention.diskPressure
+      });
+      if (guardReason) {
+        recordSkip(skips, candidate.path, guardReason);
+        actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
+        continue;
+      }
+      actions.push(removeBuildCache(candidate, retention.execute));
+    }
+    const worktreeCandidates = [
+      ...scanWorktreeCandidates(scanOpts),
+      ...scanDuplicateWorktreeCandidates(scanOpts)
+    ];
+    const worktreeSeen = /* @__PURE__ */ new Set();
+    for (const raw of worktreeCandidates) {
+      const resolved = path38.resolve(raw.path);
+      if (worktreeSeen.has(resolved)) continue;
+      worktreeSeen.add(resolved);
+      const candidate = attachCandidateBytes({ ...raw, path: resolved }, retention.accountBytes);
+      const indexed = index.get(path38.resolve(candidate.path)) ?? null;
+      const orphanSafety = indexed ? null : assessOrphanWorktreeSafety({
+        worktreePath: candidate.path,
+        harnessRoot,
+        runId: candidate.runId,
+        workerName: candidate.worker,
+        now: paths.now
+      });
+      const guardSkip = skipWorktreeRemoval({
+        indexed,
+        worktreePath: path38.resolve(candidate.path),
+        includeOrphans: retention.includeOrphans,
+        worktreesAgeMs: retention.worktreesAgeMs,
+        ageMs: candidate.ageMs,
+        orphanSafety,
+        worktreeRemovalGuard: options.worktreeRemovalGuard
+      });
+      if (guardSkip) {
+        const { reason: guardReason, detail: guardDetail } = normalizeGuardSkip(guardSkip);
+        recordSkip(skips, candidate.path, guardReason, guardDetail);
+        actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
+        continue;
+      }
+      actions.push(removeWorktree(candidate, retention.execute));
     }
-    actions.push(removeWorktree(candidate, retention.execute));
   }
   let candidateBytes = 0;
   let reclaimableBytes = 0;
@@ -5988,11 +6978,20 @@ function runHarnessCleanup(options = {}) {
   const storage = retention.accountBytes ? harnessStorageSnapshot({ harnessRoot: paths.harnessRoot, now: paths.now }) : void 0;
   return {
     harnessRoot: paths.harnessRoot,
+    scanRoots: paths.scanRoots,
     dryRun: !retention.execute,
     execute: retention.execute,
     nodeModulesAgeMs: retention.nodeModulesAgeMs,
     worktreesAgeMs: retention.worktreesAgeMs,
     includeOrphans: retention.includeOrphans,
+    diskPressure: retention.diskPressure,
+    diskGate: retention.diskGate ? {
+      ok: retention.diskGate.ok,
+      path: retention.diskGate.path,
+      freeBytes: retention.diskGate.freeBytes,
+      usedPercent: retention.diskGate.usedPercent,
+      reason: retention.diskGate.reason
+    } : void 0,
     scannedAt: new Date(paths.now).toISOString(),
     finalizedRuns,
     actions,
@@ -6029,8 +7028,8 @@ import { mkdirSync as mkdirSync7, realpathSync } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/discard-disposable.ts
-import { existsSync as existsSync23, rmSync as rmSync2 } from "node:fs";
-import path32 from "node:path";
+import { existsSync as existsSync27, rmSync as rmSync2 } from "node:fs";
+import path39 from "node:path";
 function normalizeRelativePath2(value) {
   const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").trim();
   if (!normalized || normalized.startsWith("/") || normalized.includes("..")) {
@@ -6051,15 +7050,15 @@ function discardDisposableArtifacts(args) {
   if (paths.length === 0) {
     return { ok: false, removed: [], reason: "requires at least one --path" };
   }
-  const worktreeRoot = path32.resolve(worker.worktreePath);
+  const worktreeRoot = path39.resolve(worker.worktreePath);
   const removed = [];
   for (const raw of paths) {
     const rel = normalizeRelativePath2(raw);
-    const abs = path32.resolve(worktreeRoot, rel);
-    if (!abs.startsWith(worktreeRoot + path32.sep) && abs !== worktreeRoot) {
+    const abs = path39.resolve(worktreeRoot, rel);
+    if (!abs.startsWith(worktreeRoot + path39.sep) && abs !== worktreeRoot) {
       return { ok: false, removed, reason: `path escapes worktree: ${raw}` };
     }
-    if (!existsSync23(abs)) {
+    if (!existsSync27(abs)) {
       return { ok: false, removed, reason: `path not found: ${raw}` };
     }
     rmSync2(abs, { recursive: true, force: true });
@@ -6082,195 +7081,88 @@ function discardDisposableCli(args) {
 }
 
 // src/pipeline-tick.ts
-import path36 from "node:path";
+import path42 from "node:path";
 
 // src/pipeline-dispatch.ts
 var RESERVED_REVIEW_STARTS = 1;
-function countDispatchStarts(result) {
-  if (!result || typeof result !== "object") return 0;
-  const startedCount = result.startedCount;
-  if (typeof startedCount === "number") return startedCount;
-  const outcomes = result.outcomes;
-  if (!Array.isArray(outcomes)) return 0;
-  return outcomes.filter((o) => o.started).length;
-}
-function stripCliMaxStarts(args) {
-  const { maxStarts: _maxStarts, ...rest } = args;
-  return rest;
-}
-async function runPipelineDispatch(args, slots) {
-  if (slots <= 0) {
-    return { ok: true, skipped: true, reason: "no slots", maxStarts: 0, startedCount: 0 };
-  }
-  const base = stripCliMaxStarts(args);
-  const reviewBudget = Math.min(slots, RESERVED_REVIEW_STARTS);
-  const workBudget = Math.max(0, slots - reviewBudget);
-  const review = await dispatchRun({
-    ...base,
-    execute: true,
-    pipeline: true,
-    lane: "review",
-    maxStarts: String(reviewBudget)
-  });
-  const reviewStarted = countDispatchStarts(review);
-  const workSlots = workBudget + (reviewBudget - reviewStarted);
-  if (workSlots <= 0) {
-    return {
-      ...typeof review === "object" && review !== null ? review : {},
-      passes: { review },
-      startedCount: reviewStarted
-    };
-  }
-  const work = await dispatchRun({
-    ...base,
-    execute: true,
-    pipeline: true,
-    maxStarts: String(workSlots)
-  });
-  const workStarted = countDispatchStarts(work);
-  return {
-    passes: { review, work },
-    startedCount: reviewStarted + workStarted,
-    ok: true
-  };
-}
-
-// src/pipeline-max-starts.ts
-function operatorDispatchFromTick(operatorTick) {
-  const body = operatorTick;
-  const dispatch = body.response?.dispatch;
-  return dispatch && typeof dispatch === "object" ? dispatch : null;
-}
-function resolvePipelineMaxStarts(resourceGate, operatorTick) {
-  const dispatch = operatorDispatchFromTick(operatorTick);
-  const advised = typeof dispatch?.recommendedMaxStarts === "number" ? Math.max(0, dispatch.recommendedMaxStarts) : null;
-  let maxStarts = resourceGate.slotsAvailable;
-  if (advised !== null) {
-    maxStarts = Math.min(maxStarts, advised);
-  }
-  const underutilized = dispatch?.underutilized === true;
-  const boardAdvancedThisTick = typeof dispatch?.boardAdvancedThisTick === "number" ? dispatch.boardAdvancedThisTick : 0;
-  if (underutilized && resourceGate.slotsAvailable > 0 && maxStarts === 0) {
-    const ready = dispatch?.actionableReady ?? dispatch?.queuedTasks ?? (boardAdvancedThisTick > 0 ? boardAdvancedThisTick : 1);
-    maxStarts = Math.min(resourceGate.slotsAvailable, Math.max(1, ready));
-  }
-  return {
-    maxStarts: Math.max(0, maxStarts),
-    underutilized,
-    advisedStarts: advised,
-    boardAdvancedThisTick
-  };
-}
-
-// src/stale-reconcile.ts
-import path33 from "node:path";
-var STALE_RECONCILE_HEARTBEAT_MS = 15 * 60 * 1e3;
-function staleReconcileDisabled() {
-  return process.env.KYNVER_NO_STALE_CLEANUP === "1";
-}
-function reconcileStaleWorkers() {
-  if (staleReconcileDisabled()) {
-    return { workers: [], finalizedRuns: finalizeStaleRuns() };
-  }
-  const outcomes = [];
-  const now = Date.now();
-  for (const run of listRunRecords()) {
-    for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path33.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
-      const worker = readJson(workerPath, void 0);
-      if (!worker || worker.status !== "running") {
-        outcomes.push({
-          runId: run.id,
-          worker: name,
-          action: "skipped",
-          reason: worker ? `worker status is ${worker.status}` : "worker.json missing"
-        });
-        continue;
-      }
-      const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
-      if (status.finalResult) {
-        if (worker.status === "running") {
-          const nextStatus = status.attention.state === "blocked" ? "blocked" : status.attention.state === "done" || status.status === "done" ? "done" : "exited";
-          worker.status = nextStatus;
-          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
-          worker.reconcileReason = "synced finished worker record after terminal stdout/heartbeat";
-          saveWorker(run.id, worker);
-          outcomes.push({
-            runId: run.id,
-            worker: name,
-            action: "marked_exited",
-            reason: worker.reconcileReason
-          });
-        } else {
-          outcomes.push({ runId: run.id, worker: name, action: "skipped", reason: "final result present" });
-        }
-        continue;
-      }
-      if (!status.alive) {
-        const nextStatus = status.attention.state === "blocked" ? "blocked" : status.status === "done" ? "done" : "exited";
-        worker.status = nextStatus;
-        worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
-        worker.reconcileReason = status.attention.reason;
-        saveWorker(run.id, worker);
-        outcomes.push({
-          runId: run.id,
-          worker: name,
-          action: "marked_exited",
-          reason: status.attention.reason
-        });
-        continue;
-      }
-      if (status.attention.state === "stale" && worker.pid && isPidAlive(worker.pid)) {
-        const hbMs = status.lastHeartbeatAt ? Date.parse(status.lastHeartbeatAt) : NaN;
-        const actMs = status.lastActivityAt ? Date.parse(status.lastActivityAt) : NaN;
-        const hbStale = !Number.isFinite(hbMs) || now - hbMs > STALE_RECONCILE_HEARTBEAT_MS;
-        const actStale = Number.isFinite(actMs) && now - actMs > STALE_MS;
-        if (hbStale && actStale) {
-          killWorkerProcess(worker.pid, "SIGTERM");
-          worker.status = "exited";
-          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
-          worker.reconcileReason = `reconciled stale worker: ${status.attention.reason}`;
-          saveWorker(run.id, worker);
-          outcomes.push({
-            runId: run.id,
-            worker: name,
-            action: "killed_stale",
-            reason: status.attention.reason
-          });
-          continue;
-        }
-      }
-      outcomes.push({
-        runId: run.id,
-        worker: name,
-        action: "skipped",
-        reason: status.attention.reason
-      });
-    }
+function countDispatchStarts(result) {
+  if (!result || typeof result !== "object") return 0;
+  const startedCount = result.startedCount;
+  if (typeof startedCount === "number") return startedCount;
+  const outcomes = result.outcomes;
+  if (!Array.isArray(outcomes)) return 0;
+  return outcomes.filter((o) => o.started).length;
+}
+function stripCliMaxStarts(args) {
+  const { maxStarts: _maxStarts, ...rest } = args;
+  return rest;
+}
+async function runPipelineDispatch(args, slots) {
+  if (slots <= 0) {
+    return { ok: true, skipped: true, reason: "no slots", maxStarts: 0, startedCount: 0 };
   }
-  return { workers: outcomes, finalizedRuns: finalizeStaleRuns() };
+  const base = stripCliMaxStarts(args);
+  const reviewBudget = Math.min(slots, RESERVED_REVIEW_STARTS);
+  const workBudget = Math.max(0, slots - reviewBudget);
+  const review = await dispatchRun({
+    ...base,
+    execute: true,
+    pipeline: true,
+    lane: "review",
+    maxStarts: String(reviewBudget)
+  });
+  const reviewStarted = countDispatchStarts(review);
+  const workSlots = workBudget + (reviewBudget - reviewStarted);
+  if (workSlots <= 0) {
+    return {
+      ...typeof review === "object" && review !== null ? review : {},
+      passes: { review },
+      startedCount: reviewStarted
+    };
+  }
+  const work = await dispatchRun({
+    ...base,
+    execute: true,
+    pipeline: true,
+    maxStarts: String(workSlots)
+  });
+  const workStarted = countDispatchStarts(work);
+  return {
+    passes: { review, work },
+    startedCount: reviewStarted + workStarted,
+    ok: true
+  };
 }
-function reconcileRunsCli() {
-  const result = reconcileStaleWorkers();
-  const markedExited = result.workers.filter((w) => w.action === "marked_exited").length;
-  const killedStale = result.workers.filter((w) => w.action === "killed_stale").length;
-  const skipped = result.workers.filter((w) => w.action === "skipped").length;
-  console.log(
-    JSON.stringify(
-      {
-        ok: true,
-        workers: { markedExited, killedStale, skipped, total: result.workers.length },
-        finalizedRuns: result.finalizedRuns.length,
-        details: { workers: result.workers, finalizedRuns: result.finalizedRuns }
-      },
-      null,
-      2
-    )
-  );
+
+// src/pipeline-max-starts.ts
+function operatorDispatchFromTick(operatorTick) {
+  const body = operatorTick;
+  const dispatch = body.response?.dispatch;
+  return dispatch && typeof dispatch === "object" ? dispatch : null;
+}
+function resolvePipelineMaxStarts(resourceGate, operatorTick) {
+  const dispatch = operatorDispatchFromTick(operatorTick);
+  const advised = typeof dispatch?.recommendedMaxStarts === "number" ? Math.max(0, dispatch.recommendedMaxStarts) : null;
+  let maxStarts = resourceGate.slotsAvailable;
+  if (advised !== null) {
+    maxStarts = Math.min(maxStarts, advised);
+  }
+  const underutilized = dispatch?.underutilized === true;
+  const boardAdvancedThisTick = typeof dispatch?.boardAdvancedThisTick === "number" ? dispatch.boardAdvancedThisTick : 0;
+  if (underutilized && resourceGate.slotsAvailable > 0 && maxStarts === 0) {
+    const ready = dispatch?.actionableReady ?? dispatch?.queuedTasks ?? (boardAdvancedThisTick > 0 ? boardAdvancedThisTick : 1);
+    maxStarts = Math.min(resourceGate.slotsAvailable, Math.max(1, ready));
+  }
+  return {
+    maxStarts: Math.max(0, maxStarts),
+    underutilized,
+    advisedStarts: advised,
+    boardAdvancedThisTick
+  };
 }
 
 // src/plan-progress-daemon-sync.ts
-import path34 from "node:path";
+import path40 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -6294,7 +7186,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path34.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path40.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -6344,8 +7236,8 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 
 // src/installed-package-versions.ts
 import { readFile } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import path35 from "node:path";
+import { homedir as homedir7 } from "node:os";
+import path41 from "node:path";
 var MANAGED_PACKAGES = [
   "@kynver-app/runtime",
   "@kynver-app/openclaw-agent-os",
@@ -6359,13 +7251,13 @@ function unique(values) {
   return [...new Set(values.filter((value) => Boolean(value)))];
 }
 function moduleRoots() {
-  const home = homedir6();
-  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path35.join(home, ".openclaw", "npm");
-  const npmGlobalRoot = trim(process.env.KYNVER_NPM_GLOBAL_ROOT) ?? trim(process.env.KYNVER_NPM_GLOBAL_MODULES_ROOT) ?? (trim(process.env.NPM_CONFIG_PREFIX) ? path35.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path35.join(home, ".npm-global", "lib", "node_modules"));
+  const home = homedir7();
+  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path41.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) ? path41.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path41.join(home, ".npm-global", "lib", "node_modules"));
   return unique([
-    path35.join(openClawPrefix, "lib", "node_modules"),
-    path35.join(openClawPrefix, "node_modules"),
-    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path35.join(npmGlobalRoot, "lib", "node_modules")
+    path41.join(openClawPrefix, "lib", "node_modules"),
+    path41.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path41.join(npmGlobalRoot, "lib", "node_modules")
   ]);
 }
 async function readVersion(packageJsonPath) {
@@ -6381,7 +7273,7 @@ async function collectInstalledPackageVersions(observedAt = (/* @__PURE__ */ new
   const out = {};
   for (const packageName of MANAGED_PACKAGES) {
     for (const root of roots) {
-      const packageJsonPath = path35.join(root, packageName, "package.json");
+      const packageJsonPath = path41.join(root, packageName, "package.json");
       const version = await readVersion(packageJsonPath);
       if (!version) continue;
       out[packageName] = { version, observedAt, path: packageJsonPath };
@@ -6397,7 +7289,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path36.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path42.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -6424,18 +7316,38 @@ async function completeFinishedWorkers(runId, args) {
   }
   return outcomes;
 }
-async function postOperatorTick(agentOsId, runId, resourceGate, args) {
+async function postOperatorTick(agentOsId, runId, resourceGate, args, harnessCleanup) {
   const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
   const secret = await resolveCallbackSecretWithMint(args.secret ? String(args.secret) : void 0, agentOsId, { baseUrl: base });
   const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/operator/tick`;
   const packageVersions = await collectInstalledPackageVersions();
+  const activeHarnessWorkers = [];
+  const run = loadRun(runId);
+  for (const name of Object.keys(run.workers || {})) {
+    const worker = readJson(
+      path42.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
+    );
+    if (!worker?.taskId) continue;
+    activeHarnessWorkers.push({
+      runId: run.id,
+      workerName: name,
+      taskId: worker.taskId,
+      pid: worker.pid
+    });
+  }
   const res = await postJson(url, secret, {
     agentOsId,
     runId,
     ingestHarness: true,
     harnessBoardSnapshot: buildRunBoard(runId),
     resourceGate,
-    packageVersions
+    boxResourceSnapshot: buildBoxResourceSnapshotFromGate(resourceGate, { harnessRunId: runId }),
+    packageVersions,
+    ...harnessCleanup ? { harnessCleanup } : {},
+    runnerPresence: resolveRunnerPresencePayload({ runId }),
+    activeHarnessWorkers,
+    ...harnessCleanup ? { harnessCleanup } : {}
   });
   return { ok: res.ok, httpStatus: res.status, response: res.response };
 }
@@ -6449,12 +7361,12 @@ async function runPipelineTick(args) {
     runId,
     configuredMaxWorkersOverride: workspacePrefs?.maxConcurrentWorkers
   });
-  const operatorTick = await postOperatorTick(agentOsId, runId, resourceGate, args);
+  const harnessCleanup = isPipelineCleanupEnabled() ? runPipelineHarnessCleanup(runId) : void 0;
+  const operatorTick = await postOperatorTick(agentOsId, runId, resourceGate, args, harnessCleanup);
   const completionAckSync = syncCompletionAcknowledgedFromOperatorTick(runId, operatorTick);
   const leaseRenewal = await renewActiveTaskLeases(runId, args);
   const completedWorkers = await completeFinishedWorkers(runId, args);
   const staleReconcile = reconcileStaleWorkers();
-  const harnessCleanup = isPipelineCleanupEnabled() ? runPipelineHarnessCleanup(runId) : void 0;
   const planProgressSync = await syncActiveWorkerPlanProgress(runId, args);
   const maxStartsAdvice = resolvePipelineMaxStarts(resourceGate, operatorTick);
   let maxStarts = maxStartsAdvice.maxStarts;
@@ -6535,7 +7447,7 @@ async function runDaemon(args) {
 }
 
 // src/plan-progress.ts
-import path37 from "node:path";
+import path43 from "node:path";
 
 // src/bounded-build/constants.ts
 var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
@@ -6785,7 +7697,8 @@ async function emitPlanProgress(args) {
   const secret = await resolveCallbackSecretWithMint(args.secret ? String(args.secret) : void 0, agentOsId, { baseUrl: base });
   const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/plans/${encodeURIComponent(planId)}/progress-events`;
   const cfg = loadUserConfig();
-  const provider = cfg.workerProvider ? `provider:${cfg.workerProvider}` : void 0;
+  const workerProvider = resolveConfiguredWorkerProvider(cfg.workerProvider, DEFAULT_WORKER_PROVIDER);
+  const provider = `provider:${workerProvider}`;
   const explicitProposed = args.proposed === true || args.proposed === "true" ? true : args.proposed === false || args.proposed === "false" ? false : void 0;
   const proposed = explicitProposed ?? (status !== "done" && (roleLane === "implementer" || roleLane === "repair_implementer"));
   const body = {
@@ -6821,7 +7734,7 @@ async function emitPlanProgress(args) {
 }
 function verifyPlanLocal(args) {
   const worktree = required(args.worktree ? String(args.worktree) : void 0, "worktree");
-  const cwd = path37.resolve(worktree);
+  const cwd = path43.resolve(worktree);
   const summary = runHarnessVerifyCommands(cwd);
   const emitJson = args.json === true || args.json === "true";
   const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
@@ -6870,9 +7783,9 @@ async function verifyPlan(args) {
 }
 
 // src/harness-verify-cli.ts
-import path38 from "node:path";
+import path44 from "node:path";
 function runHarnessVerifyCli(args) {
-  const cwd = path38.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const cwd = path44.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;
@@ -6916,7 +7829,7 @@ function runHarnessVerifyCli(args) {
 }
 
 // src/plan-persist-cli.ts
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 var OPERATIONS = ["create", "add_version", "update_metadata"];
 var FAILURE_KINDS = [
   "approval_guard",
@@ -6928,7 +7841,7 @@ var FAILURE_KINDS = [
 function readBodyArg(args) {
   const bodyFile = args.bodyFile ? String(args.bodyFile) : void 0;
   if (bodyFile) {
-    return { body: readFileSync11(bodyFile, "utf8"), bodyPathHint: bodyFile };
+    return { body: readFileSync12(bodyFile, "utf8"), bodyPathHint: bodyFile };
   }
   const inline = args.body ? String(args.body) : void 0;
   if (inline) return { body: inline };
@@ -7017,8 +7930,291 @@ function runCleanupCli(args) {
   }
 }
 
+// src/harness-notice/harness-notice.parse.ts
+var MAX_DIAGNOSTIC_CHARS = 2400;
+function tryParseJsonValue(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function diagnosticJson(value, maxChars = MAX_DIAGNOSTIC_CHARS) {
+  if (value === void 0 || value === null) return void 0;
+  const raw = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.length <= maxChars) return trimmed;
+  return `${trimmed.slice(0, maxChars - 1).trimEnd()}\u2026`;
+}
+function firstJsonFromStdout(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return null;
+  const direct = tryParseJsonValue(trimmed);
+  if (direct !== null) return direct;
+  for (const line of trimmed.split("\n")) {
+    const parsed = tryParseJsonValue(line);
+    if (parsed !== null) return parsed;
+  }
+  return null;
+}
+
+// src/harness-notice/harness-notice.auto-complete.ts
+function formatAutoCompleteOutcomeNotice(outcome) {
+  const lines = [];
+  lines.push(`Background auto-complete \xB7 ${outcome.runId} / ${outcome.worker}`);
+  switch (outcome.outcome) {
+    case "completed":
+      lines.push("Outcome: harness completion posted to AgentOS successfully.");
+      lines.push("AgentOS task should close or advance to review per completion routing.");
+      lines.push("Next: check Command Center \u2014 no manual complete needed unless the board still shows running.");
+      break;
+    case "blocked":
+      lines.push(
+        `Outcome: worker finished but completion was blocked${outcome.httpStatus ? ` (HTTP ${outcome.httpStatus})` : ""}.`
+      );
+      if (outcome.reason) lines.push(`Blocker: ${outcome.reason}`);
+      lines.push("Next: fix the blocker (auth, landing gate, dirty worktree) and replay completion from Command Center.");
+      break;
+    case "timed_out":
+      lines.push(`Outcome: monitor gave up waiting \u2014 ${outcome.reason ?? "worker did not finish in time"}.`);
+      lines.push("Next: inspect the worker process/logs; stop or unblock the worker, then retry auto-complete.");
+      break;
+    case "missing_link":
+      lines.push(`Outcome: cannot complete \u2014 ${outcome.reason ?? "worker missing agentOsId/taskId"}.`);
+      lines.push("Next: re-dispatch with board linkage or run `kynver worker complete` with --agent-os-id.");
+      break;
+    default:
+      lines.push(`Outcome: ${outcome.outcome}`);
+  }
+  return { primary: lines.join("\n"), diagnostic: diagnosticJson(outcome) };
+}
+
+// src/harness-notice/harness-notice.monitor-tick.ts
+function formatMonitorTickNotice(tick) {
+  const lines = [];
+  const monitorId = typeof tick.monitorId === "string" ? tick.monitorId : void 0;
+  lines.push(
+    monitorId ? `Harness monitor tick \xB7 ${tick.runId} (${monitorId})` : `Harness monitor tick \xB7 ${tick.runId}`
+  );
+  if (!tick.workers.length) {
+    lines.push("No workers in scope for this poll.");
+    return { primary: lines.join("\n"), diagnostic: diagnosticJson(tick) };
+  }
+  for (const view of tick.workers) {
+    const auto = view.autoComplete.eligible ? "eligible for auto-complete" : "not auto-completing";
+    const blockers = view.autoComplete.blockers.length > 0 ? ` (${view.autoComplete.blockers.slice(0, 2).join("; ")})` : "";
+    lines.push(
+      `\u2022 ${view.worker}: ${view.workerStatus}, ${view.health}${view.healthReason ? ` \u2014 ${view.healthReason}` : ""}; ${auto}${blockers}`
+    );
+    if (view.taskStatus) {
+      lines.push(`  Board task: ${view.taskStatus}${view.leaseOwner ? ` (lease: ${view.leaseOwner})` : ""}`);
+    }
+  }
+  const completed = tick.autoCompleted?.filter((a) => a.outcome === "completed" && a.ok) ?? [];
+  const blocked = tick.autoCompleted?.filter((a) => !a.ok && a.outcome !== "skipped") ?? [];
+  if (completed.length) {
+    lines.push(
+      `Auto-completed: ${completed.map((c) => c.worker).join(", ")} \u2014 AgentOS completion should be posted.`
+    );
+  }
+  if (blocked.length) {
+    lines.push(
+      `Auto-complete blocked: ${blocked.map((c) => `${c.worker}${c.reason ? ` (${c.reason})` : ""}`).join("; ")}`
+    );
+  }
+  if (tick.leaseRenewal?.failed?.length) {
+    lines.push(`Lease renew failed for: ${tick.leaseRenewal.failed.map((f) => f.worker).join(", ")}`);
+  }
+  const allDone = tick.workers.length > 0 && tick.workers.every((w) => w.autoComplete.terminalVerified) && (tick.autoCompleted?.every((a) => a.ok || a.outcome === "skipped") ?? true);
+  lines.push(
+    allDone ? "Next: monitor loop should stop \u2014 all workers terminal and handled." : "Next: monitor will poll again until workers are terminal-verified or max time elapses."
+  );
+  return { primary: lines.join("\n"), diagnostic: diagnosticJson(tick) };
+}
+
+// src/harness-notice/harness-notice.worker-complete.ts
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function str(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function formatWorkerCompleteNotice(data) {
+  const rec = record(data);
+  if (!rec) {
+    return {
+      primary: "Harness worker complete finished with no parseable result.",
+      diagnostic: diagnosticJson(data)
+    };
+  }
+  const worker = str(rec.worker) ?? "worker";
+  const runId = str(rec.runId);
+  const skipped = str(rec.status) === "skipped";
+  const httpStatus = typeof rec.httpStatus === "number" ? rec.httpStatus : null;
+  const response = record(rec.response);
+  const lines = [];
+  lines.push(`Harness worker complete \xB7 ${worker}${runId ? ` (${runId})` : ""}`);
+  if (skipped) {
+    lines.push(`Outcome: skipped \u2014 ${str(rec.reason) ?? "worker not finished yet"}.`);
+    lines.push("Next: wait for the worker to exit or post a finalResult, then retry complete.");
+    return { primary: lines.join("\n"), diagnostic: diagnosticJson(data) };
+  }
+  const routeOutcome = str(response?.outcome);
+  const taskRec = record(response?.task);
+  const taskStatus = str(taskRec?.status);
+  const prUrl = str(taskRec?.prUrl) ?? str(response?.prUrl);
+  if (httpStatus && httpStatus >= 200 && httpStatus < 300) {
+    lines.push("Outcome: completion callback accepted by AgentOS.");
+    if (routeOutcome) lines.push(`Routing: ${routeOutcome.replace(/_/g, " ")}`);
+    if (taskStatus) lines.push(`AgentOS task status: ${taskStatus}`);
+    if (prUrl) lines.push(`PR: ${prUrl}`);
+    lines.push("Next: check Command Center for review scheduling or blockers.");
+  } else {
+    lines.push(
+      `Outcome: completion failed${httpStatus != null ? ` (HTTP ${httpStatus})` : ""}.`
+    );
+    const detail = str(response?.detail) ?? str(response?.error);
+    if (detail) lines.push(`Blocker: ${detail}`);
+    lines.push("Next: fix the reported blocker and replay completion from the board.");
+  }
+  return { primary: lines.join("\n"), diagnostic: diagnosticJson(data) };
+}
+
+// src/harness-notice/harness-notice.worker-status.ts
+function str2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function prFromFinalResult(finalResult) {
+  const fr = record2(finalResult);
+  if (!fr) return null;
+  return str2(fr.prUrl) ?? str2(fr.pr);
+}
+function formatWorkerStatusNotice(status) {
+  const rec = record2(status);
+  if (!rec) {
+    return {
+      primary: "Harness worker status unavailable.",
+      diagnostic: diagnosticJson(status)
+    };
+  }
+  const worker = str2(rec.worker) ?? str2(rec.name) ?? "worker";
+  const runId = str2(rec.runId);
+  const workerStatus2 = str2(rec.status) ?? "unknown";
+  const alive = rec.alive === true;
+  const attention = record2(rec.attention);
+  const attentionState = str2(attention?.state) ?? str2(rec.attentionState);
+  const attentionReason = str2(attention?.reason) ?? str2(rec.attentionReason);
+  const taskId = str2(rec.taskId);
+  const prUrl = str2(rec.prUrl) ?? prFromFinalResult(rec.finalResult);
+  const branch = str2(rec.branch);
+  const headCommit = str2(rec.headCommit);
+  const lines = [];
+  lines.push(`Harness worker ${worker}${runId ? ` (${runId})` : ""}`);
+  lines.push(`Process: ${alive ? "running" : "stopped"} \xB7 harness status: ${workerStatus2}`);
+  if (attentionState) {
+    lines.push(
+      attentionReason ? `Attention: ${attentionState} \u2014 ${attentionReason}` : `Attention: ${attentionState}`
+    );
+  }
+  if (taskId) lines.push(`AgentOS task: ${taskId}`);
+  if (prUrl) lines.push(`PR: ${prUrl}`);
+  if (branch) lines.push(`Branch: ${branch}`);
+  if (headCommit) lines.push(`Commit: ${headCommit.slice(0, 12)}`);
+  if (workerStatus2 === "done" || workerStatus2 === "exited") {
+    lines.push(
+      prUrl ? "Outcome: worker finished \u2014 open the PR or check Command Center for review routing." : "Outcome: worker finished \u2014 check Command Center for task status and next action."
+    );
+  } else if (attentionState === "blocked" || attentionState === "needs_attention") {
+    lines.push("Next: resolve the blocker on the board or wait for the monitor to auto-complete when terminal.");
+  } else if (alive) {
+    lines.push("Next: wait for completion or poll again; background monitor will auto-complete when eligible.");
+  }
+  return { primary: lines.join("\n"), diagnostic: diagnosticJson(status) };
+}
+
+// src/harness-notice/harness-notice.tool-response.ts
+var DIVIDER = "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 Diagnostic (JSON) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+function joinHarnessNotice(notice) {
+  if (!notice.diagnostic?.trim()) return notice.primary;
+  return `${notice.primary}
+
+${DIVIDER}
+${notice.diagnostic}`;
+}
+function failureNotice(ctx) {
+  const lines = [`Harness ${ctx.scope} ${ctx.action} failed.`];
+  if (ctx.timedOut) lines.push("Reason: command timed out on the runner host.");
+  else if (ctx.error) lines.push(`Reason: ${ctx.error}`);
+  else if (ctx.exitCode != null) lines.push(`Exit code: ${ctx.exitCode}`);
+  const errText = ctx.stderr.trim();
+  if (errText) lines.push(`Stderr: ${errText.split("\n").slice(-3).join(" ")}`);
+  lines.push("Next: retry on the runner host or inspect harness logs.");
+  const parsed = firstJsonFromStdout(ctx.stdout);
+  return {
+    primary: lines.join("\n"),
+    diagnostic: diagnosticJson(parsed ?? { stdout: ctx.stdout, stderr: ctx.stderr })
+  };
+}
+function formatHarnessToolReadable(ctx) {
+  if (!ctx.ok) return failureNotice(ctx);
+  const parsed = firstJsonFromStdout(ctx.stdout);
+  if (parsed === null) {
+    const text = ctx.stdout.trim() || ctx.stderr.trim() || "(no output)";
+    return {
+      primary: `Harness ${ctx.scope} ${ctx.action} finished.
+${text.slice(0, 800)}`,
+      diagnostic: diagnosticJson({ stdout: ctx.stdout, stderr: ctx.stderr })
+    };
+  }
+  if (ctx.scope === "worker" && ctx.action === "status") {
+    return formatWorkerStatusNotice(parsed);
+  }
+  if (ctx.scope === "worker" && ctx.action === "complete") {
+    return formatWorkerCompleteNotice(parsed);
+  }
+  if (ctx.scope === "monitor" && (ctx.action === "tick" || ctx.action === "run-loop")) {
+    return formatMonitorTickNotice(parsed);
+  }
+  if (ctx.scope === "monitor" && ctx.action === "auto-complete") {
+    const rec = parsed;
+    if (rec.outcome && rec.worker && rec.runId) {
+      return formatAutoCompleteOutcomeNotice(parsed);
+    }
+    if (Array.isArray(rec.blockers)) {
+      return {
+        primary: [
+          `Monitor auto-complete blocked \xB7 ${rec.runId ?? "run"} / ${rec.worker ?? "worker"}`,
+          `Blockers: ${rec.blockers.join("; ")}`,
+          "Next: resolve blockers on the runner, then retry auto-complete."
+        ].join("\n"),
+        diagnostic: diagnosticJson(parsed)
+      };
+    }
+  }
+  if (ctx.scope === "run" && ctx.action === "status") {
+    const workers = parsed.workers;
+    if (Array.isArray(workers) && workers.length === 1) {
+      return formatWorkerStatusNotice(workers[0]);
+    }
+    return {
+      primary: `Harness run status \xB7 ${parsed.runId ?? "run"} (${Array.isArray(workers) ? workers.length : 0} workers).`,
+      diagnostic: diagnosticJson(parsed)
+    };
+  }
+  return {
+    primary: `Harness ${ctx.scope} ${ctx.action} completed successfully on the runner.`,
+    diagnostic: diagnosticJson(parsed)
+  };
+}
+
 // src/monitor/monitor.service.ts
-import path40 from "node:path";
+import path46 from "node:path";
 
 // src/monitor/monitor.classify.ts
 function expectedLeaseOwner(runId) {
@@ -7074,11 +8270,11 @@ function classifyWorkerHealth(input) {
 }
 
 // src/monitor/monitor.store.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync6, readdirSync as readdirSync8, unlinkSync as unlinkSync2 } from "node:fs";
-import path39 from "node:path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync6, readdirSync as readdirSync9, unlinkSync as unlinkSync2 } from "node:fs";
+import path45 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path39.join(harnessRoot, "monitors");
+  const dir = path45.join(harnessRoot, "monitors");
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
@@ -7086,7 +8282,7 @@ function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path39.join(monitorsDir(), `${monitorId}.json`);
+  return path45.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -7096,18 +8292,18 @@ function saveMonitorSession(session) {
 }
 function deleteMonitorSession(monitorId) {
   const file = monitorPath(monitorId);
-  if (!existsSync24(file)) return false;
+  if (!existsSync28(file)) return false;
   unlinkSync2(file);
   return true;
 }
 function listMonitorSessions() {
   const dir = monitorsDir();
-  if (!existsSync24(dir)) return [];
+  if (!existsSync28(dir)) return [];
   const entries = [];
-  for (const name of readdirSync8(dir)) {
+  for (const name of readdirSync9(dir)) {
     if (!name.endsWith(".json")) continue;
     const session = readJson(
-      path39.join(dir, name),
+      path45.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -7198,7 +8394,7 @@ async function fetchTaskLeasesForWorkers(input) {
 // src/monitor/monitor.service.ts
 function workerRecord2(runId, name) {
   return readJson(
-    path40.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path46.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -7383,7 +8579,11 @@ async function runMonitorLoop(args) {
       autoComplete: args.autoComplete ?? true,
       renewLeases: args.renewLeases ?? true
     });
-    console.log(JSON.stringify({ monitorId, phase: "tick", ...tick }));
+    const notice = formatMonitorTickNotice({ monitorId, phase: "tick", ...tick });
+    console.log(notice.primary);
+    if (notice.diagnostic) {
+      console.error(`[monitor diagnostic] ${notice.diagnostic}`);
+    }
     const allTerminal = tick.workers.length > 0 && tick.workers.every(
       (w) => w.autoComplete.terminalVerified && (w.autoComplete.eligible || w.autoComplete.blockers.some((b) => b.includes("already acknowledged")))
     );
@@ -7400,18 +8600,18 @@ async function runMonitorLoop(args) {
 
 // src/monitor/monitor-spawn.ts
 import { spawn as spawn4 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync25, openSync as openSync4 } from "node:fs";
-import path41 from "node:path";
+import { closeSync as closeSync4, existsSync as existsSync29, openSync as openSync4 } from "node:fs";
+import path47 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path41.join(fileURLToPath4(new URL(".", import.meta.url)), "cli.js");
+  return path47.join(fileURLToPath4(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
-  if (!existsSync25(cliPath)) return void 0;
+  if (!existsSync29(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path41.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path47.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
     logFd = openSync4(logPath, "a");
@@ -7531,12 +8731,12 @@ async function monitorTickCli(args) {
 }
 
 // src/doctor/runtime-takeover.ts
-import path43 from "node:path";
+import path49 from "node:path";
 
 // src/doctor/runtime-takeover.probes.ts
-import { accessSync, constants, existsSync as existsSync26, readFileSync as readFileSync12 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import path42 from "node:path";
+import { accessSync, constants, existsSync as existsSync30, readFileSync as readFileSync13 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import path48 from "node:path";
 import { spawnSync as spawnSync7 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
@@ -7565,7 +8765,7 @@ function tokenPrefix(token) {
   return trimmed.length <= 12 ? `${trimmed}\u2026` : `${trimmed.slice(0, 12)}\u2026`;
 }
 function isWritable(target) {
-  if (!existsSync26(target)) return false;
+  if (!existsSync30(target)) return false;
   try {
     accessSync(target, constants.W_OK);
     return true;
@@ -7578,15 +8778,15 @@ var defaultRuntimeTakeoverProbes = {
   commandOnPath: (bin) => captureCommand(process.platform === "win32" ? "where" : "which", [bin]),
   kynverVersion: (bin) => captureCommand(bin, ["--version"]),
   loadConfig: () => loadUserConfig(),
-  configFilePath: () => path42.join(homedir7(), ".kynver", "config.json"),
-  credentialsFilePath: () => path42.join(homedir7(), ".kynver", "credentials"),
+  configFilePath: () => path48.join(homedir8(), ".kynver", "config.json"),
+  credentialsFilePath: () => path48.join(homedir8(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path42.join(homedir7(), ".kynver", "credentials");
-    if (!existsSync26(credPath)) {
+    const credPath = path48.join(homedir8(), ".kynver", "credentials");
+    if (!existsSync30(credPath)) {
       return { hasApiKey: false };
     }
     try {
-      const parsed = JSON.parse(readFileSync12(credPath, "utf8"));
+      const parsed = JSON.parse(readFileSync13(credPath, "utf8"));
       return {
         hasApiKey: Boolean(parsed.apiKey?.trim()),
         runnerTokenPrefix: tokenPrefix(parsed.runnerToken),
@@ -7613,8 +8813,8 @@ var defaultRuntimeTakeoverProbes = {
     })()
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path42.join(homedir7(), ".openclaw", "harness"),
-  pathExists: (target) => existsSync26(target),
+  legacyOpenclawHarnessRoot: () => path48.join(homedir8(), ".openclaw", "harness"),
+  pathExists: (target) => existsSync30(target),
   pathWritable: (target) => isWritable(target),
   vercelVersion: () => captureCommand("vercel", ["--version"]),
   vercelWhoami: () => captureCommand("vercel", ["whoami"])
@@ -7662,7 +8862,7 @@ function assessRuntimeTakeoverScheduler(env, ctx) {
       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.",
+      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; after Vercel env is updated run `kynver scheduler attest-cutover`.",
       details: schedulerDetails
     });
   }
@@ -7942,8 +9142,8 @@ function assessVercelCli(probes) {
 }
 function assessHarnessDirs(probes) {
   const harnessRoot = probes.harnessRoot();
-  const runsDir = path43.join(harnessRoot, "runs");
-  const worktreesDir = path43.join(harnessRoot, "worktrees");
+  const runsDir = path49.join(harnessRoot, "runs");
+  const worktreesDir = path49.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -8131,6 +9331,131 @@ async function runCommandCenterContractCli(args) {
   console.log(JSON.stringify(res.response, null, 2));
 }
 
+// src/scheduler-cutover.ts
+var DEPLOYMENT_SCHEDULER_CUTOVER_STEPS = [
+  "Vercel/hosted: set KYNVER_SCHEDULER_PROVIDER=qstash",
+  "Vercel/hosted: ensure QSTASH_TOKEN (and QStash signing keys) are configured",
+  "Vercel/hosted: unset OPENCLAW_CRON_STORE_PATH if present"
+];
+var RUNNER_SCHEDULER_CUTOVER_STEPS = [
+  "User runner: unset KYNVER_SCHEDULER_PROVIDER (scheduling is deployment-owned)",
+  "User runner: unset OPENCLAW_CRON_STORE_PATH, OPENCLAW_CRON_SECRET, OPENCLAW_CRON_FIRE_BASE_URL",
+  'User runner: after deployment cutover, run `kynver scheduler attest-cutover` (or set deploymentSchedulerProvider to "qstash" in ~/.kynver/config.json)',
+  "Verify: kynver doctor runtime-takeover \u2014 hotspot_openclaw_scheduler should pass"
+];
+function readSchedulerCutoverEnv(env = process.env) {
+  return {
+    kynverSchedulerProvider: env.KYNVER_SCHEDULER_PROVIDER?.trim() || null,
+    openclawCronStorePath: env.OPENCLAW_CRON_STORE_PATH?.trim() || null,
+    openclawCronSecret: Boolean(env.OPENCLAW_CRON_SECRET?.trim()),
+    openclawCronFireBaseUrl: env.OPENCLAW_CRON_FIRE_BASE_URL?.trim() || null
+  };
+}
+function assessSchedulerCutover(config, env = readSchedulerCutoverEnv()) {
+  const blockers = [];
+  if (env.kynverSchedulerProvider === "openclaw-cron") {
+    blockers.push("Runner still has KYNVER_SCHEDULER_PROVIDER=openclaw-cron");
+  }
+  if (env.openclawCronStorePath) {
+    blockers.push("Runner still has OPENCLAW_CRON_STORE_PATH");
+  }
+  if (config.deploymentSchedulerProvider === "openclaw-cron") {
+    blockers.push("~/.kynver/config.json deploymentSchedulerProvider is still openclaw-cron");
+  }
+  return {
+    ok: blockers.length === 0,
+    blockers,
+    runnerEnv: env,
+    deploymentSchedulerProvider: config.deploymentSchedulerProvider ?? null,
+    deploymentSteps: [...DEPLOYMENT_SCHEDULER_CUTOVER_STEPS],
+    runnerSteps: [...RUNNER_SCHEDULER_CUTOVER_STEPS]
+  };
+}
+function applySchedulerCutoverAttestation(config) {
+  return {
+    ...config,
+    deploymentSchedulerProvider: "qstash"
+  };
+}
+
+// src/scheduler-cutover-cli.ts
+import path50 from "node:path";
+import { homedir as homedir9 } from "node:os";
+var CONFIG_FILE2 = path50.join(homedir9(), ".kynver", "config.json");
+function runSchedulerCutoverCheckCli(json = false) {
+  const config = loadUserConfig();
+  const report = assessSchedulerCutover(config);
+  const payload = {
+    ...report,
+    configPath: displayUserPath(CONFIG_FILE2),
+    configAttestationExample: { deploymentSchedulerProvider: "qstash" }
+  };
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+    if (!report.ok) process.exitCode = 1;
+    return;
+  }
+  console.log("AgentOS scheduler provider cutover checklist\n");
+  console.log("Deployment (Vercel):");
+  for (const step of DEPLOYMENT_SCHEDULER_CUTOVER_STEPS) console.log(`  - ${step}`);
+  console.log("\nUser runner:");
+  for (const step of RUNNER_SCHEDULER_CUTOVER_STEPS) console.log(`  - ${step}`);
+  console.log("\nThis host:");
+  console.log(`  config: ${payload.configPath}`);
+  console.log(
+    `  deploymentSchedulerProvider: ${report.deploymentSchedulerProvider ?? "(unset)"}`
+  );
+  console.log(
+    `  KYNVER_SCHEDULER_PROVIDER: ${report.runnerEnv.kynverSchedulerProvider ?? "(unset)"}`
+  );
+  console.log(
+    `  OPENCLAW_CRON_STORE_PATH: ${report.runnerEnv.openclawCronStorePath ?? "(unset)"}`
+  );
+  if (report.blockers.length) {
+    console.log("\nBlockers:");
+    for (const b of report.blockers) console.log(`  ! ${b}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log("\nNo local blockers detected on this runner.");
+}
+function runSchedulerAttestCutoverCli(json = false) {
+  const existing = loadUserConfig();
+  const report = assessSchedulerCutover(existing);
+  if (!report.ok) {
+    const payload2 = {
+      ok: false,
+      attested: false,
+      blockers: report.blockers,
+      remediation: "Clear local OpenClaw scheduler blockers before attesting qstash cutover."
+    };
+    if (json) {
+      console.log(JSON.stringify(payload2, null, 2));
+    } else {
+      console.error("Cannot attest scheduler cutover \u2014 local blockers remain:");
+      for (const b of report.blockers) console.error(`  ! ${b}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const next = applySchedulerCutoverAttestation(existing);
+  saveUserConfig(next);
+  const payload = {
+    ok: true,
+    attested: true,
+    configPath: displayUserPath(CONFIG_FILE2),
+    deploymentSchedulerProvider: "qstash",
+    config: presentUserConfig(next),
+    note: "Recorded deploymentSchedulerProvider=qstash in ~/.kynver/config.json. Confirm Vercel has KYNVER_SCHEDULER_PROVIDER=qstash and QSTASH_TOKEN before relying on hosted schedules."
+  };
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log(payload.note);
+  console.log(`  config: ${payload.configPath}`);
+}
+
 // src/cli.ts
 function isHelpFlag(arg) {
   return arg === "help" || arg === "--help" || arg === "-h";
@@ -8178,6 +9503,8 @@ function usage(code = 0) {
       "  kynver monitor auto-complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--base-url URL] [--secret SECRET]",
       "  kynver monitor run-loop --run RUN_ID --monitor-id ID [--name worker] [--agent-os-id AOS_ID] [--poll-ms MS] [--auto-complete] [--renew-leases]",
       "  kynver doctor runtime-takeover",
+      "  kynver scheduler cutover-check [--json]",
+      "  kynver scheduler attest-cutover [--json]",
       "  kynver board contract [--agent-os-id ID] [--base-url URL] [--since ISO] [--limit N]"
     ].join("\n")
   );
@@ -8189,7 +9516,7 @@ async function main(argv = process.argv.slice(2)) {
   const scope = argv.shift();
   let action;
   let rest;
-  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner" || scope === "harness" || scope === "monitor" || scope === "doctor" || scope === "board") {
+  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner" || scope === "harness" || scope === "monitor" || scope === "doctor" || scope === "scheduler" || scope === "board") {
     action = argv.shift();
     rest = argv;
   } else {
@@ -8216,6 +9543,12 @@ async function main(argv = process.argv.slice(2)) {
   }
   if (scope === "cleanup") return runCleanupCli(args);
   if (scope === "doctor" && action === "runtime-takeover") return runRuntimeTakeoverDoctorCli();
+  if (scope === "scheduler" && action === "cutover-check") {
+    return runSchedulerCutoverCheckCli(args.json === true);
+  }
+  if (scope === "scheduler" && action === "attest-cutover") {
+    return runSchedulerAttestCutoverCli(args.json === true);
+  }
   if (scope === "board" && action === "contract") {
     return void await runCommandCenterContractCli(args);
   }
@@ -8255,6 +9588,19 @@ if (isCliEntry) {
 
 // src/vercel/vercel-url.ts
 var VERCEL_HOST_RE = /(^|\.)vercel\.app$/i;
+var DPL_ID_RE = /^dpl_[a-z0-9]+$/i;
+function isInspectableVercelTarget(target) {
+  const trimmed = target.trim();
+  if (!trimmed) return false;
+  if (/vercel\.com/i.test(trimmed)) return false;
+  if (DPL_ID_RE.test(trimmed)) return true;
+  try {
+    const url = new URL(trimmed.startsWith("http") ? trimmed : `https://${trimmed}`);
+    return VERCEL_HOST_RE.test(url.hostname);
+  } catch {
+    return false;
+  }
+}
 function tryParseUrl(raw) {
   const trimmed = raw.trim();
   if (!trimmed) return null;
@@ -8308,10 +9654,11 @@ function classifyVercelUrl(raw) {
   }
   if (url.hostname === "vercel.com" || url.hostname.endsWith(".vercel.com")) {
     const deploymentId = parseDeploymentsSegment(url) ?? parseDashboardDeployment(url);
+    const inspectTarget = deploymentId && DPL_ID_RE.test(deploymentId) ? deploymentId : null;
     return {
       kind: "dashboard",
       previewUrl: null,
-      inspectTarget: deploymentId,
+      inspectTarget,
       deploymentId
     };
   }
@@ -8386,14 +9733,14 @@ function resolveVercelInspectTarget(rawUrl) {
     return { target: null, classified: null, reason: "missing target_url" };
   }
   const classified = classifyVercelUrl(trimmed);
-  if (classified.inspectTarget) {
+  if (classified.inspectTarget && isInspectableVercelTarget(classified.inspectTarget)) {
     return { target: classified.inspectTarget, classified, reason: null };
   }
   if (classified.kind === "dashboard") {
     return {
       target: null,
       classified,
-      reason: "dashboard URL is not valid for vercel inspect"
+      reason: classified.deploymentId ? "dashboard deployment id is not CLI-inspectable; trust GitHub Vercel status" : "dashboard URL is not valid for vercel inspect"
     };
   }
   return { target: null, classified, reason: "unrecognized Vercel URL" };
@@ -8434,6 +9781,15 @@ function evidenceFromGitHubVercelStatus(statuses, options = {}) {
   };
 }
 function defaultRunVercelInspect(target, waitSeconds) {
+  if (!isInspectableVercelTarget(target)) {
+    return {
+      ok: false,
+      exitCode: 1,
+      stdout: "",
+      stderr: "",
+      error: "refusing vercel inspect on non-inspectable target (dashboard URLs use GitHub status)"
+    };
+  }
   const args = ["inspect", target, "--wait", String(waitSeconds)];
   const result = spawnSync8("vercel", args, {
     encoding: "utf8",
@@ -8544,10 +9900,14 @@ function collectVercelEvidence(input) {
 export {
   DEFAULT_DISPATCH_LEASE_MS,
   DEFAULT_HARNESS_VERIFY_COMMANDS,
+  DEFAULT_NODE_MODULES_AGE_MS,
+  DEFAULT_WORKER_PROVIDER,
+  DEFAULT_WORKTREES_AGE_MS,
   DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES,
   DEFAULT_WSL_HOST_MOUNT,
   DEFAULT_WSL_HOST_WARN_FREE_BYTES,
   FORBIDDEN_WORKER_ENV_KEYS,
+  HARNESS_BUILD_CACHE_RELATIVE_PATHS,
   PACKAGE_VERSION,
   applyProductionDatabaseToProcess,
   assessAutoCompleteEligibility,
@@ -8560,8 +9920,10 @@ export {
   auditWorkerEnv,
   autoCompleteWorker,
   autoCompleteWorkerCli,
+  buildBoxResourceSnapshotFromGate,
   buildDispatchTaskText,
   buildPrompt,
+  buildRunListRows,
   buildSystemdRunArgv,
   classifyNpmAuditOutcome,
   classifyShellCommandOutcome,
@@ -8572,26 +9934,37 @@ export {
   computeAttention,
   computeWorkerStatus,
   createRun,
+  defaultBoxId,
   deriveRunStatus,
   discoverDefaultRepo,
   discoverDefaultRepoCandidates,
   dispatchRun,
   drainPlanOutbox,
+  enforceCursorWorkerProvider,
   ensurePrReadyHandoff,
   evidenceFromGitHubVercelStatus,
   extractPlanOutboxFromTask,
   extractPrUrlFromText,
+  formatAutoCompleteOutcomeNotice,
+  formatHarnessToolReadable,
+  formatHeartbeatLine,
+  formatMonitorTickNotice,
   formatPlanOutboxHandoffBlock,
   formatResolvedDefaultRepo,
+  formatWorkerCompleteNotice,
+  formatWorkerStatusNotice,
   getHarnessPaths,
   getMonitorStatus,
   gitRepoRoot,
   harnessStorageSnapshot,
   hashPlanBody,
+  isClaudeFamilyProvider,
   isDashboardVercelUrl,
   isEngagementRequiredSkip,
   isFinishedWorkerStatus,
   isForbiddenWorkerEnvKey,
+  isGeneratedHarnessPath,
+  isInspectableVercelTarget,
   isKynverMonorepoRoot,
   isLandingBlockedWorkerStatus,
   isPipelineCleanupEnabled,
@@ -8599,11 +9972,13 @@ export {
   isTerminalHeartbeatPhase,
   isVercelStatusContext,
   isWslHost,
+  joinHarnessNotice,
   landingContractAttentionReason,
   listForbiddenWorkerEnvKeys,
   listMonitors,
   listOutboxItems,
   listRuns,
+  listRunsCli,
   loadUserConfig,
   main,
   mergeNodeOptionsForBuildCheck,
@@ -8618,6 +9993,7 @@ export {
   persistPlan,
   pickVercelStatusContext,
   postJson,
+  preferCursorExecutor,
   preflightCursorModel,
   readMemAvailableBytes,
   readProductionDbKeysFromEnvFile,
@@ -8626,8 +10002,10 @@ export {
   redactHarness,
   remediateDefaultRepo,
   resolveBaseUrl,
+  resolveBoxKindFromEnv,
   resolveCallbackSecret,
   resolveCallbackSecretWithMint,
+  resolveConfiguredWorkerProvider,
   resolveDefaultRepo,
   resolveHarnessRoot,
   resolveProductionDatabaseUrl,
@@ -8654,6 +10032,7 @@ export {
   summarizeWslRecoverySteps,
   sweepRun,
   tailWorker,
+  taskAllowsClaudeWorker,
   terminalFinalResultFromHeartbeat,
   usage,
   validateOwnedPaths,