@kynver-app/runtime 0.1.61 → 0.1.66

package/dist/cli.js

@@ -87,10 +87,6 @@ function tailFile(file, lines) {
 function readMaybeFile(file) {
   return file ? readFileSync(path.resolve(file), "utf8") : "";
 }
-function listRunIds(runsDir) {
-  if (!existsSync(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);
 }
@@ -611,7 +607,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;
@@ -733,23 +729,23 @@ function isWslHost() {
 function observeWslHostDisk(options = {}) {
   const wsl = options.forceWsl === void 0 ? isWslHost() : options.forceWsl;
   if (!wsl) return null;
-  const path43 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
+  const path50 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
   const warnBelowBytes = options.wslHostFreeWarnBytes ?? DEFAULT_WSL_HOST_WARN_FREE_BYTES;
   const criticalBelowBytes = options.wslHostFreeCriticalBytes ?? DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES;
   const statfs = options.statfs ?? statfsSync;
   let stats;
   try {
-    stats = statfs(path43);
+    stats = statfs(path50);
   } catch (error) {
     return {
       ok: false,
-      path: path43,
+      path: path50,
       freeBytes: 0,
       totalBytes: 0,
       usedPercent: 100,
       warnBelowBytes,
       criticalBelowBytes,
-      reason: `Windows host disk probe failed at ${path43}: ${error.message}`,
+      reason: `Windows host disk probe failed at ${path50}: ${error.message}`,
       probeError: error.message
     };
   }
@@ -763,11 +759,11 @@ function observeWslHostDisk(options = {}) {
   let reason = null;
   if (!ok) {
     const tag = criticalFree ? "critical" : "warning";
-    reason = `Windows host disk ${path43} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+    reason = `Windows host disk ${path50} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
   }
   return {
     ok,
-    path: path43,
+    path: path50,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -787,12 +783,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 path43 = input.diskPath?.trim() || "/";
+  const path50 = 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(path43);
+  const stats = statfsSync2(path50);
   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;
@@ -815,7 +811,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path43,
+    path: path50,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -895,6 +891,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 (!existsSync6(runsDir)) return [];
   const runs = [];
   for (const entry of readdirSync2(runsDir, { withFileTypes: true })) {
@@ -923,7 +925,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
@@ -944,7 +949,9 @@ function parseHeartbeat(file) {
     lastHeartbeatPhase: null,
     lastHeartbeatSummary: null,
     heartbeatBlocker: null,
-    timestampAnomalies: []
+    timestampAnomalies: [],
+    lastBoxResourceSnapshot: null,
+    lastPrEvidence: []
   };
   if (!existsSync7(file)) return result;
   const maxFutureMs = Date.now() + HEARTBEAT_FUTURE_SKEW_MS;
@@ -971,6 +978,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;
 }
@@ -1488,10 +1503,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(
@@ -1646,6 +1686,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,
@@ -1658,7 +1704,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 {
@@ -1780,9 +1828,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";
@@ -1802,7 +1857,8 @@ function observeRunnerResourceGate(input) {
     maxConcurrentWorkers,
     activeWorkers,
     slotsAvailable,
-    reason
+    reason,
+    ...diskGate ? { diskGate } : {}
   };
 }
 
@@ -1990,10 +2046,76 @@ 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;
+}
+
 // 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() : "";
 }
@@ -2009,11 +2131,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();
@@ -2047,41 +2172,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 {
@@ -2091,31 +2208,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;
@@ -2207,6 +2334,76 @@ function hasLiveWorkerForTask(runId, taskId) {
 import { existsSync as existsSync12, 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.";
@@ -2251,7 +2448,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.",
@@ -2268,6 +2465,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");
@@ -2433,7 +2637,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(", ")}`);
@@ -2529,7 +2741,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;
@@ -2537,7 +2749,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;
@@ -2545,7 +2757,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();
@@ -2557,21 +2769,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;
 }
@@ -2587,7 +2799,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" };
   }
@@ -2598,10 +2810,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" };
   }
@@ -2622,8 +2838,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
   };
 }
 
@@ -2829,6 +3045,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,
@@ -2857,6 +3074,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 {
@@ -2984,13 +3243,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 path43 = normalizeRelativePath(pathFromGitStatusLine(line));
-    return removedSet.has(path43);
+    const path50 = normalizeRelativePath(pathFromGitStatusLine(line));
+    return removedSet.has(path50);
   });
 }
 
 // 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;
@@ -3017,7 +3276,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,
@@ -3028,7 +3287,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,
@@ -3039,7 +3298,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,
@@ -3769,6 +4028,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() : "";
@@ -3779,13 +4051,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;
@@ -3805,10 +4078,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 (existsSync12(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
   git(run.repo, ["fetch", "origin", "--prune"], { allowFailure: true });
-  git(run.repo, ["worktree", "add", "-b", branch, worktreePath, run.baseCommit], { throwError: true });
+  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");
@@ -3821,7 +4099,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 {
@@ -3874,6 +4154,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);
@@ -4545,6 +4827,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) {
@@ -4609,7 +4909,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;
@@ -4621,11 +4922,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`;
@@ -4638,6 +4946,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",
@@ -4730,10 +5039,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),
@@ -4745,10 +5063,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,
@@ -4883,106 +5204,384 @@ async function sweepRun(args) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync5 } from "node:fs";
-import path22 from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync5 } from "node:fs";
+import path25 from "node:path";
 
-// src/default-repo.ts
-import path20 from "node:path";
-function expandConfiguredRepo(value) {
-  return path20.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 formatResolvedDefaultRepo(resolved) {
-  return {
-    defaultRepo: displayUserPath(resolved.repo),
-    source: resolved.source,
-    persistedInConfig: resolved.persistedInConfig
-  };
-}
+// src/run-list.ts
+import { existsSync as existsSync15, readFileSync as readFileSync9 } from "node:fs";
+import path22 from "node:path";
 
-// src/validate.ts
+// src/stale-reconcile.ts
 import path21 from "node:path";
-var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
-function validateRunId(runId) {
-  const trimmed = runId.trim();
-  if (!RUN_ID_RE.test(trimmed)) throw new Error(`invalid run id: ${runId}`);
-  return trimmed;
+
+// src/finalize.ts
+import path20 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(
+      path20.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 validateRepo(repo) {
-  const resolved = path21.resolve(repo);
-  if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
-  return resolved;
+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
-function resolveCreateRunRepo(args) {
-  const explicit = typeof args.repo === "string" ? args.repo.trim() : "";
-  if (explicit) return explicit;
-  const resolved = resolveDefaultRepo();
-  if (resolved) return resolved.repo;
-  required("", "--repo (or set defaultRepo via `kynver setup` / KYNVER_DEFAULT_REPO)");
-  return "";
+// src/stale-reconcile.ts
+var STALE_RECONCILE_HEARTBEAT_MS = 15 * 60 * 1e3;
+function staleReconcileDisabled() {
+  return process.env.KYNVER_NO_STALE_CLEANUP === "1";
 }
-function createRun(args) {
-  const repo = validateRepo(resolveCreateRunRepo(args));
-  ensureGitRepo(repo);
-  const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
-  const dir = runDirectory(id);
-  if (existsSync15(dir)) failExists(`run already exists: ${id}`);
-  mkdirSync5(dir, { recursive: true });
-  const base = String(args.base || "origin/main");
-  const baseCommit = git(repo, ["rev-parse", base]).trim();
-  const run = {
-    id,
-    name: String(args.name || id),
-    repo,
-    base,
-    baseCommit,
+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 = path21.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 || !existsSync15(heartbeatPath)) return 0;
+  try {
+    return readFileSync9(heartbeatPath, "utf8").trim().length;
+  } catch {
+    return 0;
+  }
+}
+function workerEvidence(run, workerName) {
+  const workerPath = path22.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 = path22.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 path23 from "node:path";
+function expandConfiguredRepo(value) {
+  return path23.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 formatResolvedDefaultRepo(resolved) {
+  return {
+    defaultRepo: displayUserPath(resolved.repo),
+    source: resolved.source,
+    persistedInConfig: resolved.persistedInConfig
+  };
+}
+
+// src/validate.ts
+import path24 from "node:path";
+var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
+function validateRunId(runId) {
+  const trimmed = runId.trim();
+  if (!RUN_ID_RE.test(trimmed)) throw new Error(`invalid run id: ${runId}`);
+  return trimmed;
+}
+function validateRepo(repo) {
+  const resolved = path24.resolve(repo);
+  if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
+  return resolved;
+}
+
+// src/worktree.ts
+function resolveCreateRunRepo(args) {
+  const explicit = typeof args.repo === "string" ? args.repo.trim() : "";
+  if (explicit) return explicit;
+  const resolved = resolveDefaultRepo();
+  if (resolved) return resolved.repo;
+  required("", "--repo (or set defaultRepo via `kynver setup` / KYNVER_DEFAULT_REPO)");
+  return "";
+}
+function createRun(args) {
+  const repo = validateRepo(resolveCreateRunRepo(args));
+  ensureGitRepo(repo);
+  const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
+  const dir = runDirectory(id);
+  if (existsSync16(dir)) failExists(`run already exists: ${id}`);
+  mkdirSync5(dir, { recursive: true });
+  const base = String(args.base || "origin/main");
+  const baseCommit = git(repo, ["rev-parse", base]).trim();
+  const run = {
+    id,
+    name: String(args.name || id),
+    repo,
+    base,
+    baseCommit,
     status: "created",
     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);
@@ -4990,8 +5589,8 @@ function failExists(message) {
 }
 
 // src/discard-disposable.ts
-import { existsSync as existsSync16, rmSync } from "node:fs";
-import path23 from "node:path";
+import { existsSync as existsSync17, rmSync } from "node:fs";
+import path26 from "node:path";
 function normalizeRelativePath2(value) {
   const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").trim();
   if (!normalized || normalized.startsWith("/") || normalized.includes("..")) {
@@ -5012,15 +5611,15 @@ function discardDisposableArtifacts(args) {
   if (paths.length === 0) {
     return { ok: false, removed: [], reason: "requires at least one --path" };
   }
-  const worktreeRoot = path23.resolve(worker.worktreePath);
+  const worktreeRoot = path26.resolve(worker.worktreePath);
   const removed = [];
   for (const raw of paths) {
     const rel = normalizeRelativePath2(raw);
-    const abs = path23.resolve(worktreeRoot, rel);
-    if (!abs.startsWith(worktreeRoot + path23.sep) && abs !== worktreeRoot) {
+    const abs = path26.resolve(worktreeRoot, rel);
+    if (!abs.startsWith(worktreeRoot + path26.sep) && abs !== worktreeRoot) {
       return { ok: false, removed, reason: `path escapes worktree: ${raw}` };
     }
-    if (!existsSync16(abs)) {
+    if (!existsSync17(abs)) {
       return { ok: false, removed, reason: `path not found: ${raw}` };
     }
     rmSync(abs, { recursive: true, force: true });
@@ -5043,7 +5642,7 @@ function discardDisposableCli(args) {
 }
 
 // src/pipeline-tick.ts
-import path35 from "node:path";
+import path41 from "node:path";
 
 // src/pipeline-dispatch.ts
 var RESERVED_REVIEW_STARTS = 1;
@@ -5123,175 +5722,47 @@ function resolvePipelineMaxStarts(resourceGate, operatorTick) {
   };
 }
 
-// src/stale-reconcile.ts
-import path25 from "node:path";
+// src/box-resource-snapshot.ts
+import os5 from "node:os";
 
-// src/finalize.ts
-import path24 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(
-      path24.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";
+// 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 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;
+function defaultBoxId(boxKind, hostLabel) {
+  const host = (hostLabel ?? os4.hostname()).trim().toLowerCase().replace(/\s+/g, "-") || "unknown-host";
+  return `${boxKind}:${host}`;
 }
 
-// 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 = path25.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/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 } : {}
+  };
 }
 
 // src/plan-progress-daemon-sync.ts
-import path26 from "node:path";
+import path27 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -5315,7 +5786,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path26.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path27.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -5364,7 +5835,10 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 }
 
 // src/cleanup.ts
-import path33 from "node:path";
+import path39 from "node:path";
+
+// src/cleanup-guards.ts
+import path28 from "node:path";
 
 // src/cleanup-run-liveness.ts
 function isWorkerProcessLive(indexed) {
@@ -5385,12 +5859,30 @@ function runBlocksWorktreeRemoval(indexed) {
   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);
   });
 }
 
@@ -5455,35 +5947,27 @@ 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(path28.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 existsSync18, rmSync as rmSync2 } from "node:fs";
-import path28 from "node:path";
+import { existsSync as existsSync19, rmSync as rmSync2 } from "node:fs";
+import path30 from "node:path";
 
 // src/cleanup-dir-size.ts
-import { existsSync as existsSync17, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
-import path27 from "node:path";
+import { existsSync as existsSync18, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
+import path29 from "node:path";
 function directorySizeBytes(root, maxEntries = 5e4) {
-  if (!existsSync17(root)) return 0;
+  if (!existsSync18(root)) return 0;
   let total = 0;
   let seen = 0;
   const stack = [root];
@@ -5497,7 +5981,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path27.join(current, name);
+      const full = path29.join(current, name);
       let st;
       try {
         st = statSync2(full);
@@ -5512,8 +5996,8 @@ function directorySizeBytes(root, maxEntries = 5e4) {
 }
 
 // src/cleanup-execute.ts
-function removeNodeModules(candidate, execute) {
-  if (!existsSync18(candidate.path)) {
+function removeDependencyCache(candidate, execute) {
+  if (!existsSync19(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -5543,8 +6027,17 @@ 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 (!existsSync18(candidate.path)) {
+  if (!existsSync19(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -5561,7 +6054,7 @@ function removeWorktree(candidate, execute) {
     if (repo) {
       git(repo, ["worktree", "remove", "--force", candidate.path], { allowFailure: true });
     }
-    if (existsSync18(candidate.path)) {
+    if (existsSync19(candidate.path)) {
       rmSync2(candidate.path, { recursive: true, force: true });
     }
     return {
@@ -5580,21 +6073,37 @@ 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 existsSync19, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
-import path29 from "node:path";
+import { existsSync as existsSync20, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import path31 from "node:path";
 function pathAgeMs(target, now) {
   try {
     const mtime = statSync3(target).mtimeMs;
@@ -5604,50 +6113,57 @@ function pathAgeMs(target, now) {
   }
 }
 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 (!existsSync19(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 (!existsSync20(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)
     });
   }
-  if (!opts.includeOrphans || !existsSync19(opts.worktreesDir)) return candidates;
+  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 || !existsSync20(opts.worktreesDir)) return candidates;
   for (const runEntry of readdirSync6(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 readdirSync6(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path29.join(runPath, workerEntry.name);
-      const nm = path29.join(worktreePath, "node_modules");
-      if (!existsSync19(nm)) continue;
-      const resolved = path29.resolve(nm);
-      if (seen.has(resolved)) continue;
-      if (!isPathInside(resolved, opts.harnessRoot)) continue;
-      seen.add(resolved);
-      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;
@@ -5662,7 +6178,7 @@ function scanWorktreeCandidates(opts) {
     for (const entry of opts.index.values()) {
       if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
       const resolved = entry.worktreePath;
-      if (!existsSync19(resolved)) continue;
+      if (!existsSync20(resolved)) continue;
       if (seen.has(resolved)) continue;
       seen.add(resolved);
       candidates.push({
@@ -5676,15 +6192,15 @@ function scanWorktreeCandidates(opts) {
       });
     }
   }
-  if (!orphanEnabled || !existsSync19(opts.worktreesDir)) return candidates;
+  if (!orphanEnabled || !existsSync20(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 readdirSync6(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path29.join(opts.worktreesDir, runEntry.name);
+    const runPath = path31.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
       workerEntries = readdirSync6(runPath, { withFileTypes: true });
@@ -5693,7 +6209,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;
@@ -5711,18 +6227,191 @@ function scanWorktreeCandidates(opts) {
   return candidates;
 }
 
+// src/cleanup-dependency-scan.ts
+import { existsSync as existsSync21, readdirSync as readdirSync7, statSync as statSync4 } 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 = statSync4(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 (!existsSync21(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 (!existsSync21(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync7(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 = readdirSync7(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 existsSync22, statSync as statSync5 } from "node:fs";
+import path33 from "node:path";
+function pathAgeMs3(target, now) {
+  try {
+    const mtime = statSync5(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 || !existsSync22(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 (!existsSync22(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,
@@ -5781,15 +6470,15 @@ function resolvePipelineHarnessRetention(runId) {
 }
 
 // src/cleanup-orphan-safety.ts
-import { existsSync as existsSync20, statSync as statSync4 } from "node:fs";
-import path31 from "node:path";
+import { existsSync as existsSync23, statSync as statSync6 } 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 (!existsSync20(input.worktreePath)) return null;
+  if (!existsSync23(input.worktreePath)) return null;
   if (input.runId && input.workerName) {
-    const heartbeatPath = path31.join(
+    const heartbeatPath = path35.join(
       input.harnessRoot,
       "runs",
       input.runId,
@@ -5798,13 +6487,13 @@ function assessOrphanWorktreeSafety(input) {
       "heartbeat.jsonl"
     );
     try {
-      const mtime = statSync4(heartbeatPath).mtimeMs;
+      const mtime = statSync6(heartbeatPath).mtimeMs;
       if (now - mtime < heartbeatFreshMs) return "active_worker";
     } catch {
     }
   }
-  const gitDir = path31.join(input.worktreePath, ".git");
-  if (!existsSync20(gitDir)) return null;
+  const gitDir = path35.join(input.worktreePath, ".git");
+  if (!existsSync23(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);
@@ -5833,14 +6522,14 @@ function assessOrphanWorktreeSafety(input) {
 }
 
 // src/harness-storage-snapshot.ts
-import { existsSync as existsSync21, readdirSync as readdirSync7, statSync as statSync5 } from "node:fs";
-import path32 from "node:path";
+import { existsSync as existsSync24, readdirSync as readdirSync8, statSync as statSync7 } from "node:fs";
+import path36 from "node:path";
 function harnessStorageSnapshot(opts = {}) {
   const harnessRoot = opts.harnessRoot ?? resolveHarnessRoot();
-  const worktreesDir = path32.join(harnessRoot, "worktrees");
+  const worktreesDir = path36.join(harnessRoot, "worktrees");
   const now = opts.now ?? Date.now();
   const scannedAt = new Date(now).toISOString();
-  if (!existsSync21(worktreesDir)) {
+  if (!existsSync24(worktreesDir)) {
     return {
       harnessRoot,
       worktreesDir,
@@ -5857,7 +6546,7 @@ function harnessStorageSnapshot(opts = {}) {
   let oldestMs = null;
   let entries;
   try {
-    entries = readdirSync7(worktreesDir, { withFileTypes: true });
+    entries = readdirSync8(worktreesDir, { withFileTypes: true });
   } catch {
     return {
       harnessRoot,
@@ -5872,14 +6561,14 @@ function harnessStorageSnapshot(opts = {}) {
   for (const runEntry of entries) {
     if (!runEntry.isDirectory()) continue;
     runCount += 1;
-    const runPath = path32.join(worktreesDir, runEntry.name);
+    const runPath = path36.join(worktreesDir, runEntry.name);
     try {
-      const st = statSync5(runPath);
+      const st = statSync7(runPath);
       oldestMs = oldestMs === null ? st.mtimeMs : Math.min(oldestMs, st.mtimeMs);
     } catch {
     }
     try {
-      for (const workerEntry of readdirSync7(runPath, { withFileTypes: true })) {
+      for (const workerEntry of readdirSync8(runPath, { withFileTypes: true })) {
         if (workerEntry.isDirectory()) workerCount += 1;
       }
     } catch {
@@ -5906,12 +6595,110 @@ function harnessStorageSnapshot(opts = {}) {
   };
 }
 
+// src/cleanup-harness-roots.ts
+import { existsSync as existsSync25 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import path37 from "node:path";
+var WELL_KNOWN_HARNESS_SCAN_ROOTS = [
+  "/var/tmp/kynver-harness",
+  path37.join(homedir6(), ".openclaw", "harness")
+];
+function addRoot(seen, roots, candidate) {
+  if (!candidate?.trim()) return;
+  const resolved = path37.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 = path37.resolve(candidate);
+      if (!seen.has(resolved) && existsSync25(resolved)) addRoot(seen, roots, resolved);
+    }
+  }
+  return roots;
+}
+
+// src/cleanup-active-worktrees.ts
+import path38 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(
+          path38.join(runDirectoryAt(harnessRoot, run.id), "workers", safeSlug(name), "worker.json"),
+          void 0
+        );
+        if (!worker?.worktreePath) continue;
+        const worktreePath = path38.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 { worktreesDir } = options.harnessRoot ? { worktreesDir: path33.join(harnessRoot, "worktrees") } : getHarnessPaths();
+  const scanRoots = resolveHarnessScanRoots({ harnessRoot });
   const now = options.now ?? Date.now();
-  return { harnessRoot, worktreesDir, now };
+  return { harnessRoot, scanRoots, now };
 }
 function normalizeGuardSkip(skip) {
   if (typeof skip === "string") return { reason: skip };
@@ -5936,72 +6723,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 path39.join(worktreesDir, candidate.runId, candidate.worker);
+  }
+  return path39.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 = path33.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 = path39.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(path33.resolve(candidate.path)) ?? null;
-    const orphanSafety = indexed ? null : assessOrphanWorktreeSafety({
-      worktreePath: candidate.path,
-      harnessRoot: paths.harnessRoot,
-      runId: candidate.runId,
-      workerName: candidate.worker,
-      now: paths.now
-    });
-    const guardSkip = skipWorktreeRemoval({
-      indexed,
-      worktreePath: path33.resolve(candidate.path),
-      includeOrphans: retention.includeOrphans,
       worktreesAgeMs: retention.worktreesAgeMs,
-      ageMs: candidate.ageMs,
-      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 = path39.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(path39.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 = path39.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(path39.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 = path39.resolve(raw.path);
+      if (worktreeSeen.has(resolved)) continue;
+      worktreeSeen.add(resolved);
+      const candidate = attachCandidateBytes({ ...raw, path: resolved }, retention.accountBytes);
+      const indexed = index.get(path39.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: path39.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;
@@ -6022,11 +6882,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,
@@ -6060,8 +6929,8 @@ function isPipelineCleanupEnabled() {
 
 // src/installed-package-versions.ts
 import { readFile } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import path34 from "node:path";
+import { homedir as homedir7 } from "node:os";
+import path40 from "node:path";
 var MANAGED_PACKAGES = [
   "@kynver-app/runtime",
   "@kynver-app/openclaw-agent-os",
@@ -6075,13 +6944,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) ?? path34.join(home, ".openclaw", "npm");
-  const npmGlobalRoot = trim(process.env.KYNVER_NPM_GLOBAL_ROOT) ?? trim(process.env.KYNVER_NPM_GLOBAL_MODULES_ROOT) ?? (trim(process.env.NPM_CONFIG_PREFIX) ? path34.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path34.join(home, ".npm-global", "lib", "node_modules"));
+  const home = homedir7();
+  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path40.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) ? path40.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path40.join(home, ".npm-global", "lib", "node_modules"));
   return unique([
-    path34.join(openClawPrefix, "lib", "node_modules"),
-    path34.join(openClawPrefix, "node_modules"),
-    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path34.join(npmGlobalRoot, "lib", "node_modules")
+    path40.join(openClawPrefix, "lib", "node_modules"),
+    path40.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path40.join(npmGlobalRoot, "lib", "node_modules")
   ]);
 }
 async function readVersion(packageJsonPath) {
@@ -6097,7 +6966,7 @@ async function collectInstalledPackageVersions(observedAt = (/* @__PURE__ */ new
   const out = {};
   for (const packageName of MANAGED_PACKAGES) {
     for (const root of roots) {
-      const packageJsonPath = path34.join(root, packageName, "package.json");
+      const packageJsonPath = path40.join(root, packageName, "package.json");
       const version = await readVersion(packageJsonPath);
       if (!version) continue;
       out[packageName] = { version, observedAt, path: packageJsonPath };
@@ -6113,7 +6982,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path35.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path41.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -6140,18 +7009,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(
+      path41.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 };
 }
@@ -6165,12 +7054,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;
@@ -6251,7 +7140,7 @@ async function runDaemon(args) {
 }
 
 // src/plan-progress.ts
-import path36 from "node:path";
+import path42 from "node:path";
 
 // src/bounded-build/constants.ts
 var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
@@ -6501,7 +7390,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 = {
@@ -6537,7 +7427,7 @@ async function emitPlanProgress(args) {
 }
 function verifyPlanLocal(args) {
   const worktree = required(args.worktree ? String(args.worktree) : void 0, "worktree");
-  const cwd = path36.resolve(worktree);
+  const cwd = path42.resolve(worktree);
   const summary = runHarnessVerifyCommands(cwd);
   const emitJson = args.json === true || args.json === "true";
   const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
@@ -6586,9 +7476,9 @@ async function verifyPlan(args) {
 }
 
 // src/harness-verify-cli.ts
-import path37 from "node:path";
+import path43 from "node:path";
 function runHarnessVerifyCli(args) {
-  const cwd = path37.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const cwd = path43.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;
@@ -6632,7 +7522,7 @@ function runHarnessVerifyCli(args) {
 }
 
 // src/plan-persist-cli.ts
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 var OPERATIONS = ["create", "add_version", "update_metadata"];
 var FAILURE_KINDS = [
   "approval_guard",
@@ -6644,7 +7534,7 @@ var FAILURE_KINDS = [
 function readBodyArg(args) {
   const bodyFile = args.bodyFile ? String(args.bodyFile) : void 0;
   if (bodyFile) {
-    return { body: readFileSync9(bodyFile, "utf8"), bodyPathHint: bodyFile };
+    return { body: readFileSync10(bodyFile, "utf8"), bodyPathHint: bodyFile };
   }
   const inline = args.body ? String(args.body) : void 0;
   if (inline) return { body: inline };
@@ -6733,8 +7623,62 @@ function runCleanupCli(args) {
   }
 }
 
+// src/harness-notice/harness-notice.parse.ts
+var MAX_DIAGNOSTIC_CHARS = 2400;
+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`;
+}
+
+// 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/monitor/monitor.service.ts
-import path39 from "node:path";
+import path45 from "node:path";
 
 // src/monitor/monitor.classify.ts
 function expectedLeaseOwner(runId) {
@@ -6790,11 +7734,11 @@ function classifyWorkerHealth(input) {
 }
 
 // src/monitor/monitor.store.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync6, readdirSync as readdirSync8, unlinkSync as unlinkSync2 } from "node:fs";
-import path38 from "node:path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync6, readdirSync as readdirSync9, unlinkSync as unlinkSync2 } from "node:fs";
+import path44 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path38.join(harnessRoot, "monitors");
+  const dir = path44.join(harnessRoot, "monitors");
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
@@ -6802,7 +7746,7 @@ function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path38.join(monitorsDir(), `${monitorId}.json`);
+  return path44.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -6812,18 +7756,18 @@ function saveMonitorSession(session) {
 }
 function deleteMonitorSession(monitorId) {
   const file = monitorPath(monitorId);
-  if (!existsSync22(file)) return false;
+  if (!existsSync26(file)) return false;
   unlinkSync2(file);
   return true;
 }
 function listMonitorSessions() {
   const dir = monitorsDir();
-  if (!existsSync22(dir)) return [];
+  if (!existsSync26(dir)) return [];
   const entries = [];
-  for (const name of readdirSync8(dir)) {
+  for (const name of readdirSync9(dir)) {
     if (!name.endsWith(".json")) continue;
     const session = readJson(
-      path38.join(dir, name),
+      path44.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -6914,7 +7858,7 @@ async function fetchTaskLeasesForWorkers(input) {
 // src/monitor/monitor.service.ts
 function workerRecord2(runId, name) {
   return readJson(
-    path39.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path45.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -7099,7 +8043,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")))
     );
@@ -7116,18 +8064,18 @@ async function runMonitorLoop(args) {
 
 // src/monitor/monitor-spawn.ts
 import { spawn as spawn4 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync23, openSync as openSync4 } from "node:fs";
-import path40 from "node:path";
+import { closeSync as closeSync4, existsSync as existsSync27, openSync as openSync4 } from "node:fs";
+import path46 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path40.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
+  return path46.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
-  if (!existsSync23(cliPath)) return void 0;
+  if (!existsSync27(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path40.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path46.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
     logFd = openSync4(logPath, "a");
@@ -7247,13 +8195,13 @@ async function monitorTickCli(args) {
 }
 
 // src/package-version.ts
-import { existsSync as existsSync24, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync11 } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function resolvePackageRoot(moduleUrl) {
   let dir = dirname(fileURLToPath4(moduleUrl));
   for (let depth = 0; depth < 6; depth += 1) {
-    if (existsSync24(join(dir, "package.json"))) return dir;
+    if (existsSync28(join(dir, "package.json"))) return dir;
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -7262,7 +8210,7 @@ function resolvePackageRoot(moduleUrl) {
 }
 function readOwnPackageVersion(moduleUrl = import.meta.url) {
   const pkgPath = join(resolvePackageRoot(moduleUrl), "package.json");
-  const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
   if (typeof pkg.version !== "string" || !pkg.version.trim()) {
     throw new Error(`Missing package.json version at ${pkgPath}`);
   }
@@ -7283,12 +8231,12 @@ function handleCliVersionFlag(argv, moduleUrl = import.meta.url, binName) {
 }
 
 // src/doctor/runtime-takeover.ts
-import path42 from "node:path";
+import path48 from "node:path";
 
 // src/doctor/runtime-takeover.probes.ts
-import { accessSync, constants, existsSync as existsSync25, readFileSync as readFileSync11 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import path41 from "node:path";
+import { accessSync, constants, existsSync as existsSync29, readFileSync as readFileSync12 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import path47 from "node:path";
 import { spawnSync as spawnSync6 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
@@ -7317,7 +8265,7 @@ function tokenPrefix(token) {
   return trimmed.length <= 12 ? `${trimmed}\u2026` : `${trimmed.slice(0, 12)}\u2026`;
 }
 function isWritable(target) {
-  if (!existsSync25(target)) return false;
+  if (!existsSync29(target)) return false;
   try {
     accessSync(target, constants.W_OK);
     return true;
@@ -7330,15 +8278,15 @@ var defaultRuntimeTakeoverProbes = {
   commandOnPath: (bin) => captureCommand(process.platform === "win32" ? "where" : "which", [bin]),
   kynverVersion: (bin) => captureCommand(bin, ["--version"]),
   loadConfig: () => loadUserConfig(),
-  configFilePath: () => path41.join(homedir7(), ".kynver", "config.json"),
-  credentialsFilePath: () => path41.join(homedir7(), ".kynver", "credentials"),
+  configFilePath: () => path47.join(homedir8(), ".kynver", "config.json"),
+  credentialsFilePath: () => path47.join(homedir8(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path41.join(homedir7(), ".kynver", "credentials");
-    if (!existsSync25(credPath)) {
+    const credPath = path47.join(homedir8(), ".kynver", "credentials");
+    if (!existsSync29(credPath)) {
       return { hasApiKey: false };
     }
     try {
-      const parsed = JSON.parse(readFileSync11(credPath, "utf8"));
+      const parsed = JSON.parse(readFileSync12(credPath, "utf8"));
       return {
         hasApiKey: Boolean(parsed.apiKey?.trim()),
         runnerTokenPrefix: tokenPrefix(parsed.runnerToken),
@@ -7365,8 +8313,8 @@ var defaultRuntimeTakeoverProbes = {
     })()
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path41.join(homedir7(), ".openclaw", "harness"),
-  pathExists: (target) => existsSync25(target),
+  legacyOpenclawHarnessRoot: () => path47.join(homedir8(), ".openclaw", "harness"),
+  pathExists: (target) => existsSync29(target),
   pathWritable: (target) => isWritable(target),
   vercelVersion: () => captureCommand("vercel", ["--version"]),
   vercelWhoami: () => captureCommand("vercel", ["whoami"])
@@ -7414,7 +8362,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
     });
   }
@@ -7694,8 +8642,8 @@ function assessVercelCli(probes) {
 }
 function assessHarnessDirs(probes) {
   const harnessRoot = probes.harnessRoot();
-  const runsDir = path42.join(harnessRoot, "runs");
-  const worktreesDir = path42.join(harnessRoot, "worktrees");
+  const runsDir = path48.join(harnessRoot, "runs");
+  const worktreesDir = path48.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -7883,6 +8831,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 path49 from "node:path";
+import { homedir as homedir9 } from "node:os";
+var CONFIG_FILE2 = path49.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";
@@ -7930,6 +9003,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")
   );
@@ -7941,7 +9016,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 {
@@ -7968,6 +9043,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);
   }