@kynver-app/runtime 0.1.74 → 0.1.76

package/dist/cli.js

@@ -645,9 +645,6 @@ async function runLogin(args) {
   console.log(JSON.stringify({ ok: true, credentialsPath: displayUserPath(CREDENTIALS_FILE) }, null, 2));
 }
 
-// src/dispatch.ts
-import path18 from "node:path";
-
 // src/callback-headers.ts
 function buildHarnessCallbackHeaders(secret) {
   const trimmed = String(secret).trim();
@@ -670,12 +667,29 @@ function buildHarnessCallbackHeaders(secret) {
 }
 
 // src/callbacks.ts
+function callbackTimeoutMs() {
+  const parsed = Number(process.env.KYNVER_CALLBACK_TIMEOUT_MS);
+  if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  return 3e4;
+}
+async function withTimeout(fn) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), callbackTimeoutMs());
+  try {
+    return await fn(controller.signal);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
 async function postJson(url, secret, body) {
-  const res = await fetch(url, {
-    method: "POST",
-    headers: buildHarnessCallbackHeaders(secret),
-    body: JSON.stringify(body)
-  });
+  const res = await withTimeout(
+    (signal) => fetch(url, {
+      method: "POST",
+      headers: buildHarnessCallbackHeaders(secret),
+      body: JSON.stringify(body),
+      signal
+    })
+  );
   let response = null;
   try {
     response = await res.json();
@@ -693,10 +707,13 @@ async function postJsonWithCredentialRefresh(url, secret, body, opts) {
   return { ...retry, refreshedAuth: true };
 }
 async function getJson(url, secret) {
-  const res = await fetch(url, {
-    method: "GET",
-    headers: buildHarnessCallbackHeaders(secret)
-  });
+  const res = await withTimeout(
+    (signal) => fetch(url, {
+      method: "GET",
+      headers: buildHarnessCallbackHeaders(secret),
+      signal
+    })
+  );
   let response = null;
   try {
     response = await res.json();
@@ -729,23 +746,23 @@ function isWslHost() {
 function observeWslHostDisk(options = {}) {
   const wsl = options.forceWsl === void 0 ? isWslHost() : options.forceWsl;
   if (!wsl) return null;
-  const path50 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
+  const path59 = 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(path50);
+    stats = statfs(path59);
   } catch (error) {
     return {
       ok: false,
-      path: path50,
+      path: path59,
       freeBytes: 0,
       totalBytes: 0,
       usedPercent: 100,
       warnBelowBytes,
       criticalBelowBytes,
-      reason: `Windows host disk probe failed at ${path50}: ${error.message}`,
+      reason: `Windows host disk probe failed at ${path59}: ${error.message}`,
       probeError: error.message
     };
   }
@@ -759,11 +776,11 @@ function observeWslHostDisk(options = {}) {
   let reason = null;
   if (!ok) {
     const tag = criticalFree ? "critical" : "warning";
-    reason = `Windows host disk ${path50} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+    reason = `Windows host disk ${path59} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
   }
   return {
     ok,
-    path: path50,
+    path: path59,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -783,12 +800,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 path50 = input.diskPath?.trim() || "/";
+  const path59 = 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(path50);
+  const stats = statfsSync2(path59);
   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;
@@ -811,7 +828,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path50,
+    path: path59,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -851,7 +868,7 @@ function readMemAvailableBytes(meminfoText) {
 import path7 from "node:path";
 
 // src/run-store.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 import path6 from "node:path";
 
 // src/paths.ts
@@ -859,22 +876,36 @@ import { existsSync as existsSync5 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import path5 from "node:path";
 var LEGACY_ROOT = path5.join(homedir4(), ".openclaw", "harness");
+var HARNESS_LAYOUT_DIR_NAMES = /* @__PURE__ */ new Set(["runs", "worktrees"]);
+function normalizeHarnessRoot(root) {
+  let resolved = path5.resolve(resolveUserPath(root.trim()));
+  while (HARNESS_LAYOUT_DIR_NAMES.has(path5.basename(resolved))) {
+    resolved = path5.dirname(resolved);
+  }
+  return resolved;
+}
 function resolveHarnessRoot() {
   const env = process.env.KYNVER_HARNESS_ROOT || process.env.OPUS_HARNESS_ROOT;
-  if (env) return resolveUserPath(env);
+  if (env) return normalizeHarnessRoot(env);
   const configured = loadUserConfig().harnessRoot?.trim();
-  if (configured) return resolveUserPath(configured);
+  if (configured) return normalizeHarnessRoot(configured);
   const kynverRoot = path5.join(homedir4(), ".kynver", "harness");
   if (existsSync5(kynverRoot)) return kynverRoot;
   if (existsSync5(LEGACY_ROOT)) return LEGACY_ROOT;
   return kynverRoot;
 }
+function harnessRunsDir(harnessRoot) {
+  return path5.join(normalizeHarnessRoot(harnessRoot), "runs");
+}
+function harnessWorktreesDir(harnessRoot) {
+  return path5.join(normalizeHarnessRoot(harnessRoot), "worktrees");
+}
 function getHarnessPaths() {
   const harnessRoot = resolveHarnessRoot();
   return {
     harnessRoot,
-    runsDir: path5.join(harnessRoot, "runs"),
-    worktreesDir: path5.join(harnessRoot, "worktrees")
+    runsDir: harnessRunsDir(harnessRoot),
+    worktreesDir: harnessWorktreesDir(harnessRoot)
   };
 }
 function runDir(runsDir, id) {
@@ -894,15 +925,24 @@ function listRunRecords() {
   return listRunRecordsAt(runsDir);
 }
 function listRunRecordsForHarnessRoot(harnessRoot) {
-  return listRunRecordsAt(path6.join(harnessRoot, "runs"));
+  return listRunRecordsAt(harnessRunsDir(harnessRoot));
+}
+function isRunDirectoryEntry(runDirPath) {
+  try {
+    return statSync2(runDirPath).isDirectory();
+  } catch {
+    return false;
+  }
 }
 function listRunRecordsAt(runsDir) {
   if (!existsSync6(runsDir)) return [];
   const runs = [];
   for (const entry of readdirSync2(runsDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
+    if (entry.name === "runs") continue;
+    const runDir2 = path6.join(runsDir, entry.name);
+    if (!isRunDirectoryEntry(runDir2)) continue;
     const run = readJson(
-      path6.join(runsDir, entry.name, "run.json"),
+      path6.join(runDir2, "run.json"),
       void 0
     );
     if (run?.id) runs.push(run);
@@ -924,11 +964,11 @@ function saveWorker(runId, worker) {
   writeJson(path6.join(runDir(runsDir, runId), "workers", worker.name, "worker.json"), worker);
 }
 function runDirectory(id) {
-  const { runsDir } = getPaths();
-  return runDirectoryAt(runsDir, id);
+  const { harnessRoot } = getPaths();
+  return runDirectoryAt(harnessRoot, id);
 }
 function runDirectoryAt(harnessRoot, id) {
-  return runDir(path6.join(harnessRoot, "runs"), safeSlug(id));
+  return runDir(harnessRunsDir(harnessRoot), safeSlug(id));
 }
 
 // src/heartbeat.ts
@@ -1490,13 +1530,29 @@ function parseReconciliation(finalResult) {
   }
   return out;
 }
+function stringList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
+}
 function workerPrUrls(snapshot, finalResult) {
   const urls = [];
   const fromSnapshot = normalizePrUrl(trimOrNull3(snapshot.prUrl) ?? "");
   if (fromSnapshot) urls.push(fromSnapshot);
   if (finalResult && typeof finalResult === "object" && !Array.isArray(finalResult)) {
-    const pr = normalizePrUrl(String(finalResult.prUrl ?? ""));
+    const record = finalResult;
+    const pr = normalizePrUrl(String(record.prUrl ?? ""));
     if (pr) urls.push(pr);
+    const lane = record.laneExpertise ?? record.lane_expertise;
+    if (lane && typeof lane === "object" && !Array.isArray(lane)) {
+      for (const u of stringList(lane.prUrls)) {
+        const n = normalizePrUrl(u);
+        if (n) urls.push(n);
+      }
+    }
+    for (const u of stringList(record.prUrls ?? record.pr_urls)) {
+      const n = normalizePrUrl(u);
+      if (n) urls.push(n);
+    }
   }
   return [...new Set(urls)];
 }
@@ -1506,7 +1562,21 @@ function assessWorkerLandingContract(input) {
   if (!contract.landingOnly && contract.targetPrUrls.length === 0 && !contract.repairEnforceOriginalPr) {
     return { blocked: false };
   }
-  if (!hasFinalResult3(finalResult)) return { blocked: false };
+  if (!hasFinalResult3(finalResult)) {
+    const requiresEarly = contract.requiresTargetPrReconciliation ?? (contract.landingOnly || Boolean(contract.repairEnforceOriginalPr) || contract.targetPrUrls.length > 0);
+    if (requiresEarly && contract.targetPrUrls.length > 0) {
+      return {
+        blocked: true,
+        reason: "missing_target_pr_reconciliation",
+        detail: `Final result required to reconcile target PR(s): ${contract.targetPrUrls.join(", ")}`
+      };
+    }
+    return { blocked: false };
+  }
+  const requiresTargetPrReconciliation = contract.requiresTargetPrReconciliation ?? (contract.landingOnly || Boolean(contract.repairEnforceOriginalPr) || contract.targetPrUrls.length > 0);
+  if (!requiresTargetPrReconciliation && !contract.repairEnforceOriginalPr) {
+    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);
@@ -1538,6 +1608,14 @@ function assessWorkerLandingContract(input) {
     contract.targetPrUrls.map((u) => normalizePrUrl(u) ?? u).filter(Boolean)
   );
   const workerPrs = workerPrUrls(snapshot, finalResult);
+  const unrelatedReconciled = reconciliation.map((entry) => entry.prUrl).filter((pr) => pr && !targetSet.has(pr));
+  if (unrelatedReconciled.length > 0 && (contract.landingOnly || contract.repairEnforceOriginalPr)) {
+    return {
+      blocked: true,
+      reason: "unrelated_implementation_pr",
+      detail: `Reconciliation must only cite contract target PR(s); unrelated: ${unrelatedReconciled.join(", ")}`
+    };
+  }
   if (contract.landingOnly) {
     for (const pr of workerPrs) {
       if (targetSet.size > 0 && !targetSet.has(pr)) {
@@ -1791,6 +1869,9 @@ function readAvailableMemBytes() {
   return readMemAvailableBytes();
 }
 function isActiveHarnessWorker(worker) {
+  if (typeof worker.completionBlocker === "string" && worker.completionBlocker.trim()) {
+    return false;
+  }
   const status = computeWorkerStatus(worker);
   return status.alive && !status.finalResult && status.attention.state !== "done";
 }
@@ -1925,127 +2006,6 @@ function enrichTaskForModelRouting(task) {
   return { ...task, roleLane };
 }
 
-// src/providers/claude.ts
-import { closeSync, openSync } from "node:fs";
-import { spawn } from "node:child_process";
-
-// src/providers/model-preflight.ts
-var REASONING_SUFFIX_RE = /-(?:thinking(?:-(?:high|medium|low|minimal|max|none))?|high|medium|low|minimal)$/i;
-function stripReasoningSuffix(model) {
-  return model.replace(REASONING_SUFFIX_RE, "");
-}
-var FOREIGN_MODEL_RE = /^(?:gpt-|gpt5|o1|o3|o4|gemini-|grok-|composer|deepseek|llama|mistral|qwen|command-)/i;
-function looksLikeClaudeModel(model) {
-  return /^claude[-_]/i.test(model) || /^(?:opus|sonnet|haiku)\b/i.test(model);
-}
-var CURSOR_MODEL_ALIASES = /* @__PURE__ */ new Set(["cursor"]);
-function normalizeCursorModelAlias(model) {
-  const key = model.trim().toLowerCase();
-  if (CURSOR_MODEL_ALIASES.has(key)) return "auto";
-  return null;
-}
-function preflightClaudeModel(model, defaultModel) {
-  const requested = (model ?? "").trim();
-  if (!requested) {
-    return { ok: true, model: defaultModel, normalized: false };
-  }
-  const stripped = stripReasoningSuffix(requested).trim();
-  const launch = stripped || defaultModel;
-  if (FOREIGN_MODEL_RE.test(launch) || !looksLikeClaudeModel(launch) && launch !== defaultModel) {
-    return {
-      ok: false,
-      model: requested,
-      normalized: false,
-      requested,
-      note: `model "${requested}" is not a Claude model \u2014 the "claude" provider drives the Claude CLI, which only accepts claude-* model ids (got "${launch}"). Pick a Claude model or switch the worker provider.`
-    };
-  }
-  if (launch !== requested) {
-    return {
-      ok: true,
-      model: launch,
-      normalized: true,
-      requested,
-      note: `normalized model "${requested}" \u2192 "${launch}" (the Claude CLI rejects reasoning-effort suffixes)`
-    };
-  }
-  return { ok: true, model: launch, normalized: false };
-}
-function preflightCursorModel(model, defaultModel) {
-  const requested = (model ?? "").trim();
-  if (!requested) {
-    return { ok: true, model: defaultModel, normalized: false };
-  }
-  const aliasLaunch = normalizeCursorModelAlias(requested);
-  if (aliasLaunch) {
-    return {
-      ok: true,
-      model: aliasLaunch,
-      normalized: true,
-      requested,
-      note: `normalized model "${requested}" \u2192 "${aliasLaunch}" (Cursor provider alias \u2014 use "auto" or a composer id, not "cursor")`
-    };
-  }
-  if (looksLikeClaudeModel(requested)) {
-    return {
-      ok: false,
-      model: requested,
-      normalized: false,
-      requested,
-      note: `model "${requested}" is a Claude model but the worker provider is "cursor". Switch the provider to "claude" or pick a Cursor model.`
-    };
-  }
-  return { ok: true, model: requested, normalized: false };
-}
-
-// src/providers/claude.ts
-var CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6";
-var claudeProvider = {
-  name: "claude",
-  defaultModel: CLAUDE_DEFAULT_MODEL,
-  preflightModel(model) {
-    return preflightClaudeModel(model, CLAUDE_DEFAULT_MODEL);
-  },
-  start(opts) {
-    const preflight = preflightClaudeModel(opts.model, CLAUDE_DEFAULT_MODEL);
-    if (!preflight.ok) {
-      throw new Error(`claude provider model preflight failed: ${preflight.note}`);
-    }
-    const model = preflight.model;
-    const stdoutFd = openSync(opts.stdoutPath, "a");
-    const stderrFd = openSync(opts.stderrPath, "a");
-    const stdio = ["ignore", stdoutFd, stderrFd];
-    const child = spawn(
-      "claude",
-      [
-        "--model",
-        model,
-        "-p",
-        "--verbose",
-        "--permission-mode",
-        "bypassPermissions",
-        "--output-format",
-        "stream-json",
-        "--include-partial-messages",
-        opts.prompt
-      ],
-      hiddenSpawnOptions({
-        cwd: opts.worktreePath,
-        detached: true,
-        stdio,
-        env: scrubWorkerEnv(process.env)
-      })
-    );
-    closeSync(stdoutFd);
-    closeSync(stderrFd);
-    if (!child.pid) {
-      throw new Error("failed to spawn claude worker process (is the `claude` CLI on PATH?)");
-    }
-    child.unref();
-    return { pid: child.pid, model };
-  }
-};
-
 // src/worker-provider-policy.ts
 var DEFAULT_WORKER_PROVIDER = "cursor";
 var CLAUDE_FAMILY = /* @__PURE__ */ new Set(["claude", "opus", "anthropic"]);
@@ -2109,75 +2069,959 @@ function resolveConfiguredWorkerProvider(configured, fallback = DEFAULT_WORKER_P
   const trimmed = configured?.trim();
   if (!trimmed) return fallback;
   if (isClaudeFamilyProvider(trimmed)) return DEFAULT_WORKER_PROVIDER;
+  if (trimmed === "codex") return "codex";
   return trimmed;
 }
 
-// src/model-routing.ts
-var GLOBAL_DEFAULT_MODEL = "claude-sonnet-4-6";
-var CURSOR_DEFAULT_MODEL = "composer-2.5";
-function taskString3(task, key) {
-  const v = task[key];
-  return typeof v === "string" ? v.trim() : "";
-}
-function normalizeRef(ref) {
-  return ref.toLowerCase();
+// src/orchestration-providers/capabilities.ts
+var CAPABILITIES = {
+  codex: {
+    id: "codex",
+    displayName: "Codex (BYO OAuth / Hermes openai-codex)",
+    costTier: "low",
+    authSources: ["oauth_local", "api_key_env", "subscription_hermes"],
+    supportsLowRiskOrchestration: true,
+    supportsPrivilegedPlatformActions: false
+  },
+  cursor: {
+    id: "cursor",
+    displayName: "Cursor / Composer",
+    costTier: "medium",
+    authSources: ["oauth_local", "api_key_env"],
+    supportsLowRiskOrchestration: true,
+    supportsPrivilegedPlatformActions: true
+  },
+  claude: {
+    id: "claude",
+    displayName: "Claude Code",
+    costTier: "high",
+    authSources: ["oauth_local"],
+    supportsLowRiskOrchestration: true,
+    supportsPrivilegedPlatformActions: true
+  }
+};
+function getOrchestrationProviderCapability(id) {
+  return CAPABILITIES[id];
 }
-function resolveGlobalDefaultModel(config = loadUserConfig()) {
-  const fromConfig = config.defaultModel?.trim();
-  if (fromConfig) return fromConfig;
-  const fromEnv = process.env.KYNVER_DEFAULT_MODEL?.trim();
-  if (fromEnv) return fromEnv;
-  return GLOBAL_DEFAULT_MODEL;
+function listOrchestrationProviderCapabilities() {
+  return Object.values(CAPABILITIES);
 }
-function inferProviderFromModel(model) {
-  const m = (model ?? "").toLowerCase();
-  if (!m) return "cursor";
-  if (m.includes("composer") || m.includes("cursor") || m.includes("codex") || m.startsWith("gpt-") || m.startsWith("gpt5")) {
-    return "cursor";
+
+// src/orchestration-providers/codex-oauth-binding.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import path8 from "node:path";
+
+// src/orchestration-providers/oauth-binding-utils.ts
+import { createHash } from "node:crypto";
+import { statSync as statSync3 } from "node:fs";
+import { spawnSync as spawnSync2 } from "node:child_process";
+function fingerprintAuthStore(filePath) {
+  try {
+    const st = statSync3(filePath);
+    const material = `${filePath}|${st.size}|${st.mtimeMs}`;
+    return createHash("sha256").update(material).digest("hex").slice(0, 16);
+  } catch {
+    return void 0;
   }
-  if (/^claude[-_]/i.test(m) || /^(?:opus|sonnet|haiku)\b/i.test(m)) {
-    return "claude";
+}
+function envKeyFingerprint(envKey) {
+  return createHash("sha256").update(`env:${envKey}`).digest("hex").slice(0, 16);
+}
+function resolveCliBin(defaultBin, envKeys) {
+  for (const key of envKeys) {
+    const value = process.env[key]?.trim();
+    if (value) return value;
   }
-  return "cursor";
+  return defaultBin;
 }
-function normalizeProviderAliasModel(model, explicitProvider) {
-  const alias = model.trim().toLowerCase();
-  const provider = explicitProvider?.trim();
-  if (alias === "cursor") {
+function probeCliCommand(bin, args, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  try {
+    const result = spawnSync2(bin, args, {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      env: { ...process.env, CI: "1", NO_COLOR: "1" }
+    });
+    if (result.status === 0) {
+      return { ok: true, note: options.okNote ?? `${bin} ${args.join(" ")}: ok` };
+    }
+    const stderr = (result.stderr || result.stdout || "").trim();
+    const prefix = options.failPrefix ?? `${bin} ${args.join(" ")} failed`;
     return {
-      model: CURSOR_DEFAULT_MODEL,
-      provider: "cursor",
-      rule: provider && provider !== "cursor" ? "explicit:model_provider_alias_overrode_provider" : "explicit:model_provider_alias",
-      requestedModel: model
+      ok: false,
+      note: stderr ? `${prefix}: ${stderr.slice(0, 200)}` : prefix
     };
-  }
-  if (alias === "claude" || alias === "anthropic") {
+  } catch (err) {
     return {
-      model: CLAUDE_DEFAULT_MODEL,
-      provider: "claude",
-      rule: provider && provider !== "claude" ? "explicit:model_provider_alias_overrode_provider" : "explicit:model_provider_alias",
-      requestedModel: model
+      ok: false,
+      note: err instanceof Error ? err.message : `${bin} probe failed`
     };
   }
-  return null;
 }
-function isOpusLane(ref, title) {
-  if (ref.includes("deep") && ref.includes("review")) return true;
-  if (ref.includes("security")) return true;
-  if (ref.includes("plan_author") || ref.includes("plan-author")) return true;
-  if (title.includes("deep review") || title.includes("security review")) return true;
-  if (ref.includes("plan") && !ref.includes("review") && (ref.includes("author") || ref.includes("strategy"))) {
-    return true;
+function probeCliExitCodeOnly(bin, args, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  try {
+    const result = spawnSync2(bin, args, {
+      stdio: "ignore",
+      timeout: timeoutMs,
+      env: { ...process.env, CI: "1", NO_COLOR: "1" }
+    });
+    if (result.status === 0) {
+      return { ok: true, note: options.okNote ?? `${bin} authenticated` };
+    }
+    return { ok: false, note: options.failNote ?? `${bin} not authenticated` };
+  } catch (err) {
+    return {
+      ok: false,
+      note: err instanceof Error ? err.message : `${bin} auth probe failed`
+    };
   }
-  return false;
 }
-function inferModelRoutingFromTask(task) {
-  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" };
+
+// src/orchestration-providers/codex-oauth-binding.ts
+var DEFAULT_CODEX_BIN = "codex";
+function authStoreCandidates() {
+  const home = homedir5();
+  return [
+    path8.join(home, ".codex", "auth.json"),
+    path8.join(home, ".config", "codex", "auth.json")
+  ];
+}
+function probeCodexOAuthBinding(nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  const bin = resolveCliBin(DEFAULT_CODEX_BIN, ["KYNVER_CODEX_BIN", "CODEX_BIN"]);
+  if (process.env.CODEX_API_KEY?.trim()) {
+    return {
+      providerId: "codex",
+      ready: true,
+      authSource: "api_key_env",
+      sessionFingerprint: envKeyFingerprint("CODEX_API_KEY"),
+      checkedAt: nowIso,
+      note: "CODEX_API_KEY present (env binding \u2014 cloud credits path, no token stored in Kynver)"
+    };
+  }
+  const authPath = authStoreCandidates().find((p) => existsSync9(p));
+  const login = probeCliCommand(bin, ["login", "status"], {
+    okNote: "codex login status: authenticated",
+    failPrefix: "codex login status"
+  });
+  const ready = Boolean(authPath) && login.ok;
+  return {
+    providerId: "codex",
+    ready,
+    authSource: "oauth_local",
+    sessionFingerprint: authPath ? fingerprintAuthStore(authPath) : void 0,
+    checkedAt: nowIso,
+    note: ready ? "Local Codex OAuth session bound on runner" : [login.note, authPath ? void 0 : "no ~/.codex/auth.json"].filter(Boolean).join("; ")
+  };
+}
+
+// src/orchestration-providers/hermes-openai-codex-binding.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import path9 from "node:path";
+function hermesAuthStorePath() {
+  const configured = process.env.HERMES_HOME?.trim();
+  const home = configured ? path9.resolve(configured) : path9.join(homedir6(), ".hermes");
+  return path9.join(home, "auth.json");
+}
+function probeHermesOpenAiCodexBinding(nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  const bin = resolveCliBin("hermes", ["KYNVER_HERMES_BIN", "HERMES_BIN"]);
+  const cli = probeCliCommand(bin, ["--version"], {
+    okNote: `${bin} CLI available`,
+    failPrefix: `${bin} CLI not available`
+  });
+  const authPath = hermesAuthStorePath();
+  const authStorePresent = existsSync10(authPath);
+  const auth = probeCliExitCodeOnly(bin, ["auth", "status", "openai-codex"], {
+    okNote: "hermes openai-codex: logged in",
+    failNote: "hermes openai-codex: not logged in"
+  });
+  const ready = cli.ok && auth.ok;
+  const authSource = ready ? "subscription_hermes" : "none";
+  return {
+    path: "hermes_openai_codex",
+    ready,
+    authSource,
+    sessionFingerprint: authStorePresent ? fingerprintAuthStore(authPath) : void 0,
+    checkedAt: nowIso,
+    note: ready ? "Hermes openai-codex subscription session bound (ChatGPT Codex OAuth)" : [cli.note, auth.note, authStorePresent ? void 0 : "no ~/.hermes/auth.json"].filter(Boolean).join("; ")
+  };
+}
+
+// src/orchestration-providers/codex-orchestration-adapter.ts
+function resolveCodexOrchestrationAdapter(nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  const cliBinding = probeCodexOAuthBinding(nowIso);
+  if (cliBinding.ready) {
+    return { ...cliBinding, path: "codex_cli" };
+  }
+  const hermes = probeHermesOpenAiCodexBinding(nowIso);
+  if (hermes.ready) {
+    return {
+      providerId: "codex",
+      ready: true,
+      authSource: hermes.authSource,
+      sessionFingerprint: hermes.sessionFingerprint,
+      checkedAt: hermes.checkedAt,
+      note: hermes.note,
+      path: "hermes_openai_codex",
+      hermesOpenAiCodex: hermes
+    };
+  }
+  return {
+    providerId: "codex",
+    ready: false,
+    authSource: "none",
+    checkedAt: nowIso,
+    path: "none",
+    hermesOpenAiCodex: hermes,
+    note: [cliBinding.note, hermes.note].filter(Boolean).join("; ") || "Codex CLI and Hermes openai-codex unavailable"
+  };
+}
+
+// src/orchestration-providers/cost-router.ts
+var COST_TIER_ORDER = ["low", "medium", "high"];
+var AUTH_SOURCE_RANK = {
+  oauth_local: 0,
+  subscription_hermes: 0,
+  runner_token: 1,
+  api_key_env: 2,
+  none: 3
+};
+function providerCapableForRisk(providerId, riskClass) {
+  const cap = getOrchestrationProviderCapability(providerId);
+  if (riskClass === "privileged") return cap.supportsPrivilegedPlatformActions;
+  if (riskClass === "low") return cap.supportsLowRiskOrchestration;
+  return true;
+}
+function compareProviderCandidates(a, b) {
+  const capA = getOrchestrationProviderCapability(a.providerId);
+  const capB = getOrchestrationProviderCapability(b.providerId);
+  const tierDiff = COST_TIER_ORDER.indexOf(capA.costTier) - COST_TIER_ORDER.indexOf(capB.costTier);
+  if (tierDiff !== 0) return tierDiff;
+  const authDiff = AUTH_SOURCE_RANK[a.binding.authSource] - AUTH_SOURCE_RANK[b.binding.authSource];
+  if (authDiff !== 0) return authDiff;
+  return a.providerId.localeCompare(b.providerId);
+}
+function selectCheapestCapableProvider(input) {
+  const candidates = listOrchestrationProviderCapabilities().map((cap) => ({
+    providerId: cap.id,
+    binding: input.inventory.bindings[cap.id]
+  })).filter(
+    (c) => c.binding.ready && providerCapableForRisk(c.providerId, input.riskClass)
+  );
+  if (candidates.length === 0) return null;
+  const sorted = [...candidates].sort(compareProviderCandidates);
+  const chosen = sorted[0];
+  const lowTierProviderId = "codex";
+  if (chosen.providerId === lowTierProviderId) {
+    return { providerId: chosen.providerId, binding: chosen.binding };
+  }
+  const lowBinding = input.inventory.bindings[lowTierProviderId];
+  let escalatedReason;
+  if (!providerCapableForRisk(lowTierProviderId, input.riskClass)) {
+    escalatedReason = `${input.riskClass} orchestration requires privileged-capable provider`;
+  } else if (!lowBinding.ready) {
+    escalatedReason = lowBinding.note ?? `${lowTierProviderId} not bound`;
+  }
+  return {
+    providerId: chosen.providerId,
+    binding: chosen.binding,
+    escalatedFrom: lowTierProviderId,
+    escalatedReason
+  };
+}
+
+// src/orchestration-providers/claude-oauth-binding.ts
+import { existsSync as existsSync11 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import path10 from "node:path";
+var DEFAULT_CLAUDE_BIN = "claude";
+function claudeAuthStoreCandidates() {
+  const home = homedir7();
+  return [path10.join(home, ".claude", ".credentials.json")];
+}
+function probeClaudeOAuthBinding(nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  const bin = resolveCliBin(DEFAULT_CLAUDE_BIN, ["KYNVER_CLAUDE_BIN", "CLAUDE_BIN"]);
+  if (process.env.ANTHROPIC_API_KEY?.trim()) {
+    return {
+      providerId: "claude",
+      ready: true,
+      authSource: "api_key_env",
+      sessionFingerprint: envKeyFingerprint("ANTHROPIC_API_KEY"),
+      checkedAt: nowIso,
+      note: "ANTHROPIC_API_KEY present (env binding \u2014 cloud credits path, no token stored in Kynver)"
+    };
+  }
+  const cli = probeCliCommand(bin, ["--version"], {
+    okNote: `${bin} CLI available`,
+    failPrefix: `${bin} CLI not available`
+  });
+  const authPath = claudeAuthStoreCandidates().find((p) => existsSync11(p));
+  const login = probeCliExitCodeOnly(bin, ["auth", "status"], {
+    okNote: "claude auth status: authenticated",
+    failNote: "claude auth status: not authenticated"
+  });
+  const ready = cli.ok && (login.ok || Boolean(authPath));
+  return {
+    providerId: "claude",
+    ready,
+    authSource: "oauth_local",
+    sessionFingerprint: authPath ? fingerprintAuthStore(authPath) : void 0,
+    checkedAt: nowIso,
+    note: ready ? "Local Claude Code OAuth session bound on runner" : [cli.note, login.note, authPath ? void 0 : "no ~/.claude/.credentials.json"].filter(Boolean).join("; ")
+  };
+}
+
+// src/orchestration-providers/cursor-oauth-binding.ts
+import { existsSync as existsSync12 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import path11 from "node:path";
+var DEFAULT_AGENT_BIN = "agent";
+function cursorAuthStoreCandidates() {
+  const home = homedir8();
+  return [path11.join(home, ".config", "cursor", "auth.json")];
+}
+function probeCursorOAuthBinding(nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  const bin = resolveCliBin(DEFAULT_AGENT_BIN, [
+    "KYNVER_CURSOR_AGENT_BIN",
+    "CURSOR_AGENT_BIN"
+  ]);
+  if (process.env.CURSOR_API_KEY?.trim()) {
+    return {
+      providerId: "cursor",
+      ready: true,
+      authSource: "api_key_env",
+      sessionFingerprint: envKeyFingerprint("CURSOR_API_KEY"),
+      checkedAt: nowIso,
+      note: "CURSOR_API_KEY present (env binding \u2014 cloud credits path, no token stored in Kynver)"
+    };
+  }
+  const cli = probeCliCommand(bin, ["-v"], {
+    okNote: `${bin} CLI available`,
+    failPrefix: `${bin} CLI not available`
+  });
+  const authPath = cursorAuthStoreCandidates().find((p) => existsSync12(p));
+  const ready = Boolean(authPath) && cli.ok;
+  return {
+    providerId: "cursor",
+    ready,
+    authSource: "oauth_local",
+    sessionFingerprint: authPath ? fingerprintAuthStore(authPath) : void 0,
+    checkedAt: nowIso,
+    note: ready ? "Local Cursor/Composer OAuth session bound on runner" : [cli.note, authPath ? void 0 : "no ~/.config/cursor/auth.json"].filter(Boolean).join("; ")
+  };
+}
+
+// src/orchestration-providers/hermes-cli-adapter.ts
+import { existsSync as existsSync13, readFileSync as readFileSync8 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import path12 from "node:path";
+var PROFILE_ENV_KEYS = [
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "KYNVER_API_KEY",
+  "KYNVER_BASE_URL"
+];
+function hermesProfileEnvPath() {
+  const configured = process.env.HERMES_HOME?.trim();
+  const home = configured ? path12.resolve(configured) : path12.join(homedir9(), ".hermes");
+  return path12.join(home, ".env");
+}
+function profileEnvKeyPresence(envPath) {
+  try {
+    const text = readFileSync8(envPath, "utf8");
+    const present = [];
+    for (const key of PROFILE_ENV_KEYS) {
+      const re = new RegExp(`^${key}=`, "m");
+      if (re.test(text)) present.push(key);
+    }
+    return present;
+  } catch {
+    return [];
+  }
+}
+function probeHermesCliAdapter(nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  const bin = resolveCliBin("hermes", ["KYNVER_HERMES_BIN", "HERMES_BIN"]);
+  const cli = probeCliCommand(bin, ["--version"], {
+    okNote: `${bin} CLI available`,
+    failPrefix: `${bin} CLI not available`
+  });
+  const profilePath = hermesProfileEnvPath();
+  const profileBound = existsSync13(profilePath);
+  const envKeys = profileBound ? profileEnvKeyPresence(profilePath) : [];
+  const hasApiKeys = envKeys.some((k) => k.endsWith("_API_KEY"));
+  const authSource = hasApiKeys ? "api_key_env" : profileBound ? "oauth_local" : "none";
+  const ready = cli.ok && profileBound;
+  return {
+    adapterId: "hermes",
+    cliAvailable: cli.ok,
+    profileBound,
+    authSource,
+    sessionFingerprint: profileBound ? fingerprintAuthStore(profilePath) : void 0,
+    checkedAt: nowIso,
+    note: ready ? `Hermes profile bound (${envKeys.length ? `keys: ${envKeys.join(", ")}` : "no API keys detected"})` : [cli.note, profileBound ? void 0 : "no ~/.hermes/.env"].filter(Boolean).join("; ")
+  };
+}
+
+// src/orchestration-providers/inventory.ts
+function buildOrchestrationProviderInventory(options = {}) {
+  const generatedAt = options.nowIso?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+  const codexAdapter = resolveCodexOrchestrationAdapter(generatedAt);
+  const bindings = {
+    codex: codexAdapter,
+    cursor: probeCursorOAuthBinding(generatedAt),
+    claude: probeClaudeOAuthBinding(generatedAt)
+  };
+  const readyCount = Object.values(bindings).filter((b) => b.ready).length;
+  return {
+    generatedAt,
+    bindings,
+    cloudApiCredits: {
+      anthropicApiKey: Boolean(process.env.ANTHROPIC_API_KEY?.trim()),
+      openaiApiKey: Boolean(process.env.OPENAI_API_KEY?.trim()),
+      codexApiKey: Boolean(process.env.CODEX_API_KEY?.trim())
+    },
+    hermes: probeHermesCliAdapter(generatedAt),
+    hermesOpenAiCodex: probeHermesOpenAiCodexBinding(generatedAt),
+    codexAdapterPath: codexAdapter.path,
+    readyCount
+  };
+}
+
+// src/orchestration-providers/routing.ts
+var PRIVILEGED_MARKERS = [
+  /\bprivileged\b/i,
+  /\bproduction\s+db\b/i,
+  /\bdb:push\b/i,
+  /\bmigration\b/i,
+  /\bdeploy\b/i,
+  /\bsecrets?\b/i,
+  /\bstripe\b/i,
+  /\[require-approval\]/i,
+  /\[operator-only\]/i
+];
+var LOW_RISK_MARKERS = [
+  /\borchestration\b/i,
+  /\bplan[- ]?progress\b/i,
+  /\bstatus\s+sync\b/i,
+  /\bheartbeat\b/i,
+  /\bboard[- ]?drain\b/i,
+  /\bmaintenance\b/i,
+  /\[orchestration:\s*low-risk\]/i
+];
+function taskString3(task, key) {
+  const v = task[key];
+  return typeof v === "string" ? v.trim() : "";
+}
+function classifyOrchestrationRisk(task) {
+  const ref = taskString3(task, "executorRef").toLowerCase();
+  const title = taskString3(task, "title").toLowerCase();
+  const description = taskString3(task, "description").toLowerCase();
+  const blob = `${ref}
+${title}
+${description}`;
+  if (PRIVILEGED_MARKERS.some((re) => re.test(blob))) return "privileged";
+  if (ref.includes("provider:claude") || ref.includes("deep_review") || ref.includes("security")) {
+    return "elevated";
+  }
+  if (ref.includes("landing") || ref.includes("review") || title.startsWith("land:") || ref.includes("implementer") || ref.includes("repair") || title.includes("implement")) {
+    return "elevated";
+  }
+  if (LOW_RISK_MARKERS.some((re) => re.test(blob))) {
+    return "low";
+  }
+  return "elevated";
+}
+function buildAudit(input) {
+  const cap = getOrchestrationProviderCapability(input.provider);
+  const costRationale = input.escalatedFrom && input.escalatedReason ? `Escalated from ${input.escalatedFrom} (${input.escalatedReason}); using ${cap.displayName} (${cap.costTier} tier)` : `${cap.displayName} selected for ${input.riskClass} orchestration (${cap.costTier} tier, auth=${input.authSource})`;
+  return {
+    provider: input.provider,
+    model: input.model,
+    authSource: input.authSource,
+    costTier: cap.costTier,
+    riskClass: input.riskClass,
+    costRationale,
+    routingRule: input.routingRule,
+    escalatedFrom: input.escalatedFrom,
+    escalatedReason: input.escalatedReason
+  };
+}
+function resolveInventory(input) {
+  const inventory = input.inventory ?? buildOrchestrationProviderInventory();
+  if (!input.codexBinding) return inventory;
+  return {
+    ...inventory,
+    bindings: { ...inventory.bindings, codex: input.codexBinding }
+  };
+}
+function decisionForProvider(input) {
+  const audit = buildAudit({
+    provider: input.providerId,
+    model: input.model,
+    authSource: input.binding.authSource,
+    riskClass: input.riskClass,
+    routingRule: input.routingRule,
+    escalatedFrom: input.escalatedFrom,
+    escalatedReason: input.escalatedReason
+  });
+  return {
+    provider: input.providerId,
+    model: input.model,
+    rule: audit.routingRule,
+    audit
+  };
+}
+function resolveOrchestrationRouting(input) {
+  const task = input.task ?? {};
+  const risk = classifyOrchestrationRisk(task);
+  const inventory = resolveInventory({
+    inventory: input.inventory,
+    codexBinding: input.codexBinding ?? resolveCodexOrchestrationAdapter()
+  });
+  const explicit = input.preferLowCost === false ? null : input.explicitProvider?.trim().toLowerCase();
+  const explicitModel = input.explicitModel?.trim() || void 0;
+  const fallbackProvider = DEFAULT_WORKER_PROVIDER;
+  if (explicit === "codex" || explicit === "provider:codex") {
+    const binding = inventory.bindings.codex;
+    if (!binding.ready) {
+      const selection2 = selectCheapestCapableProvider({ inventory, riskClass: risk });
+      if (selection2) {
+        return decisionForProvider({
+          providerId: selection2.providerId,
+          binding: selection2.binding,
+          riskClass: risk,
+          routingRule: "orchestration:explicit_codex_unavailable_cost_aware",
+          model: explicitModel,
+          escalatedFrom: "codex",
+          escalatedReason: binding.note ?? "codex oauth not bound"
+        });
+      }
+      return decisionForProvider({
+        providerId: fallbackProvider,
+        binding: inventory.bindings[fallbackProvider],
+        riskClass: risk,
+        routingRule: "orchestration:codex_unavailable_escalate_cursor",
+        model: explicitModel,
+        escalatedFrom: "codex",
+        escalatedReason: binding.note ?? "codex oauth not bound"
+      });
+    }
+    return decisionForProvider({
+      providerId: "codex",
+      binding,
+      riskClass: risk,
+      routingRule: "orchestration:explicit_codex",
+      model: explicitModel
+    });
+  }
+  if (explicit === "cursor" || explicit === "provider:cursor") {
+    const binding = inventory.bindings.cursor;
+    if (binding.ready) {
+      return decisionForProvider({
+        providerId: "cursor",
+        binding,
+        riskClass: risk,
+        routingRule: "orchestration:explicit_cursor",
+        model: explicitModel
+      });
+    }
+  }
+  if (explicit === "claude" || explicit === "provider:claude") {
+    const binding = inventory.bindings.claude;
+    if (binding.ready) {
+      return decisionForProvider({
+        providerId: "claude",
+        binding,
+        riskClass: risk,
+        routingRule: "orchestration:explicit_claude",
+        model: explicitModel
+      });
+    }
+  }
+  const selection = selectCheapestCapableProvider({ inventory, riskClass: risk });
+  if (selection) {
+    return decisionForProvider({
+      providerId: selection.providerId,
+      binding: selection.binding,
+      riskClass: risk,
+      routingRule: `orchestration:cost_aware_${selection.providerId}`,
+      model: explicitModel,
+      escalatedFrom: selection.escalatedFrom,
+      escalatedReason: selection.escalatedReason
+    });
+  }
+  const codexBinding = inventory.bindings.codex;
+  return decisionForProvider({
+    providerId: fallbackProvider,
+    binding: inventory.bindings[fallbackProvider],
+    riskClass: risk,
+    routingRule: codexBinding.ready ? "orchestration:inventory_empty_default_cursor" : "orchestration:codex_unavailable_default_cursor",
+    model: explicitModel,
+    ...codexBinding.ready ? {} : { escalatedFrom: "codex", escalatedReason: codexBinding.note ?? "codex oauth not bound" }
+  });
+}
+
+// src/providers/claude.ts
+import { closeSync, openSync } from "node:fs";
+import { spawn } from "node:child_process";
+
+// src/providers/model-preflight.ts
+var REASONING_SUFFIX_RE = /-(?:thinking(?:-(?:high|medium|low|minimal|max|none))?|high|medium|low|minimal)$/i;
+function stripReasoningSuffix(model) {
+  return model.replace(REASONING_SUFFIX_RE, "");
+}
+var FOREIGN_MODEL_RE = /^(?:gpt-|gpt5|o1|o3|o4|gemini-|grok-|composer|deepseek|llama|mistral|qwen|command-)/i;
+function looksLikeClaudeModel(model) {
+  return /^claude[-_]/i.test(model) || /^(?:opus|sonnet|haiku)\b/i.test(model);
+}
+var CURSOR_MODEL_ALIASES = /* @__PURE__ */ new Set(["cursor"]);
+function normalizeCursorModelAlias(model) {
+  const key = model.trim().toLowerCase();
+  if (CURSOR_MODEL_ALIASES.has(key)) return "auto";
+  return null;
+}
+function preflightClaudeModel(model, defaultModel) {
+  const requested = (model ?? "").trim();
+  if (!requested) {
+    return { ok: true, model: defaultModel, normalized: false };
+  }
+  const stripped = stripReasoningSuffix(requested).trim();
+  const launch = stripped || defaultModel;
+  if (FOREIGN_MODEL_RE.test(launch) || !looksLikeClaudeModel(launch) && launch !== defaultModel) {
+    return {
+      ok: false,
+      model: requested,
+      normalized: false,
+      requested,
+      note: `model "${requested}" is not a Claude model \u2014 the "claude" provider drives the Claude CLI, which only accepts claude-* model ids (got "${launch}"). Pick a Claude model or switch the worker provider.`
+    };
+  }
+  if (launch !== requested) {
+    return {
+      ok: true,
+      model: launch,
+      normalized: true,
+      requested,
+      note: `normalized model "${requested}" \u2192 "${launch}" (the Claude CLI rejects reasoning-effort suffixes)`
+    };
+  }
+  return { ok: true, model: launch, normalized: false };
+}
+function preflightCodexModel(model, defaultModel) {
+  const requested = (model ?? "").trim();
+  if (!requested) {
+    return { ok: true, model: defaultModel, normalized: false };
+  }
+  if (looksLikeClaudeModel(requested)) {
+    return {
+      ok: false,
+      model: requested,
+      normalized: false,
+      requested,
+      note: `model "${requested}" is a Claude model but the worker provider is "codex". Switch the provider or pick a Codex/OpenAI model.`
+    };
+  }
+  return { ok: true, model: requested, normalized: false };
+}
+function preflightCursorModel(model, defaultModel) {
+  const requested = (model ?? "").trim();
+  if (!requested) {
+    return { ok: true, model: defaultModel, normalized: false };
+  }
+  const aliasLaunch = normalizeCursorModelAlias(requested);
+  if (aliasLaunch) {
+    return {
+      ok: true,
+      model: aliasLaunch,
+      normalized: true,
+      requested,
+      note: `normalized model "${requested}" \u2192 "${aliasLaunch}" (Cursor provider alias \u2014 use "auto" or a composer id, not "cursor")`
+    };
+  }
+  if (looksLikeClaudeModel(requested)) {
+    return {
+      ok: false,
+      model: requested,
+      normalized: false,
+      requested,
+      note: `model "${requested}" is a Claude model but the worker provider is "cursor". Switch the provider to "claude" or pick a Cursor model.`
+    };
+  }
+  return { ok: true, model: requested, normalized: false };
+}
+
+// src/providers/claude.ts
+var CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6";
+var claudeProvider = {
+  name: "claude",
+  defaultModel: CLAUDE_DEFAULT_MODEL,
+  preflightModel(model) {
+    return preflightClaudeModel(model, CLAUDE_DEFAULT_MODEL);
+  },
+  start(opts) {
+    const preflight = preflightClaudeModel(opts.model, CLAUDE_DEFAULT_MODEL);
+    if (!preflight.ok) {
+      throw new Error(`claude provider model preflight failed: ${preflight.note}`);
+    }
+    const model = preflight.model;
+    const stdoutFd = openSync(opts.stdoutPath, "a");
+    const stderrFd = openSync(opts.stderrPath, "a");
+    const stdio = ["ignore", stdoutFd, stderrFd];
+    const child = spawn(
+      "claude",
+      [
+        "--model",
+        model,
+        "-p",
+        "--verbose",
+        "--permission-mode",
+        "bypassPermissions",
+        "--output-format",
+        "stream-json",
+        "--include-partial-messages",
+        opts.prompt
+      ],
+      hiddenSpawnOptions({
+        cwd: opts.worktreePath,
+        detached: true,
+        stdio,
+        env: scrubWorkerEnv(process.env)
+      })
+    );
+    closeSync(stdoutFd);
+    closeSync(stderrFd);
+    if (!child.pid) {
+      throw new Error("failed to spawn claude worker process (is the `claude` CLI on PATH?)");
+    }
+    child.unref();
+    return { pid: child.pid, model };
+  }
+};
+
+// src/providers/codex.ts
+import { closeSync as closeSync3, existsSync as existsSync14, openSync as openSync3 } from "node:fs";
+import { spawn as spawn3 } from "node:child_process";
+
+// src/providers/hermes-codex.ts
+import { closeSync as closeSync2, openSync as openSync2 } from "node:fs";
+import { spawn as spawn2 } from "node:child_process";
+var HERMES_OPENAI_CODEX_DEFAULT_MODEL = "gpt-5.4";
+function hermesWorkerEnv() {
+  return scrubWorkerEnv({
+    ...process.env,
+    CI: "1",
+    NO_COLOR: "1",
+    HERMES_ACCEPT_HOOKS: process.env.HERMES_ACCEPT_HOOKS ?? "1"
+  });
+}
+function buildHermesOpenAiCodexChatArgv(model, prompt) {
+  const maxTurns = process.env.KYNVER_HERMES_CODEX_MAX_TURNS?.trim() || "40";
+  return [
+    "chat",
+    "-q",
+    prompt,
+    "--provider",
+    "openai-codex",
+    "-m",
+    model,
+    "-Q",
+    "--accept-hooks",
+    "--max-turns",
+    maxTurns,
+    "--toolsets",
+    "hermes-cli"
+  ];
+}
+var hermesCodexProvider = {
+  name: "hermes-codex",
+  defaultModel: HERMES_OPENAI_CODEX_DEFAULT_MODEL,
+  preflightModel(model) {
+    return preflightCodexModel(model, HERMES_OPENAI_CODEX_DEFAULT_MODEL);
+  },
+  start(opts) {
+    const preflight = preflightCodexModel(opts.model, HERMES_OPENAI_CODEX_DEFAULT_MODEL);
+    if (!preflight.ok) {
+      throw new Error(`hermes-codex provider model preflight failed: ${preflight.note}`);
+    }
+    const model = preflight.model;
+    const stdoutFd = openSync2(opts.stdoutPath, "a");
+    const stderrFd = openSync2(opts.stderrPath, "a");
+    const stdio = ["ignore", stdoutFd, stderrFd];
+    const bin = resolveCliBin("hermes", ["KYNVER_HERMES_BIN", "HERMES_BIN"]);
+    const args = buildHermesOpenAiCodexChatArgv(model, opts.prompt);
+    const child = spawn2(
+      bin,
+      args,
+      hiddenSpawnOptions({
+        cwd: opts.worktreePath,
+        detached: true,
+        shell: false,
+        stdio,
+        env: hermesWorkerEnv()
+      })
+    );
+    closeSync2(stdoutFd);
+    closeSync2(stderrFd);
+    if (!child.pid) {
+      throw new Error(
+        `failed to spawn Hermes openai-codex worker (is \`${bin}\` on PATH? run \`hermes auth status openai-codex\`)`
+      );
+    }
+    child.unref();
+    return { pid: child.pid, model };
+  }
+};
+
+// src/providers/codex.ts
+var CODEX_DEFAULT_MODEL = "gpt-5.4";
+function resolveCodexBin() {
+  return process.env.KYNVER_CODEX_BIN?.trim() || process.env.CODEX_BIN?.trim() || "codex";
+}
+function codexWorkerEnv() {
+  return scrubWorkerEnv({
+    ...process.env,
+    CI: "1",
+    NO_COLOR: "1"
+  });
+}
+function buildCodexExecArgv(model, prompt) {
+  return [
+    "exec",
+    "--sandbox",
+    "read-only",
+    "--ask-for-approval",
+    "never",
+    "--model",
+    model,
+    prompt
+  ];
+}
+function spawnCodexProcess(bin, args, opts) {
+  const useScript = process.platform !== "win32" && existsSync14("/usr/bin/script");
+  if (!useScript) {
+    return spawn3(bin, args, opts);
+  }
+  const quoted = [bin, ...args].map((a) => `'${a.replace(/'/g, `'\\''`)}'`).join(" ");
+  return spawn3("script", ["-qfc", quoted, "/dev/null"], opts);
+}
+var codexProvider = {
+  name: "codex",
+  defaultModel: CODEX_DEFAULT_MODEL,
+  preflightModel(model) {
+    return preflightCodexModel(model, CODEX_DEFAULT_MODEL);
+  },
+  start(opts) {
+    const adapter = resolveCodexOrchestrationAdapter();
+    if (adapter.path === "hermes_openai_codex") {
+      return hermesCodexProvider.start(opts);
+    }
+    const preflight = preflightCodexModel(opts.model, CODEX_DEFAULT_MODEL);
+    if (!preflight.ok) {
+      throw new Error(`codex provider model preflight failed: ${preflight.note}`);
+    }
+    const model = preflight.model;
+    const stdoutFd = openSync3(opts.stdoutPath, "a");
+    const stderrFd = openSync3(opts.stderrPath, "a");
+    const stdio = ["ignore", stdoutFd, stderrFd];
+    const bin = resolveCodexBin();
+    const args = buildCodexExecArgv(model, opts.prompt);
+    const child = spawnCodexProcess(
+      bin,
+      args,
+      hiddenSpawnOptions({
+        cwd: opts.worktreePath,
+        detached: true,
+        shell: false,
+        stdio,
+        env: codexWorkerEnv()
+      })
+    );
+    closeSync3(stdoutFd);
+    closeSync3(stderrFd);
+    if (!child.pid) {
+      throw new Error(
+        `failed to spawn Codex worker (is \`${bin}\` on PATH? run \`codex login\` or set CODEX_API_KEY)`
+      );
+    }
+    child.unref();
+    return { pid: child.pid, model };
+  }
+};
+
+// src/model-routing.ts
+var GLOBAL_DEFAULT_MODEL = "claude-sonnet-4-6";
+var CURSOR_DEFAULT_MODEL = "composer-2.5";
+function taskString4(task, key) {
+  const v = task[key];
+  return typeof v === "string" ? v.trim() : "";
+}
+function normalizeRef(ref) {
+  return ref.toLowerCase();
+}
+function resolveGlobalDefaultModel(config = loadUserConfig()) {
+  const fromConfig = config.defaultModel?.trim();
+  if (fromConfig) return fromConfig;
+  const fromEnv = process.env.KYNVER_DEFAULT_MODEL?.trim();
+  if (fromEnv) return fromEnv;
+  return GLOBAL_DEFAULT_MODEL;
+}
+function inferProviderFromModel(model) {
+  const m = (model ?? "").toLowerCase();
+  if (!m) return "cursor";
+  if (m.includes("composer") || m.includes("cursor") || m.includes("codex") || m.startsWith("gpt-") || m.startsWith("gpt5")) {
+    return "cursor";
+  }
+  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();
+  const provider = explicitProvider?.trim();
+  if (alias === "cursor") {
+    return {
+      model: CURSOR_DEFAULT_MODEL,
+      provider: "cursor",
+      rule: provider && provider !== "cursor" ? "explicit:model_provider_alias_overrode_provider" : "explicit:model_provider_alias",
+      requestedModel: model
+    };
+  }
+  if (alias === "claude" || alias === "anthropic") {
+    return {
+      model: CLAUDE_DEFAULT_MODEL,
+      provider: "claude",
+      rule: provider && provider !== "claude" ? "explicit:model_provider_alias_overrode_provider" : "explicit:model_provider_alias",
+      requestedModel: model
+    };
+  }
+  return null;
+}
+function isOpusLane(ref, title) {
+  if (ref.includes("deep") && ref.includes("review")) return true;
+  if (ref.includes("security")) return true;
+  if (ref.includes("plan_author") || ref.includes("plan-author")) return true;
+  if (title.includes("deep review") || title.includes("security review")) return true;
+  if (ref.includes("plan") && !ref.includes("review") && (ref.includes("author") || ref.includes("strategy"))) {
+    return true;
+  }
+  return false;
+}
+function inferModelRoutingFromTask(task) {
+  const ref = normalizeRef(taskString4(task, "executorRef"));
+  const title = taskString4(task, "title").toLowerCase();
+  const priority = taskString4(task, "priority") || "normal";
+  const roleLane = normalizeRef(taskString4(task, "roleLane"));
+  if (ref.includes("provider:codex") || ref.startsWith("codex:")) {
+    return { provider: "codex", model: CODEX_DEFAULT_MODEL, rule: "lane:codex_orchestration" };
+  }
+  if (ref.includes("cursor") || ref.includes("composer") || ref.includes("copilot") || roleLane === "implementer" || roleLane === "repair_implementer") {
+    return { provider: "cursor", rule: "lane:implementation" };
+  }
+  if (ref.includes("codex")) {
+    return { provider: "codex", model: CODEX_DEFAULT_MODEL, rule: "lane:codex_orchestration" };
   }
   if (ref.includes("landing") || title.startsWith("land:") || title.includes(" merge")) {
     return { provider: "cursor", rule: "lane:landing" };
@@ -2237,12 +3081,33 @@ function resolveWorkerLaunch(input) {
       requestedModel: model
     };
   }
-  return enforceCursorWorkerProvider({
+  const afterCursorPolicy = enforceCursorWorkerProvider({
     routing: decision,
     task: input.task,
     explicitProvider: input.explicitProvider,
     explicitProviderIsOperatorOverride: input.explicitProviderIsOperatorOverride
   });
+  if (!input.task || Object.keys(input.task).length === 0) {
+    return afterCursorPolicy;
+  }
+  if (afterCursorPolicy.rule === "explicit:model_provider_alias" || afterCursorPolicy.rule === "explicit:model_provider_alias_overrode_provider") {
+    return afterCursorPolicy;
+  }
+  if (isClaudeFamilyProvider(afterCursorPolicy.provider) && (input.explicitProviderIsOperatorOverride || taskAllowsClaudeWorker(input.task))) {
+    return afterCursorPolicy;
+  }
+  const orchestration = resolveOrchestrationRouting({
+    task: input.task,
+    explicitProvider: input.explicitProvider ?? afterCursorPolicy.provider,
+    explicitModel: afterCursorPolicy.model
+  });
+  return {
+    provider: orchestration.provider,
+    model: orchestration.provider === "codex" ? orchestration.model ?? afterCursorPolicy.model ?? CODEX_DEFAULT_MODEL : afterCursorPolicy.model,
+    rule: orchestration.rule,
+    requestedModel: afterCursorPolicy.requestedModel,
+    orchestrationAudit: orchestration.audit
+  };
 }
 function resolveModelFallback(startedModel, launchModel, providerDefault) {
   return startedModel || launchModel || providerDefault || resolveGlobalDefaultModel() || CLAUDE_DEFAULT_MODEL;
@@ -2256,16 +3121,69 @@ function positiveInt2(value, fallback) {
 }
 function readHarnessRetryLimits() {
   return {
-    maxTaskAttempts: positiveInt2(process.env.KYNVER_MAX_TASK_ATTEMPTS, 3),
+    maxTaskAttempts: positiveInt2(process.env.KYNVER_MAX_TASK_ATTEMPTS, 4),
     dispatchCooldownMs: positiveInt2(process.env.KYNVER_DISPATCH_COOLDOWN_MS, 5e3)
   };
 }
 
 // src/lease-renewal.ts
-import path8 from "node:path";
+import path13 from "node:path";
+
+// src/harness-lease-owner.ts
+var HARNESS_LEASE_PREFIX = "kynver-harness:";
+var RUNNER_MARKER = "@runner:";
+function trimOrNull4(value) {
+  if (!value?.trim()) return null;
+  return value.trim();
+}
+function parseHarnessLeaseRunId(leaseOwner) {
+  const owner = trimOrNull4(leaseOwner);
+  if (!owner?.startsWith(HARNESS_LEASE_PREFIX)) return null;
+  const body = owner.slice(HARNESS_LEASE_PREFIX.length);
+  const atRunner = body.indexOf(RUNNER_MARKER);
+  if (atRunner >= 0) return body.slice(0, atRunner).trim() || null;
+  return body.trim() || null;
+}
+function formatHarnessLeaseOwner(runId, runnerId) {
+  const run = runId.trim();
+  const runner = runnerId.trim();
+  return `${HARNESS_LEASE_PREFIX}${run}${RUNNER_MARKER}${runner}`;
+}
+function harnessLeaseOwnerMatchesRun(leaseOwner, runId) {
+  const expectedRun = trimOrNull4(runId);
+  if (!expectedRun) return false;
+  return parseHarnessLeaseRunId(leaseOwner) === expectedRun;
+}
+function resolveHarnessLeaseOwnerForRenewal(input) {
+  const stored = trimOrNull4(input.workerLeaseOwner);
+  if (stored && harnessLeaseOwnerMatchesRun(stored, input.runId)) {
+    return stored;
+  }
+  return formatHarnessLeaseOwner(input.runId, input.runnerId);
+}
+
+// src/runner-identity.ts
+import os3 from "node:os";
+function trimOrNull5(value) {
+  if (!value?.trim()) return null;
+  return value.trim();
+}
+function resolveRunnerPresencePayload(input = {}) {
+  const env = input.env ?? process.env;
+  const runnerId = trimOrNull5(env.KYNVER_RUNTIME_ID) ?? trimOrNull5(env.OPENCLAW_RUNTIME_ID) ?? trimOrNull5(env.HOSTNAME) ?? os3.hostname();
+  return {
+    runnerId,
+    hostname: trimOrNull5(env.HOSTNAME) ?? os3.hostname(),
+    profile: trimOrNull5(env.KYNVER_RUNNER_PROFILE) ?? trimOrNull5(env.OPENCLAW_RUNNER_PROFILE),
+    harnessRepo: trimOrNull5(env.KYNVER_HARNESS_REPO) ?? trimOrNull5(env.KYNVER_DEFAULT_REPO),
+    runId: input.runId ?? null
+  };
+}
+
+// src/lease-renewal.ts
 function workerRecord(runId, name) {
   return readJson(
-    path8.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path13.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -2282,7 +3200,7 @@ async function renewActiveTaskLeases(runId, args) {
     { baseUrl: base }
   );
   const leaseDurationMs = Number(args.leaseMs) > 0 ? Math.floor(Number(args.leaseMs)) : DEFAULT_DISPATCH_LEASE_MS;
-  const leaseOwner = `kynver-harness:${runId}`;
+  const runnerId = resolveRunnerPresencePayload({ runId }).runnerId;
   const renewed = [];
   const failed = [];
   const skipped = [];
@@ -2301,11 +3219,20 @@ async function renewActiveTaskLeases(runId, args) {
       skipped.push(name);
       continue;
     }
+    const leaseOwner = resolveHarnessLeaseOwnerForRenewal({
+      runId,
+      workerLeaseOwner: worker.leaseOwner ?? null,
+      runnerId
+    });
     const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(worker.taskId)}/renew-lease`;
     const res = await postJsonWithCredentialRefresh(
       url,
       secret,
-      { leaseOwner, leaseDurationMs },
+      {
+        leaseOwner,
+        leaseDurationMs,
+        ...worker.leaseToken ? { leaseToken: worker.leaseToken } : {}
+      },
       { agentOsId, baseUrl: base }
     );
     if (res.ok) {
@@ -2331,20 +3258,20 @@ function hasLiveWorkerForTask(runId, taskId) {
 }
 
 // src/supervisor.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync3 } from "node:fs";
-import path14 from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync3 } from "node:fs";
+import path19 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) {
+function trimOrNull6(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);
+  if (!m) return trimOrNull6(url);
   return `https://github.com/${m[1]}/pull/${m[2]}`;
 }
 function isHarnessRepairTask(task) {
@@ -2366,10 +3293,10 @@ function parseRepairTargetContractFromDescription(description) {
   if (!m?.[1]) return empty;
   try {
     const parsed = JSON.parse(m[1]);
-    const url = trimOrNull4(
+    const url = trimOrNull6(
       String(parsed.targetPrUrl ?? parsed.target_pr_url ?? "")
     );
-    const branch = trimOrNull4(
+    const branch = trimOrNull6(
       String(parsed.targetPrBranch ?? parsed.target_pr_branch ?? "")
     );
     const enforce = parsed.repairEnforceOriginalPr === true || parsed.repair_enforce_original_pr === true;
@@ -2390,7 +3317,7 @@ function resolveHarnessRepairTargetFromTask(task) {
   if (!targetPrUrl) return null;
   return {
     targetPrUrl,
-    targetPrBranch: block.targetPrBranch ?? trimOrNull4(task.branch)
+    targetPrBranch: block.targetPrBranch ?? trimOrNull6(task.branch)
   };
 }
 function repairTargetPromptLines(target) {
@@ -2478,13 +3405,13 @@ function buildPrompt(input) {
 }
 
 // src/providers/cursor.ts
-import { closeSync as closeSync2, existsSync as existsSync10, openSync as openSync2 } from "node:fs";
-import { spawn as spawn2 } from "node:child_process";
-import path10 from "node:path";
+import { closeSync as closeSync4, existsSync as existsSync16, openSync as openSync4 } from "node:fs";
+import { spawn as spawn4 } from "node:child_process";
+import path15 from "node:path";
 
 // src/providers/cursor-windows.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3 } from "node:fs";
-import path9 from "node:path";
+import { existsSync as existsSync15, readdirSync as readdirSync3 } from "node:fs";
+import path14 from "node:path";
 var CURSOR_VERSION_DIR = /^\d{4}\.\d{1,2}\.\d{1,2}-[a-f0-9]+$/i;
 function parseCursorVersionSortKey(versionName) {
   const datePart = versionName.split("-")[0];
@@ -2495,8 +3422,8 @@ function parseCursorVersionSortKey(versionName) {
   return Number(`${year}${month.padStart(2, "0")}${day.padStart(2, "0")}`);
 }
 function pickLatestCursorVersionDir(agentRoot) {
-  const versionsRoot = path9.join(agentRoot, "versions");
-  if (!existsSync9(versionsRoot)) return null;
+  const versionsRoot = path14.join(agentRoot, "versions");
+  if (!existsSync15(versionsRoot)) return null;
   let bestDir = null;
   let bestKey = -1;
   for (const entry of readdirSync3(versionsRoot, { withFileTypes: true })) {
@@ -2504,22 +3431,22 @@ function pickLatestCursorVersionDir(agentRoot) {
     const key = parseCursorVersionSortKey(entry.name);
     if (key == null || key <= bestKey) continue;
     bestKey = key;
-    bestDir = path9.join(versionsRoot, entry.name);
+    bestDir = path14.join(versionsRoot, entry.name);
   }
   return bestDir;
 }
 function resolveWindowsCursorBundled(agentRoot) {
-  const root = agentRoot?.trim() || path9.join(process.env.LOCALAPPDATA || "", "cursor-agent");
-  const directNode = path9.join(root, "node.exe");
-  const directIndex = path9.join(root, "index.js");
-  if (existsSync9(directNode) && existsSync9(directIndex)) {
+  const root = agentRoot?.trim() || path14.join(process.env.LOCALAPPDATA || "", "cursor-agent");
+  const directNode = path14.join(root, "node.exe");
+  const directIndex = path14.join(root, "index.js");
+  if (existsSync15(directNode) && existsSync15(directIndex)) {
     return { nodeExe: directNode, indexJs: directIndex, versionDir: root };
   }
   const versionDir = pickLatestCursorVersionDir(root);
   if (!versionDir) return null;
-  const nodeExe = path9.join(versionDir, "node.exe");
-  const indexJs = path9.join(versionDir, "index.js");
-  if (!existsSync9(nodeExe) || !existsSync9(indexJs)) return null;
+  const nodeExe = path14.join(versionDir, "node.exe");
+  const indexJs = path14.join(versionDir, "index.js");
+  if (!existsSync15(nodeExe) || !existsSync15(indexJs)) return null;
   return { nodeExe, indexJs, versionDir };
 }
 
@@ -2537,13 +3464,13 @@ function bundledSpawnTarget(nodeExe, indexJs, versionDir) {
 function resolveCursorSpawn(agentBin) {
   if (process.platform === "win32") {
     const isCursorWrapper = /\.(cmd|bat)$/i.test(agentBin);
-    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync10(path10.join(path10.dirname(agentBin), "index.js"));
+    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync16(path15.join(path15.dirname(agentBin), "index.js"));
     const isDefaultShim = agentBin === "agent";
     if (isCursorWrapper || isBundledNode || isDefaultShim) {
-      const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path10.dirname(agentBin)) : isBundledNode ? {
+      const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path15.dirname(agentBin)) : isBundledNode ? {
         nodeExe: agentBin,
-        indexJs: path10.join(path10.dirname(agentBin), "index.js"),
-        versionDir: path10.dirname(agentBin)
+        indexJs: path15.join(path15.dirname(agentBin), "index.js"),
+        versionDir: path15.dirname(agentBin)
       } : resolveWindowsCursorBundled();
       if (bundled) {
         return bundledSpawnTarget(bundled.nodeExe, bundled.indexJs, bundled.versionDir);
@@ -2563,8 +3490,8 @@ function resolveAgentBin() {
       process.env.KYNVER_CURSOR_AGENT_ROOT?.trim() || void 0
     );
     if (bundled) return bundled.nodeExe;
-    const localAgent = path10.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
-    if (existsSync10(localAgent)) return localAgent;
+    const localAgent = path15.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
+    if (existsSync16(localAgent)) return localAgent;
   }
   return "agent";
 }
@@ -2573,7 +3500,7 @@ function cursorWorkerEnv(agentBin, spawnTarget) {
     ...process.env,
     CI: "1",
     NO_COLOR: "1",
-    ...spawnTarget.bundledVersionDir ? { CURSOR_INVOKED_AS: path10.basename(agentBin) || "agent.cmd" } : {}
+    ...spawnTarget.bundledVersionDir ? { CURSOR_INVOKED_AS: path15.basename(agentBin) || "agent.cmd" } : {}
   });
 }
 var cursorProvider = {
@@ -2588,12 +3515,12 @@ var cursorProvider = {
       throw new Error(`cursor provider model preflight failed: ${preflight.note}`);
     }
     const model = preflight.model;
-    const stdoutFd = openSync2(opts.stdoutPath, "a");
-    const stderrFd = openSync2(opts.stderrPath, "a");
+    const stdoutFd = openSync4(opts.stdoutPath, "a");
+    const stderrFd = openSync4(opts.stderrPath, "a");
     const stdio = ["ignore", stdoutFd, stderrFd];
     const agentBin = resolveAgentBin();
     const spawnTarget = resolveCursorSpawn(agentBin);
-    const child = spawn2(
+    const child = spawn4(
       spawnTarget.executable,
       [
         ...spawnTarget.prefixArgs,
@@ -2617,8 +3544,8 @@ var cursorProvider = {
         env: cursorWorkerEnv(agentBin, spawnTarget)
       })
     );
-    closeSync2(stdoutFd);
-    closeSync2(stderrFd);
+    closeSync4(stdoutFd);
+    closeSync4(stderrFd);
     if (!child.pid) {
       throw new Error(
         `failed to spawn Cursor agent worker (is \`${agentBin}\` on PATH? run \`agent login\` or set CURSOR_API_KEY)`
@@ -2632,6 +3559,7 @@ var cursorProvider = {
 // src/providers/registry.ts
 var BUILTIN = {
   claude: claudeProvider,
+  codex: codexProvider,
   cursor: cursorProvider
 };
 var overrideProvider = null;
@@ -2654,9 +3582,9 @@ function resolveWorkerProvider(name) {
 }
 
 // src/auto-complete.ts
-import { spawn as spawn3 } from "node:child_process";
-import { existsSync as existsSync11, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
-import path13 from "node:path";
+import { spawn as spawn5 } from "node:child_process";
+import { existsSync as existsSync17, openSync as openSync5, closeSync as closeSync5 } from "node:fs";
+import path18 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/completion-ack.ts
@@ -2673,7 +3601,7 @@ function persistCompletionAck(worker, runId, fields) {
 }
 
 // src/worker-ops.ts
-import path12 from "node:path";
+import path17 from "node:path";
 
 // src/completion-response.ts
 function asRecord(value) {
@@ -2741,7 +3669,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 trimOrNull5(value) {
+function trimOrNull7(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   return trimmed.length ? trimmed : null;
@@ -2749,7 +3677,7 @@ function trimOrNull5(value) {
 function committedHead(ancestry) {
   if (!ancestry?.checked) return null;
   if (ancestry.headIsAncestorOfBase !== false) return null;
-  return trimOrNull5(ancestry.head);
+  return trimOrNull7(ancestry.head);
 }
 function extractPrUrlFromText(value) {
   if (value === void 0 || value === null) return null;
@@ -2757,7 +3685,7 @@ function extractPrUrlFromText(value) {
   const m = text.match(
     /https?:\/\/[^\s)>"]+\/(?:pull|pulls|merge_requests|pull-requests)\/\d+/i
   );
-  return m ? trimOrNull5(m[0]) : null;
+  return m ? trimOrNull7(m[0]) : null;
 }
 function countCommitsAheadOfBase(worktreePath, baseRef, exec) {
   const base = baseRef.trim();
@@ -2769,21 +3697,21 @@ function countCommitsAheadOfBase(worktreePath, baseRef, exec) {
 }
 function isReviewArtifactWorker(worker, snapshot) {
   if (snapshot.changedFiles.length > 0) return false;
-  const persona = trimOrNull5(worker.personaSlug)?.toLowerCase();
+  const persona = trimOrNull7(worker.personaSlug)?.toLowerCase();
   if (persona && REVIEW_PERSONA_SLUGS.has(persona)) return true;
-  const rule = trimOrNull5(worker.routingRule) ?? "";
+  const rule = trimOrNull7(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 = trimOrNull5(options?.baseRef);
+  const baseRef = trimOrNull7(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 (trimOrNull5(snapshot.headCommit)) return true;
+  if (trimOrNull7(snapshot.headCommit)) return true;
   if (committedHead(snapshot.gitAncestry)) return true;
   return false;
 }
@@ -2799,7 +3727,7 @@ function assessPrHandoffRequirement(input) {
   })) {
     return { required: false, reason: "expert_review_task" };
   }
-  const rule = trimOrNull5(input.routingRule) ?? "";
+  const rule = trimOrNull7(input.routingRule) ?? "";
   if (rule && REVIEW_LANE_RULE.test(rule)) {
     return { required: false, reason: "review_lane" };
   }
@@ -2810,14 +3738,14 @@ function assessPrHandoffRequirement(input) {
   if (isReviewArtifactWorker(workerCtx, input.snapshot)) {
     return { required: false, reason: "review_artifact" };
   }
-  if (trimOrNull5(input.patchPath) || trimOrNull5(input.artifactBundlePath)) {
+  if (trimOrNull7(input.patchPath) || trimOrNull7(input.artifactBundlePath)) {
     return { required: false, reason: "patch_or_bundle" };
   }
-  const repairTarget = trimOrNull5(input.repairTargetPrUrl);
+  const repairTarget = trimOrNull7(input.repairTargetPrUrl);
   if (repairTarget) {
     return { required: false, reason: "repair_target_pr" };
   }
-  const prUrl = trimOrNull5(input.prUrl) ?? trimOrNull5(input.taskPrUrl) ?? trimOrNull5(input.snapshot.prUrl);
+  const prUrl = trimOrNull7(input.prUrl) ?? trimOrNull7(input.taskPrUrl) ?? trimOrNull7(input.snapshot.prUrl);
   if (prUrl) {
     return { required: false, reason: "already_has_pr" };
   }
@@ -2838,13 +3766,13 @@ function buildPrHandoffSnapshotFromStatus(status, extras) {
     worktreePath: status.worktreePath,
     gitAncestry: status.gitAncestry,
     finalResult: status.finalResult,
-    headCommit: trimOrNull5(extras?.headCommit) ?? committedHead(status.gitAncestry),
-    prUrl: trimOrNull5(extras?.prUrl) ?? null
+    headCommit: trimOrNull7(extras?.headCommit) ?? committedHead(status.gitAncestry),
+    prUrl: trimOrNull7(extras?.prUrl) ?? null
   };
 }
 
 // src/pr-handoff/pr-handoff-gh.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 
 // src/github-repo.ts
 function parseGithubOwnerRepo(remoteUrl) {
@@ -2877,7 +3805,7 @@ function normalizeOwnerRepo(value) {
 // src/pr-handoff/pr-handoff-gh.ts
 function capture(bin, cwd, args) {
   try {
-    const res = spawnSync2(bin, args, { cwd, encoding: "utf8" });
+    const res = spawnSync3(bin, args, { cwd, encoding: "utf8" });
     return {
       status: res.status,
       stdout: (res.stdout || "").trim(),
@@ -3219,7 +4147,7 @@ function pathFromGitStatusLine(line) {
 }
 
 // src/disposable-artifacts.ts
-function stringList(value) {
+function stringList2(value) {
   if (!Array.isArray(value)) return [];
   return value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
 }
@@ -3230,9 +4158,9 @@ function extractDisposableArtifactsRemoved(finalResult) {
   const record = asRecord2(finalResult);
   if (!record) return [];
   const nested = asRecord2(record.worktreeHandoff);
-  const fromNested = stringList(nested?.disposableArtifactsRemoved);
+  const fromNested = stringList2(nested?.disposableArtifactsRemoved);
   if (fromNested.length) return fromNested;
-  return stringList(record.disposableArtifactsRemoved);
+  return stringList2(record.disposableArtifactsRemoved);
 }
 function normalizeRelativePath(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
@@ -3243,18 +4171,18 @@ function dirtyPathsCoveredByDisposableRemoval(changedFiles, removed) {
   if (removed.length === 0) return false;
   const removedSet = new Set(removed.map((p) => normalizeRelativePath(p)));
   return material.every((line) => {
-    const path50 = normalizeRelativePath(pathFromGitStatusLine(line));
-    return removedSet.has(path50);
+    const path59 = normalizeRelativePath(pathFromGitStatusLine(line));
+    return removedSet.has(path59);
   });
 }
 
 // src/worktree-completion-handoff.ts
-function trimOrNull6(value) {
+function trimOrNull8(value) {
   if (typeof value !== "string") return null;
   const t = value.trim();
   return t.length ? t : null;
 }
-function stringList2(value) {
+function stringList3(value) {
   if (!Array.isArray(value)) return [];
   return value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
 }
@@ -3267,16 +4195,16 @@ function hasFinalResult4(value) {
   return true;
 }
 function mergedDisposableRemoved(input) {
-  const fromWorker = stringList2(input.disposableArtifactsRemoved);
+  const fromWorker = stringList3(input.disposableArtifactsRemoved);
   const fromResult = extractDisposableArtifactsRemoved(input.finalResult);
   return [.../* @__PURE__ */ new Set([...fromWorker, ...fromResult])];
 }
 function assessWorktreeCompletionHandoff(input) {
-  const rawDirty = stringList2(input.changedFiles);
+  const rawDirty = stringList3(input.changedFiles);
   const materialDirty = materialWorktreeChanges(rawDirty);
   const removed = mergedDisposableRemoved(input);
   const effectivelyClean = materialDirty.length === 0 || dirtyPathsCoveredByDisposableRemoval(rawDirty, removed);
-  if (trimOrNull6(input.prUrl)) {
+  if (trimOrNull8(input.prUrl)) {
     if (!effectivelyClean) {
       return {
         allowed: false,
@@ -3287,7 +4215,7 @@ function assessWorktreeCompletionHandoff(input) {
     }
     return { allowed: true, state: "pr_handoff", materialDirtyCount: 0 };
   }
-  if (trimOrNull6(input.headCommit)) {
+  if (trimOrNull8(input.headCommit)) {
     if (!effectivelyClean) {
       return {
         allowed: false,
@@ -3298,7 +4226,7 @@ function assessWorktreeCompletionHandoff(input) {
     }
     return { allowed: true, state: "commit_handoff", materialDirtyCount: 0 };
   }
-  if (trimOrNull6(input.artifactBundlePath) || trimOrNull6(input.patchPath)) {
+  if (trimOrNull8(input.artifactBundlePath) || trimOrNull8(input.patchPath)) {
     if (!effectivelyClean) {
       return {
         allowed: false,
@@ -3329,7 +4257,7 @@ function assessWorktreeCompletionHandoff(input) {
 }
 
 // src/worker-lifecycle.ts
-import path11 from "node:path";
+import path16 from "node:path";
 var TASK_LEFT_RUNNING = /* @__PURE__ */ new Set([
   "awaiting_review",
   "blocked",
@@ -3385,7 +4313,7 @@ function syncCompletionAcknowledgedFromOperatorTick(runId, operatorTick) {
   const synced = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path11.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path16.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || isCompletionAcknowledged(worker)) continue;
@@ -3502,37 +4430,39 @@ async function tryCompleteWorker(args) {
     return { ok: true, skipped: true, reason: "local-only-worker" };
   }
   const headCommit = status.gitAncestry.headIsAncestorOfBase === false && status.gitAncestry.head ? status.gitAncestry.head : status.headCommit;
-  const handoff = assessWorktreeCompletionHandoff({
-    changedFiles: status.changedFiles,
-    finalResult: status.finalResult,
-    prUrl: status.prUrl,
-    headCommit,
-    disposableArtifactsRemoved: worker.disposableArtifactsRemoved
-  });
-  if (!handoff.allowed) {
-    const reason2 = handoff.detail ?? `worktree completion blocked (${handoff.state})`;
-    persistCompletionBlocker(worker, reason2);
-    return {
-      ok: false,
-      reason: reason2,
-      nextAction: "Clean the worktree (commit, open a PR, or `kynver worker discard-disposable --path <file>`), then rerun `kynver worker complete`.",
-      completionBlocked: true
-    };
+  if (worker.dispatched) {
+    const handoff = assessWorktreeCompletionHandoff({
+      changedFiles: status.changedFiles,
+      finalResult: status.finalResult,
+      prUrl: status.prUrl,
+      headCommit,
+      disposableArtifactsRemoved: worker.disposableArtifactsRemoved
+    });
+    if (!handoff.allowed) {
+      const reason2 = handoff.detail ?? `worktree completion blocked (${handoff.state})`;
+      persistCompletionBlocker(worker, reason2);
+      return {
+        ok: false,
+        reason: reason2,
+        nextAction: "Clean the worktree (commit, open a PR, or `kynver worker discard-disposable --path <file>`), then rerun `kynver worker complete`.",
+        completionBlocked: true
+      };
+    }
   }
   const skipPrHandoff = args.skipPrHandoff === true || args.skipPrHandoff === "true";
   if (!skipPrHandoff && worker.dispatched && taskId) {
-    const handoff2 = ensurePrReadyHandoff({ worker, run, status });
-    if (!handoff2.ok) {
-      persistCompletionBlocker(worker, handoff2.reason);
+    const handoff = ensurePrReadyHandoff({ worker, run, status });
+    if (!handoff.ok) {
+      persistCompletionBlocker(worker, handoff.reason);
       return {
         ok: false,
-        reason: handoff2.reason,
-        nextAction: handoff2.nextAction,
+        reason: handoff.reason,
+        nextAction: handoff.nextAction,
         completionBlocked: true
       };
     }
-    if (handoff2.prUrl || handoff2.headCommit) {
-      status = applyPrHandoffToStatus(status, handoff2);
+    if (handoff.prUrl || handoff.headCommit) {
+      status = applyPrHandoffToStatus(status, handoff);
     }
   }
   const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
@@ -3549,9 +4479,10 @@ async function tryCompleteWorker(args) {
     runId: worker.runId,
     workerName: worker.name,
     taskId,
+    leaseToken: worker.leaseToken ?? null,
     startedAt: worker.startedAt,
     finishedAt: status.lastActivityAt || (/* @__PURE__ */ new Date()).toISOString(),
-    status: statusPayload,
+    status: worker.leaseToken ? { ...statusPayload, leaseToken: worker.leaseToken } : statusPayload,
     workerInjection: {
       instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
       instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null,
@@ -3666,7 +4597,7 @@ function workerStatus(args) {
   const worker = loadWorker(String(args.run), String(args.name));
   const run = loadRun(worker.runId);
   const status = computeWorkerStatus(worker, workerStatusOptions(run));
-  writeJson(path12.join(worker.workerDir, "last-status.json"), status);
+  writeJson(path17.join(worker.workerDir, "last-status.json"), status);
   console.log(JSON.stringify(status, null, 2));
 }
 function buildRunBoard(runId) {
@@ -3674,7 +4605,7 @@ function buildRunBoard(runId) {
   const names = Object.keys(run.workers || {});
   const workers = names.map((name) => {
     const worker = readJson(
-      path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path17.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) {
@@ -3785,7 +4716,7 @@ function buildRunBoard(runId) {
     needsAttention: workers.filter((w) => w.attention && w.attention !== "ok" && w.attention !== "done").map((w) => w.worker),
     workers
   };
-  writeJson(path12.join(runDirectory(run.id), "last-board.json"), board);
+  writeJson(path17.join(runDirectory(run.id), "last-board.json"), board);
   return board;
 }
 async function publishHarnessBoardSnapshot(args, source) {
@@ -3974,15 +4905,15 @@ async function autoCompleteWorkerCli(raw) {
   }
 }
 function resolveDefaultCliPath() {
-  return path13.join(fileURLToPath2(new URL(".", import.meta.url)), "cli.js");
+  return path18.join(fileURLToPath2(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnCompletionSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath();
-  if (!existsSync11(cliPath)) return void 0;
-  const logPath = path13.join(opts.workerDir, "auto-complete.log");
+  if (!existsSync17(cliPath)) return void 0;
+  const logPath = path18.join(opts.workerDir, "auto-complete.log");
   let logFd;
   try {
-    logFd = openSync3(logPath, "a");
+    logFd = openSync5(logPath, "a");
   } catch {
     logFd = void 0;
   }
@@ -4005,7 +4936,7 @@ function spawnCompletionSidecar(opts) {
   if (opts.baseUrl) args.push("--base-url", opts.baseUrl);
   if (opts.secret) args.push("--secret", opts.secret);
   try {
-    const child = spawn3(
+    const child = spawn5(
       nodeExecutable,
       args,
       hiddenSpawnOptions({
@@ -4014,13 +4945,13 @@ function spawnCompletionSidecar(opts) {
         env: process.env
       })
     );
-    if (logFd !== void 0) closeSync3(logFd);
+    if (logFd !== void 0) closeSync5(logFd);
     child.unref();
     return { pid: child.pid, logPath, cliPath };
   } catch {
     if (logFd !== void 0) {
       try {
-        closeSync3(logFd);
+        closeSync5(logFd);
       } catch {
       }
     }
@@ -4075,21 +5006,21 @@ function spawnWorkerProcess(run, opts) {
     launchModel = preflight.model;
   }
   const { worktreesDir } = getPaths();
-  const workerDir = path14.join(runDirectory(run.id), "workers", name);
+  const workerDir = path19.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
-  const worktreePath = path14.join(worktreesDir, run.id, name);
+  const worktreePath = path19.join(worktreesDir, 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}`);
+  if (existsSync18(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
   git(run.repo, ["fetch", "origin", "--prune"], { allowFailure: 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");
+  const stdoutPath = path19.join(workerDir, "stdout.jsonl");
+  const stderrPath = path19.join(workerDir, "stderr.log");
+  const heartbeatPath = path19.join(workerDir, "heartbeat.jsonl");
   const prompt = buildPrompt({
     task: opts.task,
     ownedPaths: opts.ownedPaths || [],
@@ -4146,10 +5077,12 @@ function spawnWorkerProcess(run, opts) {
     ...opts.personaSlug ? { personaSlug: String(opts.personaSlug) } : {},
     ...opts.personaEvidence ? { personaEvidence: opts.personaEvidence } : {},
     ...opts.leaseOwner ? { leaseOwner: String(opts.leaseOwner) } : {},
+    ...opts.leaseToken ? { leaseToken: String(opts.leaseToken) } : {},
     ...opts.dispatched ? { dispatched: true } : {},
     ...!opts.agentOsId || !opts.taskId ? { localOnly: true } : {},
     routingRule: routing.rule,
     ...routing.requestedModel ? { requestedModel: routing.requestedModel } : {},
+    ...routing.orchestrationAudit ? { orchestrationAudit: routing.orchestrationAudit } : {},
     ...opts.executorRef ? { executorRef: String(opts.executorRef) } : {},
     ...opts.parentTaskId ? { parentTaskId: String(opts.parentTaskId) } : {},
     ...opts.taskTitle ? { taskTitle: String(opts.taskTitle) } : {},
@@ -4159,7 +5092,7 @@ function spawnWorkerProcess(run, opts) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveWorker(run.id, worker);
-  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path14.join(workerDir, "worker.json") } };
+  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path19.join(workerDir, "worker.json") } };
   run.status = "running";
   saveRun(run);
   if (worker.agentOsId && worker.taskId) {
@@ -4253,17 +5186,50 @@ async function startWorker(args) {
   }
 }
 
+// src/active-harness-workers.ts
+import path20 from "node:path";
+function workerWriteSetFields(worker) {
+  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") : [];
+  return {
+    ...ownedPaths.length ? { ownedPaths } : {},
+    ...writeSetPrefixes.length ? { writeSetPrefixes } : {},
+    ...worker.allowConcurrentHotspot ? { allowConcurrentHotspot: true } : {}
+  };
+}
+function collectRunActiveHarnessWorkers(runId) {
+  const run = loadRun(runId);
+  const out = [];
+  for (const name of Object.keys(run.workers || {})) {
+    const worker = readJson(
+      path20.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
+    );
+    if (!worker?.taskId || !isPidAlive(worker.pid)) continue;
+    out.push({
+      runId: run.id,
+      workerName: name,
+      taskId: worker.taskId,
+      pid: worker.pid,
+      ...workerWriteSetFields(worker)
+    });
+  }
+  return out;
+}
+
 // src/plan-persist/body-hash.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function hashPlanBody(body) {
   const normalized = body.replace(/\r\n/g, "\n").trimEnd();
-  return createHash("sha256").update(normalized, "utf8").digest("hex");
+  return createHash2("sha256").update(normalized, "utf8").digest("hex");
 }
 function hashSummary(summary) {
   if (summary == null) return null;
   const trimmed = summary.trim();
   if (!trimmed) return null;
-  return createHash("sha256").update(trimmed, "utf8").digest("hex");
+  return createHash2("sha256").update(trimmed, "utf8").digest("hex");
 }
 
 // src/plan-persist/errors.ts
@@ -4433,7 +5399,7 @@ function mergeSourceRefs(input) {
 }
 
 // src/plan-persist/idempotency.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function buildPlanPersistIdempotencyKey(input) {
   const payload = {
     operation: input.operation,
@@ -4446,23 +5412,23 @@ function buildPlanPersistIdempotencyKey(input) {
     changeSummary: input.changeSummary?.trim() ?? null,
     markCurrent: input.markCurrent ?? true
   };
-  return createHash2("sha256").update(JSON.stringify(payload), "utf8").digest("hex");
+  return createHash3("sha256").update(JSON.stringify(payload), "utf8").digest("hex");
 }
 
 // src/plan-persist/paths.ts
 import { mkdirSync as mkdirSync4 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import path15 from "node:path";
+import { homedir as homedir10 } from "node:os";
+import path21 from "node:path";
 function resolveKynverStateRoot() {
   const env = process.env.KYNVER_STATE_ROOT;
-  if (env) return path15.resolve(env);
-  return path15.join(homedir5(), ".kynver", "state");
+  if (env) return path21.resolve(env);
+  return path21.join(homedir10(), ".kynver", "state");
 }
 function planOutboxDir() {
-  return path15.join(resolveKynverStateRoot(), "plan-outbox");
+  return path21.join(resolveKynverStateRoot(), "plan-outbox");
 }
 function planOutboxArchiveDir() {
-  return path15.join(resolveKynverStateRoot(), "plan-outbox-archive");
+  return path21.join(resolveKynverStateRoot(), "plan-outbox-archive");
 }
 function ensurePlanOutboxDirs() {
   const outboxDir = planOutboxDir();
@@ -4473,20 +5439,20 @@ function ensurePlanOutboxDirs() {
 }
 function isTmpOnlyPath(filePath) {
   if (filePath.startsWith("/tmp/") || filePath.startsWith("/var/folders/")) return true;
-  const resolved = path15.resolve(filePath);
-  return resolved.startsWith("/tmp/") || resolved.startsWith(path15.join("/var", "folders"));
+  const resolved = path21.resolve(filePath);
+  return resolved.startsWith("/tmp/") || resolved.startsWith(path21.join("/var", "folders"));
 }
 
 // src/plan-persist/outbox-store.ts
 import {
-  existsSync as existsSync14,
-  readFileSync as readFileSync8,
+  existsSync as existsSync20,
+  readFileSync as readFileSync9,
   renameSync,
   readdirSync as readdirSync4,
   writeFileSync as writeFileSync3,
   unlinkSync
 } from "node:fs";
-import path16 from "node:path";
+import path22 from "node:path";
 import { randomUUID } from "node:crypto";
 var DEFAULT_MAX_RETRIES = 12;
 function listOutboxItems() {
@@ -4494,7 +5460,7 @@ function listOutboxItems() {
   const files = readdirSync4(outboxDir).filter((f) => f.endsWith(".json"));
   const items = [];
   for (const file of files) {
-    const item = readOutboxItem(path16.join(outboxDir, file));
+    const item = readOutboxItem(path22.join(outboxDir, file));
     if (item && item.queueStatus === "queued") items.push(item);
   }
   return items.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
@@ -4506,25 +5472,25 @@ function findOutboxByIdempotencyKey(key) {
   return null;
 }
 function readOutboxItem(jsonPath) {
-  if (!existsSync14(jsonPath)) return null;
+  if (!existsSync20(jsonPath)) return null;
   try {
-    return JSON.parse(readFileSync8(jsonPath, "utf8"));
+    return JSON.parse(readFileSync9(jsonPath, "utf8"));
   } catch {
     return null;
   }
 }
 function readOutboxBody(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
-  const bodyFile = path16.join(outboxDir, item.bodyPath);
-  return readFileSync8(bodyFile, "utf8");
+  const bodyFile = path22.join(outboxDir, item.bodyPath);
+  return readFileSync9(bodyFile, "utf8");
 }
 function writeOutboxItem(input, opts) {
   const { outboxDir } = ensurePlanOutboxDirs();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const id = opts.existing?.id ?? randomUUID();
   const bodyPath = opts.existing?.bodyPath ?? `${id}.body.md`;
-  const jsonPath = path16.join(outboxDir, `${id}.json`);
-  const bodyFile = path16.join(outboxDir, bodyPath);
+  const jsonPath = path22.join(outboxDir, `${id}.json`);
+  const bodyFile = path22.join(outboxDir, bodyPath);
   if (!opts.existing) {
     writeFileSync3(bodyFile, input.body, "utf8");
   }
@@ -4560,24 +5526,24 @@ function writeOutboxItem(input, opts) {
 }
 function saveOutboxItem(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
-  const jsonPath = path16.join(outboxDir, `${item.id}.json`);
+  const jsonPath = path22.join(outboxDir, `${item.id}.json`);
   writeFileSync3(jsonPath, `${JSON.stringify(item, null, 2)}
 `, { mode: 384 });
 }
 function archiveOutboxItem(item) {
   const { outboxDir, archiveDir } = ensurePlanOutboxDirs();
-  const jsonSrc = path16.join(outboxDir, `${item.id}.json`);
-  const bodySrc = path16.join(outboxDir, item.bodyPath);
-  const jsonDst = path16.join(archiveDir, `${item.id}.json`);
-  const bodyDst = path16.join(archiveDir, item.bodyPath);
-  if (existsSync14(jsonSrc)) renameSync(jsonSrc, jsonDst);
-  if (existsSync14(bodySrc)) renameSync(bodySrc, bodyDst);
+  const jsonSrc = path22.join(outboxDir, `${item.id}.json`);
+  const bodySrc = path22.join(outboxDir, item.bodyPath);
+  const jsonDst = path22.join(archiveDir, `${item.id}.json`);
+  const bodyDst = path22.join(archiveDir, item.bodyPath);
+  if (existsSync20(jsonSrc)) renameSync(jsonSrc, jsonDst);
+  if (existsSync20(bodySrc)) renameSync(bodySrc, bodyDst);
 }
 function outboxItemPaths(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
   return {
-    jsonPath: path16.join(outboxDir, `${item.id}.json`),
-    bodyPath: path16.join(outboxDir, item.bodyPath)
+    jsonPath: path22.join(outboxDir, `${item.id}.json`),
+    bodyPath: path22.join(outboxDir, item.bodyPath)
   };
 }
 function outboxInputFromItem(item, body) {
@@ -4763,7 +5729,7 @@ function markOutboxFailed(item, message) {
 }
 
 // src/plan-persist/drain.ts
-import path17 from "node:path";
+import path23 from "node:path";
 async function drainPlanOutbox(opts = {}, deps = {}) {
   const items = listOutboxItems().filter(
     (item) => opts.outboxId ? item.id === opts.outboxId : true
@@ -4797,7 +5763,7 @@ async function drainPlanOutbox(opts = {}, deps = {}) {
   return result;
 }
 function loadOutboxById(outboxId) {
-  const jsonPath = path17.join(planOutboxDir(), `${outboxId}.json`);
+  const jsonPath = path23.join(planOutboxDir(), `${outboxId}.json`);
   return readOutboxItem(jsonPath);
 }
 
@@ -4827,24 +5793,6 @@ 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) {
@@ -4900,6 +5848,20 @@ function buildDispatchTaskText(task, agentOsId) {
   }
   return lines.join("\n");
 }
+function requestedTargetTaskIds(args) {
+  const out = /* @__PURE__ */ new Set();
+  if (args.targetTaskId) {
+    out.add(String(args.targetTaskId));
+    return out;
+  }
+  if (args.targetTaskIds) {
+    for (const value of String(args.targetTaskIds).split(",")) {
+      const trimmed = value.trim();
+      if (trimmed) out.add(trimmed);
+    }
+  }
+  return out;
+}
 async function dispatchRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -4910,37 +5872,46 @@ async function dispatchRun(args) {
     const execute = args.execute === true || args.execute === "true";
     const dryRun = !execute;
     const runnerPresence = resolveRunnerPresencePayload({ runId: run.id });
-    const leaseOwner = `kynver-harness:${run.id}@runner:${runnerPresence.runnerId}`;
+    const leaseOwner = formatHarnessLeaseOwner(run.id, 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;
-    const cappedStarts = dryRun ? requestedStarts : Math.min(requestedStarts, runnerResourceGate.slotsAvailable);
-    const activeHarnessWorkers = [];
-    for (const name of Object.keys(run.workers || {})) {
-      const worker = readJson(
-        path18.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-        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({
+    const runnerResourceGate = observeRunnerResourceGate({ runId: run.id });
+    const exactTargetIds = requestedTargetTaskIds(args);
+    const exactTargetMode = exactTargetIds.size > 0;
+    const requestedStarts = Number(args.maxStarts) > 0 ? Math.floor(Number(args.maxStarts)) : 1;
+    const effectiveRequestedStarts = exactTargetMode ? Math.min(requestedStarts, exactTargetIds.size) : requestedStarts;
+    const cappedStarts = dryRun ? effectiveRequestedStarts : Math.min(effectiveRequestedStarts, runnerResourceGate.slotsAvailable);
+    if (!dryRun && cappedStarts <= 0) {
+      const summary2 = {
         runId: run.id,
-        workerName: name,
-        taskId: worker.taskId,
-        pid: worker.pid,
-        ...ownedPaths.length ? { ownedPaths } : {},
-        ...writeSetPrefixes.length ? { writeSetPrefixes } : {},
-        ...worker.allowConcurrentHotspot ? { allowConcurrentHotspot: true } : {}
-      });
+        agentOsId,
+        dryRun: false,
+        skipped: true,
+        reason: runnerResourceGate.reason ?? "no resource slots",
+        resourceGate: runnerResourceGate
+      };
+      if (pipeline) return { ok: true, ...summary2 };
+      console.log(JSON.stringify(summary2, null, 2));
+      return;
+    }
+    const activeHarnessWorkers = collectRunActiveHarnessWorkers(run.id);
+    if (args.reconcileStaleBlockers === true || args.reconcileStaleBlockers === "true") {
+      const laneHygieneUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/lane-hygiene`;
+      try {
+        await postJsonWithCredentialRefresh(
+          laneHygieneUrl,
+          secret,
+          { agentOsId, dryRun: false, includeBoardReconcile: true },
+          { agentOsId, baseUrl: base }
+        );
+      } catch (err) {
+        console.error(`[dispatch] reconcile-stale-blockers lane-hygiene call failed: ${err.message}`);
+      }
     }
     const dispatchUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/dispatch-next`;
-    const body = {
+    const buildBody = (maxStarts) => ({
       agentOsId,
       dryRun,
-      maxStarts: cappedStarts,
+      maxStarts,
       leaseOwner,
       leaseDurationMs: Number(args.leaseMs) > 0 ? Math.floor(Number(args.leaseMs)) : DEFAULT_DISPATCH_LEASE_MS,
       runnerDiskGate,
@@ -4951,25 +5922,32 @@ async function dispatchRun(args) {
       ...args.lane ? { lane: String(args.lane) } : {},
       executor: args.executor ? String(args.executor) : "harness",
       ...args.diskPath ? { diskPath: String(args.diskPath) } : {},
-      ...args.targetTaskId ? { targetTaskId: String(args.targetTaskId) } : {}
+      ...args.targetTaskId ? { targetTaskId: String(args.targetTaskId) } : {},
+      ...!args.targetTaskId && args.targetTaskIds ? {
+        targetTaskIds: String(args.targetTaskIds).split(",").map((s) => s.trim()).filter(Boolean)
+      } : {}
+    });
+    const requestDispatch = async (maxStarts) => {
+      const dispatch = await postJsonWithCredentialRefresh(dispatchUrl, secret, buildBody(maxStarts), { agentOsId, baseUrl: base });
+      const responseBody = dispatch.response;
+      return { dispatch, result: responseBody?.result };
     };
-    const dispatch = await postJsonWithCredentialRefresh(dispatchUrl, secret, body, { agentOsId, baseUrl: base });
-    const responseBody = dispatch.response;
-    if (!dispatch.ok || !responseBody?.result) {
+    const first = await requestDispatch(exactTargetMode || dryRun ? cappedStarts : 1);
+    if (!first.dispatch.ok || !first.result) {
       const failure = {
         runId: run.id,
         agentOsId,
         action: "dispatch",
-        httpStatus: dispatch.status,
-        response: dispatch.response,
-        authRefreshed: dispatch.refreshedAuth === true,
-        authRefreshFailure: dispatch.authRefreshFailure
+        httpStatus: first.dispatch.status,
+        response: first.dispatch.response,
+        authRefreshed: first.dispatch.refreshedAuth === true,
+        authRefreshFailure: first.dispatch.authRefreshFailure
       };
       if (pipeline) return { ok: false, ...failure };
       console.log(JSON.stringify(failure, null, 2));
       process.exit(1);
     }
-    const result = responseBody.result;
+    const result = first.result;
     if (dryRun) {
       const summary2 = {
         runId: run.id,
@@ -4991,25 +5969,41 @@ async function dispatchRun(args) {
       console.log(JSON.stringify(summary2, null, 2));
       return;
     }
-    if (!dryRun && cappedStarts <= 0) {
-      const summary2 = {
-        runId: run.id,
-        agentOsId,
-        dryRun: false,
-        skipped: true,
-        reason: runnerResourceGate.reason ?? "no resource slots",
-        resourceGate: runnerResourceGate
-      };
-      if (pipeline) return { ok: true, ...summary2 };
-      console.log(JSON.stringify(summary2, null, 2));
-      return;
-    }
     const retryLimits = readHarnessRetryLimits();
     const outcomes = [];
-    for (const decision of result.started) {
+    const skipped = [];
+    let inspected = Number(result.inspected) || 0;
+    async function spawnClaimed(decision) {
       const task = decision.task;
       const harnessContext = readHarnessWorkerContext(decision);
       const taskId = String(task.id);
+      if (exactTargetMode && !exactTargetIds.has(taskId)) {
+        const releaseUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(taskId)}/release`;
+        let release;
+        try {
+          release = await postJsonWithCredentialRefresh(
+            releaseUrl,
+            secret,
+            {
+              agentOsId,
+              leaseOwner,
+              reason: `exact target dispatch mismatch: requested ${[...exactTargetIds].join(",")} but dispatch-next returned ${taskId}`
+            },
+            { agentOsId, baseUrl: base }
+          );
+        } catch (relErr) {
+          release = { ok: false, error: relErr.message };
+        }
+        outcomes.push({
+          taskId,
+          started: false,
+          error: "exact_target_mismatch: dispatch-next returned a different task than requested",
+          requestedTargetTaskIds: [...exactTargetIds],
+          released: release.ok === true || release.response?.ok === true,
+          releaseResponse: release.response ?? release
+        });
+        return false;
+      }
       const expectedPersona = normalizePersonaSlug2(task.personaSlug);
       if (expectedPersona && (!harnessContext?.personaInjectionReady || !harnessContext.personaMarkdown)) {
         outcomes.push({
@@ -5017,7 +6011,7 @@ async function dispatchRun(args) {
           started: false,
           error: `persona_injection_required: missing anchored context-envelope persona block for "${expectedPersona}"`
         });
-        continue;
+        return false;
       }
       if (hasLiveWorkerForTask(run.id, taskId)) {
         outcomes.push({
@@ -5025,16 +6019,16 @@ async function dispatchRun(args) {
           started: false,
           error: "duplicate_dispatch_prevented: live local worker already owns this task"
         });
-        continue;
+        return false;
       }
       const attempt = Number(task.attempt) || 1;
-      if (attempt > retryLimits.maxTaskAttempts) {
+      if (attempt >= retryLimits.maxTaskAttempts) {
         outcomes.push({
           taskId: task.id,
           started: false,
           error: `task attempt ${attempt} exceeds KYNVER_MAX_TASK_ATTEMPTS (${retryLimits.maxTaskAttempts})`
         });
-        continue;
+        return false;
       }
       const name = safeSlug(`t-${task.id}-a${task.attempt}`);
       const routing = resolveWorkerLaunch({
@@ -5078,6 +6072,7 @@ async function dispatchRun(args) {
           personaSlug: harnessContext?.personaSlug ?? expectedPersona,
           personaEvidence: harnessContext?.personaEvidence ?? null,
           leaseOwner,
+          leaseToken: task.leaseToken ? String(task.leaseToken) : void 0,
           dispatched: true
         });
         outcomes.push({
@@ -5104,6 +6099,7 @@ async function dispatchRun(args) {
             `[dispatch] task ${taskId}: persona context injected slug=${harnessContext.personaSlug}`
           );
         }
+        return true;
       } catch (error) {
         const releaseUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(String(task.id))}/release`;
         let release;
@@ -5119,6 +6115,35 @@ async function dispatchRun(args) {
           released: release.ok === true || release.response?.ok === true,
           releaseResponse: release.response ?? release
         });
+        return false;
+      }
+    }
+    let shouldContinueDispatch = true;
+    for (const decision of result.started) {
+      shouldContinueDispatch = await spawnClaimed(decision) && shouldContinueDispatch;
+    }
+    skipped.push(...result.skipped ?? []);
+    if (exactTargetMode) shouldContinueDispatch = false;
+    while (shouldContinueDispatch && outcomes.length < cappedStarts) {
+      if (exactTargetMode) break;
+      const next = await requestDispatch(1);
+      if (!next.dispatch.ok || !next.result) {
+        outcomes.push({
+          started: false,
+          error: "dispatch_next request failed during top-up",
+          httpStatus: next.dispatch.status,
+          response: next.dispatch.response
+        });
+        break;
+      }
+      inspected += Number(next.result.inspected) || 0;
+      skipped.push(...next.result.skipped ?? []);
+      const started = next.result.started ?? [];
+      if (started.length === 0) break;
+      for (const decision of started) {
+        if (outcomes.length >= cappedStarts) break;
+        shouldContinueDispatch = await spawnClaimed(decision) && shouldContinueDispatch;
+        if (!shouldContinueDispatch) break;
       }
     }
     const summary = {
@@ -5128,10 +6153,11 @@ async function dispatchRun(args) {
       leaseOwner,
       startedCount: outcomes.filter((o) => o.started).length,
       outcomes,
-      skipped: result.skipped.map((d) => ({
+      skipped: skipped.map((d) => ({
         taskId: d.task.id,
         skipReason: d.skipReason
       })),
+      inspected,
       diskGate: result.diskGate,
       resourceGate: result.resourceGate
     };
@@ -5148,7 +6174,7 @@ async function dispatchRun(args) {
 }
 
 // src/sweep.ts
-import path19 from "node:path";
+import path24 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -5156,18 +6182,23 @@ async function sweepRun(args) {
     const agentOsId = String(required(String(args.agentOsId || ""), "--agent-os-id"));
     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 leaseOwner = `kynver-harness:${run.id}`;
+    const runnerId = resolveRunnerPresencePayload({ runId: run.id }).runnerId;
     const snapshotPublished = await publishHarnessBoardSnapshot({ run: run.id, agentOsId, ...args }, "run_sweep");
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path19.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path24.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
       const status = computeWorkerStatus(worker);
       if (status.alive) continue;
       if (status.finalResult || worker.completionReportedAt) continue;
+      const leaseOwner = resolveHarnessLeaseOwnerForRenewal({
+        runId: run.id,
+        workerLeaseOwner: worker.leaseOwner ?? null,
+        runnerId
+      });
       const releaseUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(String(worker.taskId))}/release`;
       let release;
       try {
@@ -5193,7 +6224,7 @@ async function sweepRun(args) {
     } catch (reapErr) {
       reap = { ok: false, error: reapErr.message };
     }
-    const summary = { runId: run.id, agentOsId, leaseOwner, snapshotPublished, releasedLocalOrphans, reap: reap.response ?? reap };
+    const summary = { runId: run.id, agentOsId, snapshotPublished, releasedLocalOrphans, reap: reap.response ?? reap };
     if (pipeline) return { ok: true, ...summary };
     console.log(JSON.stringify(summary, null, 2));
   } catch (error) {
@@ -5204,18 +6235,18 @@ async function sweepRun(args) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync5 } from "node:fs";
-import path25 from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync5 } from "node:fs";
+import path32 from "node:path";
 
 // src/run-list.ts
-import { existsSync as existsSync15, readFileSync as readFileSync9 } from "node:fs";
-import path22 from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync10 } from "node:fs";
+import path29 from "node:path";
 
 // src/stale-reconcile.ts
-import path21 from "node:path";
+import path28 from "node:path";
 
 // src/finalize.ts
-import path20 from "node:path";
+import path25 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set([
   "running",
   "dispatching",
@@ -5233,7 +6264,7 @@ function deriveTerminalRunStatus(run) {
   let anyLandingBlocked = false;
   for (const name of names) {
     const worker = readJson(
-      path20.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path25.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) continue;
@@ -5272,20 +6303,346 @@ function finalizeStaleRuns() {
   return finalized;
 }
 
+// src/worker-metadata-reconcile.ts
+import { existsSync as existsSync21, lstatSync, readdirSync as readdirSync5, readlinkSync, renameSync as renameSync2, rmSync } from "node:fs";
+import path27 from "node:path";
+
+// src/worker-metadata-paths.ts
+import path26 from "node:path";
+var NESTED_RUNS = `${path26.sep}runs${path26.sep}runs${path26.sep}`;
+function hasNestedRunsSegment(filePath) {
+  return filePath.includes(NESTED_RUNS);
+}
+function canonicalRunDir(harnessRoot, runId) {
+  return path26.join(harnessRunsDir(normalizeHarnessRoot(harnessRoot)), safeSlug(runId));
+}
+function canonicalWorkerDir(harnessRoot, runId, workerName) {
+  return path26.join(canonicalRunDir(harnessRoot, runId), "workers", safeSlug(workerName));
+}
+function legacyNestedWorkerDir(harnessRoot, runId, workerName) {
+  const root = normalizeHarnessRoot(harnessRoot);
+  return path26.join(root, "runs", "runs", safeSlug(runId), "workers", safeSlug(workerName));
+}
+function workerArtifactFileNames() {
+  return [
+    "stdout.jsonl",
+    "stderr.log",
+    "heartbeat.jsonl",
+    "last-status.json",
+    "auto-complete.log",
+    "worker.json"
+  ];
+}
+function workerArtifactPaths(workerDir) {
+  return {
+    workerJsonPath: path26.join(workerDir, "worker.json"),
+    stdoutPath: path26.join(workerDir, "stdout.jsonl"),
+    stderrPath: path26.join(workerDir, "stderr.log"),
+    heartbeatPath: path26.join(workerDir, "heartbeat.jsonl"),
+    lastStatusPath: path26.join(workerDir, "last-status.json")
+  };
+}
+function resolveWorkerJsonPath(input) {
+  const canonical = workerArtifactPaths(canonicalWorkerDir(input.harnessRoot, input.runId, input.workerName)).workerJsonPath;
+  if (input.statusPath && !hasNestedRunsSegment(input.statusPath)) {
+    return input.statusPath;
+  }
+  return canonical;
+}
+
+// src/worker-metadata-reconcile.ts
+function materializeSymlinkedRunDir(harnessRoot, runId) {
+  const canonical = canonicalRunDir(harnessRoot, runId);
+  let stat;
+  try {
+    stat = lstatSync(canonical);
+  } catch {
+    return null;
+  }
+  if (!stat.isSymbolicLink()) return null;
+  const linkedTarget = path27.resolve(path27.dirname(canonical), readlinkSync(canonical));
+  const staging = `${canonical}.materialize-${Date.now()}`;
+  renameSync2(linkedTarget, staging);
+  rmSync(canonical);
+  renameSync2(staging, canonical);
+  return linkedTarget;
+}
+function relocateArtifacts(input) {
+  const moved = [];
+  for (const fileName of workerArtifactFileNames()) {
+    const from = path27.join(input.fromDir, fileName);
+    const to = path27.join(input.toDir, fileName);
+    if (!existsSync21(from) || existsSync21(to)) continue;
+    renameSync2(from, to);
+    moved.push(fileName);
+  }
+  return moved;
+}
+function repairWorkerPathFields(worker, canonicalDir) {
+  const artifacts = workerArtifactPaths(canonicalDir);
+  let changed = false;
+  if (worker.workerDir !== canonicalDir) {
+    worker.workerDir = canonicalDir;
+    changed = true;
+  }
+  if (worker.stdoutPath !== artifacts.stdoutPath) {
+    worker.stdoutPath = artifacts.stdoutPath;
+    changed = true;
+  }
+  if (worker.stderrPath !== artifacts.stderrPath) {
+    worker.stderrPath = artifacts.stderrPath;
+    changed = true;
+  }
+  if (worker.heartbeatPath !== artifacts.heartbeatPath) {
+    worker.heartbeatPath = artifacts.heartbeatPath;
+    changed = true;
+  }
+  return changed;
+}
+function deriveSynthesizedStatus(input) {
+  const statusFromLast = typeof input.lastStatus?.status === "string" ? input.lastStatus.status : void 0;
+  const attentionState = input.lastStatus?.attention && typeof input.lastStatus.attention === "object" ? input.lastStatus.attention.state : void 0;
+  if (statusFromLast === "done" || attentionState === "done") return "done";
+  if (input.stdoutFinalResult || input.heartbeatFinalResult) return "done";
+  if (statusFromLast === "blocked") return "blocked";
+  if (statusFromLast === "running") return "exited";
+  return statusFromLast ?? "exited";
+}
+function synthesizeWorkerFromArtifacts(input) {
+  const artifacts = workerArtifactPaths(input.canonicalDir);
+  const lastStatus = readJson(artifacts.lastStatusPath, void 0);
+  const stdoutExists = existsSync21(artifacts.stdoutPath);
+  const heartbeatExists = existsSync21(artifacts.heartbeatPath);
+  const hasArtifacts = stdoutExists || heartbeatExists || lastStatus != null;
+  if (!hasArtifacts) return null;
+  const parsedStdout = stdoutExists ? parseHarnessStream(artifacts.stdoutPath) : { finalResult: null };
+  const heartbeat = heartbeatExists ? parseHeartbeat(artifacts.heartbeatPath) : parseHeartbeat("");
+  const heartbeatFinalResult = terminalFinalResultFromHeartbeat(heartbeat);
+  const status = deriveSynthesizedStatus({
+    lastStatus,
+    stdoutFinalResult: parsedStdout.finalResult,
+    heartbeatFinalResult
+  });
+  const worker = {
+    name: input.workerName,
+    runId: input.run.id,
+    status,
+    branch: typeof lastStatus?.branch === "string" ? lastStatus.branch : `agent/${input.run.id}/${input.workerName}`,
+    worktreePath: typeof lastStatus?.worktreePath === "string" ? lastStatus.worktreePath : path27.join(getPaths().worktreesDir, input.run.id, input.workerName),
+    workerDir: input.canonicalDir,
+    stdoutPath: artifacts.stdoutPath,
+    stderrPath: artifacts.stderrPath,
+    heartbeatPath: artifacts.heartbeatPath,
+    startedAt: typeof lastStatus?.startedAt === "string" ? lastStatus.startedAt : input.run.createdAt,
+    reconciledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reconcileReason: "synthesized worker.json from on-disk artifacts after metadata repair"
+  };
+  if (typeof lastStatus?.taskId === "string") worker.taskId = lastStatus.taskId;
+  if (typeof lastStatus?.agentOsId === "string") worker.agentOsId = lastStatus.agentOsId;
+  if (typeof lastStatus?.planId === "string") worker.planId = lastStatus.planId;
+  if (typeof lastStatus?.pid === "number") worker.pid = lastStatus.pid;
+  if (parsedStdout.finalResult || heartbeatFinalResult) {
+    worker.completionSnapshot = {
+      finalResult: parsedStdout.finalResult ?? heartbeatFinalResult ?? "completed",
+      summary: heartbeat.lastHeartbeatSummary
+    };
+  }
+  repairWorkerPathFields(worker, input.canonicalDir);
+  return worker;
+}
+function repairRunWorkerIndex(run, harnessRoot) {
+  let changed = false;
+  const nextWorkers = { ...run.workers || {} };
+  for (const [name, ref] of Object.entries(nextWorkers)) {
+    const canonicalDir = canonicalWorkerDir(harnessRoot, run.id, name);
+    const canonicalStatus = path27.join(canonicalDir, "worker.json");
+    const nested = hasNestedRunsSegment(ref.workerDir) || hasNestedRunsSegment(ref.statusPath) || ref.workerDir !== canonicalDir || ref.statusPath !== canonicalStatus;
+    if (!nested) continue;
+    nextWorkers[name] = { workerDir: canonicalDir, statusPath: canonicalStatus };
+    changed = true;
+  }
+  if (changed) {
+    run.workers = nextWorkers;
+    saveRun(run);
+  }
+  return changed;
+}
+function reconcileOneWorker(input) {
+  const outcomes = [];
+  const canonicalDir = canonicalWorkerDir(input.harnessRoot, input.run.id, input.workerName);
+  const legacyDir = legacyNestedWorkerDir(input.harnessRoot, input.run.id, input.workerName);
+  const canonicalArtifacts = workerArtifactPaths(canonicalDir);
+  const moved = relocateArtifacts({ fromDir: legacyDir, toDir: canonicalDir });
+  if (moved.length > 0) {
+    outcomes.push({
+      runId: input.run.id,
+      worker: input.workerName,
+      action: "relocated_artifacts",
+      reason: `moved ${moved.join(", ")} from nested runs/runs layout`
+    });
+  }
+  const workerJsonPath = resolveWorkerJsonPath({
+    harnessRoot: input.harnessRoot,
+    runId: input.run.id,
+    workerName: input.workerName,
+    statusPath: input.statusPath
+  });
+  let worker = readJson(workerJsonPath, void 0);
+  if (!worker && existsSync21(canonicalArtifacts.workerJsonPath)) {
+    worker = readJson(canonicalArtifacts.workerJsonPath, void 0);
+  }
+  if (!worker) {
+    const synthesized = synthesizeWorkerFromArtifacts({
+      run: input.run,
+      workerName: input.workerName,
+      canonicalDir,
+      harnessRoot: input.harnessRoot
+    });
+    if (synthesized) {
+      saveWorker(input.run.id, synthesized);
+      outcomes.push({
+        runId: input.run.id,
+        worker: input.workerName,
+        action: "synthesized_worker_json",
+        reason: synthesized.reconcileReason ?? "synthesized from artifacts"
+      });
+      return outcomes;
+    }
+    const dirExists = existsSync21(canonicalDir);
+    const hasAnyArtifact = workerArtifactFileNames().some((f) => existsSync21(path27.join(canonicalDir, f)));
+    if (dirExists && !hasAnyArtifact) {
+      const abandoned = {
+        name: input.workerName,
+        runId: input.run.id,
+        status: "exited",
+        branch: `agent/${input.run.id}/${input.workerName}`,
+        worktreePath: path27.join(getPaths().worktreesDir, input.run.id, input.workerName),
+        workerDir: canonicalDir,
+        stdoutPath: canonicalArtifacts.stdoutPath,
+        stderrPath: canonicalArtifacts.stderrPath,
+        heartbeatPath: canonicalArtifacts.heartbeatPath,
+        startedAt: input.run.createdAt,
+        reconciledAt: (/* @__PURE__ */ new Date()).toISOString(),
+        reconcileReason: "empty worker dir \u2014 marked abandoned during metadata reconcile"
+      };
+      saveWorker(input.run.id, abandoned);
+      outcomes.push({
+        runId: input.run.id,
+        worker: input.workerName,
+        action: "marked_abandoned",
+        reason: abandoned.reconcileReason ?? "empty worker dir"
+      });
+      return outcomes;
+    }
+    outcomes.push({
+      runId: input.run.id,
+      worker: input.workerName,
+      action: "skipped",
+      reason: "worker.json missing and no recoverable artifacts"
+    });
+    return outcomes;
+  }
+  if (repairWorkerPathFields(worker, canonicalDir)) {
+    worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+    worker.reconcileReason = worker.reconcileReason ?? "repaired nested runs/runs path fields";
+    saveWorker(input.run.id, worker);
+    outcomes.push({
+      runId: input.run.id,
+      worker: input.workerName,
+      action: "repaired_worker_paths",
+      reason: worker.reconcileReason
+    });
+  } else {
+    outcomes.push({
+      runId: input.run.id,
+      worker: input.workerName,
+      action: "skipped",
+      reason: "worker metadata already canonical"
+    });
+  }
+  return outcomes;
+}
+function listOrphanWorkerNames(run, harnessRoot) {
+  const workersDir = path27.join(runDirectory(run.id), "workers");
+  if (!existsSync21(workersDir)) return [];
+  const indexed = new Set(Object.keys(run.workers || {}));
+  const orphans = [];
+  for (const entry of readdirSync5(workersDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if (indexed.has(entry.name)) continue;
+    orphans.push(entry.name);
+  }
+  return orphans;
+}
+function reconcileWorkerMetadata() {
+  const { harnessRoot } = getPaths();
+  const outcomes = [];
+  for (const run of listRunRecords()) {
+    const materializedFrom = materializeSymlinkedRunDir(harnessRoot, run.id);
+    if (materializedFrom) {
+      outcomes.push({
+        runId: run.id,
+        worker: "*",
+        action: "materialized_run_symlink",
+        reason: `replaced symlink with real run dir (was ${materializedFrom})`
+      });
+    }
+    if (repairRunWorkerIndex(run, harnessRoot)) {
+      outcomes.push({
+        runId: run.id,
+        worker: "*",
+        action: "repaired_run_index",
+        reason: "repaired nested runs/runs workerDir/statusPath entries in run.json"
+      });
+    }
+    const workerNames = new Set(Object.keys(run.workers || {}));
+    for (const orphan of listOrphanWorkerNames(run, harnessRoot)) {
+      workerNames.add(orphan);
+      run.workers = {
+        ...run.workers || {},
+        [orphan]: {
+          workerDir: canonicalWorkerDir(harnessRoot, run.id, orphan),
+          statusPath: path27.join(canonicalWorkerDir(harnessRoot, run.id, orphan), "worker.json")
+        }
+      };
+      saveRun(run);
+      outcomes.push({
+        runId: run.id,
+        worker: orphan,
+        action: "repaired_run_index",
+        reason: "indexed orphan worker dir into run.json"
+      });
+    }
+    for (const name of workerNames) {
+      const ref = run.workers?.[name];
+      outcomes.push(
+        ...reconcileOneWorker({
+          run,
+          workerName: name,
+          harnessRoot,
+          statusPath: ref?.statusPath
+        })
+      );
+    }
+  }
+  return { workers: outcomes };
+}
+
 // src/stale-reconcile.ts
 var STALE_RECONCILE_HEARTBEAT_MS = 15 * 60 * 1e3;
 function staleReconcileDisabled() {
   return process.env.KYNVER_NO_STALE_CLEANUP === "1";
 }
 function reconcileStaleWorkers() {
+  const metadataReconcile = reconcileWorkerMetadata();
   if (staleReconcileDisabled()) {
-    return { workers: [], finalizedRuns: finalizeStaleRuns() };
+    return { workers: [], finalizedRuns: finalizeStaleRuns(), metadataReconcile };
   }
   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 workerPath = path28.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker || worker.status !== "running") {
         outcomes.push({
@@ -5357,20 +6714,29 @@ function reconcileStaleWorkers() {
       });
     }
   }
-  return { workers: outcomes, finalizedRuns: finalizeStaleRuns() };
+  return { workers: outcomes, finalizedRuns: finalizeStaleRuns(), metadataReconcile };
 }
 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;
+  const metadataTotals = result.metadataReconcile.workers.reduce((acc, row) => {
+    acc[row.action] = (acc[row.action] ?? 0) + 1;
+    return acc;
+  }, {});
   console.log(
     JSON.stringify(
       {
         ok: true,
         workers: { markedExited, killedStale, skipped, total: result.workers.length },
+        metadataReconcile: { totals: metadataTotals, total: result.metadataReconcile.workers.length },
         finalizedRuns: result.finalizedRuns.length,
-        details: { workers: result.workers, finalizedRuns: result.finalizedRuns }
+        details: {
+          workers: result.workers,
+          metadataReconcile: result.metadataReconcile.workers,
+          finalizedRuns: result.finalizedRuns
+        }
       },
       null,
       2
@@ -5380,15 +6746,15 @@ function reconcileRunsCli() {
 
 // src/run-list.ts
 function heartbeatByteLength(heartbeatPath) {
-  if (!heartbeatPath || !existsSync15(heartbeatPath)) return 0;
+  if (!heartbeatPath || !existsSync22(heartbeatPath)) return 0;
   try {
-    return readFileSync9(heartbeatPath, "utf8").trim().length;
+    return readFileSync10(heartbeatPath, "utf8").trim().length;
   } catch {
     return 0;
   }
 }
 function workerEvidence(run, workerName) {
-  const workerPath = path22.join(runDirectory(run.id), "workers", safeSlug(workerName), "worker.json");
+  const workerPath = path29.join(runDirectory(run.id), "workers", safeSlug(workerName), "worker.json");
   const worker = readJson(workerPath, void 0);
   if (!worker) {
     return {
@@ -5445,7 +6811,7 @@ function aggregateRunAttention(workers) {
 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 workerPath = path29.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 });
@@ -5494,9 +6860,9 @@ function listRunsCli() {
 }
 
 // src/default-repo.ts
-import path23 from "node:path";
+import path30 from "node:path";
 function expandConfiguredRepo(value) {
-  return path23.resolve(resolveUserPath(value.trim()));
+  return path30.resolve(resolveUserPath(value.trim()));
 }
 function fromConfigured(value, source, persistedInConfig) {
   const trimmed = value?.trim();
@@ -5536,7 +6902,7 @@ function formatResolvedDefaultRepo(resolved) {
 }
 
 // src/validate.ts
-import path24 from "node:path";
+import path31 from "node:path";
 var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 function validateRunId(runId) {
   const trimmed = runId.trim();
@@ -5544,7 +6910,7 @@ function validateRunId(runId) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path24.resolve(repo);
+  const resolved = path31.resolve(repo);
   if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
   return resolved;
 }
@@ -5563,7 +6929,7 @@ function createRun(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}`);
+  if (existsSync23(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();
@@ -5577,7 +6943,7 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path25.join(dir, "run.json"), run);
+  writeJson(path32.join(dir, "run.json"), run);
   console.log(JSON.stringify({ runId: id, runDir: dir, repo, base, baseCommit }, null, 2));
 }
 function listRuns() {
@@ -5589,8 +6955,8 @@ function failExists(message) {
 }
 
 // src/discard-disposable.ts
-import { existsSync as existsSync17, rmSync } from "node:fs";
-import path26 from "node:path";
+import { existsSync as existsSync24, rmSync as rmSync2 } from "node:fs";
+import path33 from "node:path";
 function normalizeRelativePath2(value) {
   const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").trim();
   if (!normalized || normalized.startsWith("/") || normalized.includes("..")) {
@@ -5611,18 +6977,18 @@ function discardDisposableArtifacts(args) {
   if (paths.length === 0) {
     return { ok: false, removed: [], reason: "requires at least one --path" };
   }
-  const worktreeRoot = path26.resolve(worker.worktreePath);
+  const worktreeRoot = path33.resolve(worker.worktreePath);
   const removed = [];
   for (const raw of paths) {
     const rel = normalizeRelativePath2(raw);
-    const abs = path26.resolve(worktreeRoot, rel);
-    if (!abs.startsWith(worktreeRoot + path26.sep) && abs !== worktreeRoot) {
+    const abs = path33.resolve(worktreeRoot, rel);
+    if (!abs.startsWith(worktreeRoot + path33.sep) && abs !== worktreeRoot) {
       return { ok: false, removed, reason: `path escapes worktree: ${raw}` };
     }
-    if (!existsSync17(abs)) {
+    if (!existsSync24(abs)) {
       return { ok: false, removed, reason: `path not found: ${raw}` };
     }
-    rmSync(abs, { recursive: true, force: true });
+    rmSync2(abs, { recursive: true, force: true });
     removed.push(rel);
   }
   const prior = Array.isArray(worker.disposableArtifactsRemoved) ? worker.disposableArtifactsRemoved.filter((p) => typeof p === "string") : [];
@@ -5642,7 +7008,7 @@ function discardDisposableCli(args) {
 }
 
 // src/pipeline-tick.ts
-import path41 from "node:path";
+import path49 from "node:path";
 
 // src/pipeline-dispatch.ts
 var RESERVED_REVIEW_STARTS = 1;
@@ -5663,6 +7029,19 @@ async function runPipelineDispatch(args, slots) {
     return { ok: true, skipped: true, reason: "no slots", maxStarts: 0, startedCount: 0 };
   }
   const base = stripCliMaxStarts(args);
+  if (base.targetTaskId || base.targetTaskIds) {
+    const target = await dispatchRun({
+      ...base,
+      execute: true,
+      pipeline: true,
+      maxStarts: String(slots)
+    });
+    return {
+      ...typeof target === "object" && target !== null ? target : {},
+      passes: { target },
+      startedCount: countDispatchStarts(target)
+    };
+  }
   const reviewBudget = Math.min(slots, RESERVED_REVIEW_STARTS);
   const workBudget = Math.max(0, slots - reviewBudget);
   const review = await dispatchRun({
@@ -5762,7 +7141,7 @@ function buildBoxResourceSnapshotFromGate(gate, input = {}) {
 }
 
 // src/plan-progress-daemon-sync.ts
-import path27 from "node:path";
+import path34 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -5786,7 +7165,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path27.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path34.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -5835,10 +7214,10 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 }
 
 // src/cleanup.ts
-import path39 from "node:path";
+import path47 from "node:path";
 
 // src/cleanup-guards.ts
-import path28 from "node:path";
+import path35 from "node:path";
 
 // src/cleanup-run-liveness.ts
 function isWorkerProcessLive(indexed) {
@@ -5902,72 +7281,217 @@ function prUrlFromFinalResult(finalResult) {
   return null;
 }
 function isPrOrUnmergedWork(status) {
-  if (prUrlFromFinalResult(status.finalResult)) return true;
   const relation = status.gitAncestry?.relation;
+  if (relation === "merged" || relation === "synced") {
+    return materialWorktreeChanges2(status.changedFiles).length > 0;
+  }
+  if (prUrlFromFinalResult(status.finalResult)) return true;
   if (relation === "ahead" || relation === "diverged") return true;
   if (status.changedFiles.length > 0 && status.finalResult) return true;
   return false;
 }
-function hasUnrestorableWorktreeChanges(status) {
-  if (materialWorktreeChanges2(status.changedFiles).length > 0) return true;
-  if (status.gitAncestry?.relation === "diverged") return true;
-  return false;
+function hasUnrestorableWorktreeChanges(status) {
+  if (materialWorktreeChanges2(status.changedFiles).length > 0) return true;
+  if (status.gitAncestry?.relation === "diverged") return true;
+  return false;
+}
+function effectiveWorktreeAgeMs(input) {
+  const { indexed, includeOrphans, worktreesAgeMs, terminalWorktreesAgeMs } = input;
+  if (!indexed) return includeOrphans ? terminalWorktreesAgeMs : worktreesAgeMs;
+  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) {
+    return terminalWorktreesAgeMs;
+  }
+  return worktreesAgeMs;
+}
+function skipWorktreeRemoval(input) {
+  const { indexed, includeOrphans, worktreesAgeMs, ageMs, orphanSafety, worktreeRemovalGuard } = input;
+  if (!indexed) {
+    if (!includeOrphans) return "orphan_without_flag";
+    return orphanSafety ?? null;
+  }
+  const ageThresholdMs = effectiveWorktreeAgeMs(input);
+  if (worktreesAgeMs <= 0 && !includeOrphans && ageThresholdMs <= 0) return "worktrees_disabled";
+  if (ageThresholdMs > 0 && ageMs < ageThresholdMs) return "below_age_threshold";
+  if (isWorkerProcessLive(indexed)) return "active_worker";
+  if (indexed.worker.completionBlocker) return "completion_blocked";
+  if (runBlocksWorktreeRemoval(indexed)) return "run_still_active";
+  if (!isFinishedWorkerStatus(indexed.status)) return "run_still_active";
+  if (isPrOrUnmergedWork(indexed.status)) return "pr_or_unmerged_commits";
+  if (materialWorktreeChanges2(indexed.status.changedFiles).length > 0) 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) return "landing_blocked";
+  if (worktreeRemovalGuard && input.worktreePath) {
+    const overlay = worktreeRemovalGuard({
+      worktreePath: input.worktreePath,
+      indexed: Boolean(indexed),
+      runId: indexed?.runId,
+      worker: indexed?.workerName
+    });
+    if (overlay) {
+      return overlay.detail ? { reason: overlay.reason, detail: overlay.detail } : overlay.reason;
+    }
+  }
+  return null;
+}
+function skipDependencyCacheRemoval(input) {
+  const { indexed, nodeModulesAgeMs, ageMs, worktreePath, activeWorktreePaths, diskPressure } = input;
+  if (!diskPressure && ageMs < nodeModulesAgeMs) return "below_age_threshold";
+  if (activeWorktreePaths.has(path35.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-types.ts
+var DEFAULT_NODE_MODULES_AGE_MS = 6 * 60 * 60 * 1e3;
+var DEFAULT_WORKTREES_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_TERMINAL_WORKTREES_AGE_MS = DEFAULT_NODE_MODULES_AGE_MS;
+var DEFAULT_RUN_DIRECTORIES_AGE_MS = 60 * 60 * 1e3;
+var DEFAULT_MAX_ACTIONS_PER_SWEEP = 120;
+var MAX_PRESERVED_LIVE_PATH_SAMPLES = 24;
+
+// src/cleanup-evidence.ts
+var LIVE_SKIP_REASONS = /* @__PURE__ */ new Set([
+  "active_worker",
+  "run_still_active",
+  "completion_blocked",
+  "landing_blocked"
+]);
+function collectPreservedLivePaths(actions, skips) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (path59, reason, detail) => {
+    const key = `${path59}\0${reason}`;
+    if (seen.has(key) || out.length >= MAX_PRESERVED_LIVE_PATH_SAMPLES) return;
+    seen.add(key);
+    out.push({ path: path59, reason, ...detail ? { detail } : {} });
+  };
+  for (const skip2 of skips) {
+    if (!LIVE_SKIP_REASONS.has(skip2.reason)) continue;
+    push(skip2.path, skip2.reason, skip2.detail);
+  }
+  for (const action of actions) {
+    if (!action.skipped || !action.skipReason) continue;
+    if (!LIVE_SKIP_REASONS.has(action.skipReason)) continue;
+    push(action.path, action.skipReason);
+  }
+  return out;
+}
+
+// src/cleanup-run-directory.ts
+import { existsSync as existsSync25, readdirSync as readdirSync6, statSync as statSync4 } from "node:fs";
+import path37 from "node:path";
+
+// src/cleanup-active-worktrees.ts
+import path36 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(
+          path36.join(runDirectoryAt(harnessRoot, run.id), "workers", safeSlug(name), "worker.json"),
+          void 0
+        );
+        if (!worker?.worktreePath) continue;
+        const worktreePath = path36.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 };
+}
+function isWorktreeOnLiveRun(worktreePath, harnessRoot, runId, liveRunKeys) {
+  if (!runId) return false;
+  return liveRunKeys.has(`${harnessRoot}\0${runId}`);
 }
-function skipWorktreeRemoval(input) {
-  const { indexed, includeOrphans, worktreesAgeMs, ageMs, orphanSafety, worktreeRemovalGuard } = input;
-  if (!indexed) {
-    if (!includeOrphans) return "orphan_without_flag";
-    return orphanSafety ?? null;
+
+// src/cleanup-run-directory.ts
+function pathAgeMs(target, now) {
+  try {
+    const mtime = statSync4(target).mtimeMs;
+    return Math.max(0, now - mtime);
+  } catch {
+    return 0;
   }
-  if (worktreesAgeMs <= 0 && !includeOrphans) return "worktrees_disabled";
-  if (worktreesAgeMs > 0 && ageMs < worktreesAgeMs) return "below_age_threshold";
-  if (isWorkerProcessLive(indexed)) return "active_worker";
-  if (indexed.worker.completionBlocker) return "completion_blocked";
-  if (runBlocksWorktreeRemoval(indexed)) return "run_still_active";
-  if (!isFinishedWorkerStatus(indexed.status)) return "run_still_active";
-  if (isPrOrUnmergedWork(indexed.status)) return "pr_or_unmerged_commits";
-  if (materialWorktreeChanges2(indexed.status.changedFiles).length > 0) 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) return "landing_blocked";
-  if (worktreeRemovalGuard && input.worktreePath) {
-    const overlay = worktreeRemovalGuard({
-      worktreePath: input.worktreePath,
-      indexed: Boolean(indexed),
-      runId: indexed?.runId,
-      worker: indexed?.workerName
-    });
-    if (overlay) {
-      return overlay.detail ? { reason: overlay.reason, detail: overlay.detail } : overlay.reason;
-    }
+}
+function loadRunStatus(harnessRoot, runId) {
+  const runPath = path37.join(harnessRoot, "runs", runId, "run.json");
+  if (!existsSync25(runPath)) return null;
+  return readJson(runPath, null);
+}
+function runDirectoryIsEmpty(runPath) {
+  try {
+    const entries = readdirSync6(runPath);
+    return entries.length === 0;
+  } catch {
+    return false;
   }
-  return null;
 }
-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";
+function skipRunDirectoryRemoval(input) {
+  const { harnessRoot, runId, runPath, ageMs, runDirectoriesAgeMs, activeGuards } = input;
+  if (isWorktreeOnLiveRun(runPath, harnessRoot, runId, activeGuards.liveRunKeys)) {
+    return "run_still_active";
+  }
+  if (!runDirectoryIsEmpty(runPath)) return "run_still_active";
+  const run = loadRunStatus(harnessRoot, runId);
+  if (run && !TERMINAL_RUN_STATUSES.has(run.status)) return "run_still_active";
+  if (runDirectoriesAgeMs > 0 && ageMs < runDirectoriesAgeMs) return "below_age_threshold";
   return null;
 }
-function skipBuildCacheRemoval(input) {
-  return skipDependencyCacheRemoval(input);
+function scanStaleRunDirectoryCandidates(opts) {
+  if (!existsSync25(opts.worktreesDir)) return [];
+  const candidates = [];
+  let entries;
+  try {
+    entries = readdirSync6(opts.worktreesDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const runEntry of entries) {
+    if (!runEntry.isDirectory()) continue;
+    const runId = runEntry.name;
+    if (opts.runIdFilter && runId !== opts.runIdFilter) continue;
+    const runPath = path37.join(opts.worktreesDir, runId);
+    if (!runDirectoryIsEmpty(runPath)) continue;
+    candidates.push({
+      kind: "remove_run_directory",
+      path: runPath,
+      bytes: null,
+      harnessRoot: opts.harnessRoot,
+      runId,
+      ageMs: pathAgeMs(runPath, opts.now)
+    });
+  }
+  return candidates;
 }
 
 // src/cleanup-execute.ts
-import { existsSync as existsSync19, rmSync as rmSync2 } from "node:fs";
-import path30 from "node:path";
+import { existsSync as existsSync27, rmSync as rmSync3 } from "node:fs";
+import path39 from "node:path";
 
 // src/cleanup-dir-size.ts
-import { existsSync as existsSync18, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
-import path29 from "node:path";
+import { existsSync as existsSync26, readdirSync as readdirSync7, statSync as statSync5 } from "node:fs";
+import path38 from "node:path";
 function directorySizeBytes(root, maxEntries = 5e4) {
-  if (!existsSync18(root)) return 0;
+  if (!existsSync26(root)) return 0;
   let total = 0;
   let seen = 0;
   const stack = [root];
@@ -5975,16 +7499,16 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     const current = stack.pop();
     let entries;
     try {
-      entries = readdirSync5(current);
+      entries = readdirSync7(current);
     } catch {
       continue;
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path29.join(current, name);
+      const full = path38.join(current, name);
       let st;
       try {
-        st = statSync2(full);
+        st = statSync5(full);
       } catch {
         continue;
       }
@@ -5997,7 +7521,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
 
 // src/cleanup-execute.ts
 function removeDependencyCache(candidate, execute) {
-  if (!existsSync19(candidate.path)) {
+  if (!existsSync27(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -6010,7 +7534,7 @@ function removeDependencyCache(candidate, execute) {
   }
   try {
     const bytesBefore = candidate.bytes ?? directorySizeBytes(candidate.path);
-    rmSync2(candidate.path, { recursive: true, force: true });
+    rmSync3(candidate.path, { recursive: true, force: true });
     return {
       ...candidate,
       bytes: bytesBefore,
@@ -6036,8 +7560,39 @@ function removeNextCache(candidate, execute) {
 function removeBuildCache(candidate, execute) {
   return removeDependencyCache(candidate, execute);
 }
+function removeRunDirectory(candidate, execute) {
+  if (!existsSync27(candidate.path)) {
+    return {
+      ...candidate,
+      executed: false,
+      skipped: true,
+      skipReason: "missing_worktree"
+    };
+  }
+  if (!execute) {
+    return { ...candidate, executed: false, skipped: true, skipReason: "dry_run" };
+  }
+  try {
+    const bytesBefore = candidate.bytes ?? directorySizeBytes(candidate.path);
+    rmSync3(candidate.path, { recursive: true, force: true });
+    return {
+      ...candidate,
+      bytes: bytesBefore,
+      executed: true,
+      skipped: false
+    };
+  } catch (error) {
+    return {
+      ...candidate,
+      executed: false,
+      skipped: true,
+      skipReason: "remove_failed",
+      error: error.message
+    };
+  }
+}
 function removeWorktree(candidate, execute) {
-  if (!existsSync19(candidate.path)) {
+  if (!existsSync27(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -6054,8 +7609,8 @@ function removeWorktree(candidate, execute) {
     if (repo) {
       git(repo, ["worktree", "remove", "--force", candidate.path], { allowFailure: true });
     }
-    if (existsSync19(candidate.path)) {
-      rmSync2(candidate.path, { recursive: true, force: true });
+    if (existsSync27(candidate.path)) {
+      rmSync3(candidate.path, { recursive: true, force: true });
     }
     return {
       ...candidate,
@@ -6074,15 +7629,15 @@ function removeWorktree(candidate, execute) {
   }
 }
 function isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, cacheDirName) {
-  const resolved = path30.resolve(targetPath);
-  const suffix = `${path30.sep}${cacheDirName}`;
+  const resolved = path39.resolve(targetPath);
+  const suffix = `${path39.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);
+  const rel = path39.relative(worktreesDir, cachePath);
+  if (rel.startsWith("..") || path39.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path39.sep);
   if (parts.length < 3 || parts[parts.length - 1] !== cacheDirName) return "path_outside_harness";
-  if (!resolved.startsWith(path30.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path39.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
@@ -6092,37 +7647,37 @@ 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);
+  const resolved = path39.resolve(targetPath);
+  const relToWt = path39.relative(worktreesDir, resolved);
+  if (relToWt.startsWith("..") || path39.isAbsolute(relToWt)) return "path_outside_harness";
+  const parts = relToWt.split(path39.sep);
   if (parts.length < 3) return "path_outside_harness";
-  if (!resolved.startsWith(path30.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path39.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 
 // src/cleanup-scan.ts
-import { existsSync as existsSync20, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
-import path31 from "node:path";
-function pathAgeMs(target, now) {
+import { existsSync as existsSync28, readdirSync as readdirSync8, statSync as statSync6 } from "node:fs";
+import path40 from "node:path";
+function pathAgeMs2(target, now) {
   try {
-    const mtime = statSync3(target).mtimeMs;
+    const mtime = statSync6(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
   }
 }
 function isPathInside(child, parent) {
-  const rel = path31.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path31.isAbsolute(rel);
+  const rel = path40.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path40.isAbsolute(rel);
 }
 function collectBuildCacheForWorktree(worktreePath, opts, seen, meta) {
   const out = [];
   for (const rel of HARNESS_BUILD_CACHE_RELATIVE_PATHS) {
     if (rel === ".next") continue;
-    const target = path31.join(worktreePath, rel);
-    if (!existsSync20(target)) continue;
-    const resolved = path31.resolve(target);
+    const target = path40.join(worktreePath, rel);
+    if (!existsSync28(target)) continue;
+    const resolved = path40.resolve(target);
     if (seen.has(resolved)) continue;
     if (!isPathInside(resolved, opts.harnessRoot)) continue;
     seen.add(resolved);
@@ -6133,7 +7688,7 @@ function collectBuildCacheForWorktree(worktreePath, opts, seen, meta) {
       runId: meta.runId,
       worker: meta.worker,
       repo: meta.repo,
-      ageMs: pathAgeMs(resolved, opts.now)
+      ageMs: pathAgeMs2(resolved, opts.now)
     });
   }
   return out;
@@ -6151,13 +7706,13 @@ function scanBuildCacheCandidates(opts) {
       })
     );
   }
-  if (!opts.includeOrphans || !existsSync20(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync6(opts.worktreesDir, { withFileTypes: true })) {
+  if (!opts.includeOrphans || !existsSync28(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync8(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path31.join(opts.worktreesDir, runEntry.name);
-    for (const workerEntry of readdirSync6(runPath, { withFileTypes: true })) {
+    const runPath = path40.join(opts.worktreesDir, runEntry.name);
+    for (const workerEntry of readdirSync8(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path31.join(runPath, workerEntry.name);
+      const worktreePath = path40.join(runPath, workerEntry.name);
       candidates.push(
         ...collectBuildCacheForWorktree(worktreePath, opts, seen, {
           runId: runEntry.name,
@@ -6178,7 +7733,7 @@ function scanWorktreeCandidates(opts) {
     for (const entry of opts.index.values()) {
       if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
       const resolved = entry.worktreePath;
-      if (!existsSync20(resolved)) continue;
+      if (!existsSync28(resolved)) continue;
       if (seen.has(resolved)) continue;
       seen.add(resolved);
       candidates.push({
@@ -6188,28 +7743,28 @@ function scanWorktreeCandidates(opts) {
         runId: entry.runId,
         worker: entry.workerName,
         repo: entry.run.repo,
-        ageMs: pathAgeMs(resolved, opts.now)
+        ageMs: pathAgeMs2(resolved, opts.now)
       });
     }
   }
-  if (!orphanEnabled || !existsSync20(opts.worktreesDir)) return candidates;
+  if (!orphanEnabled || !existsSync28(opts.worktreesDir)) return candidates;
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path31.resolve(entry.worktreePath));
+    indexedPaths.add(path40.resolve(entry.worktreePath));
   }
-  for (const runEntry of readdirSync6(opts.worktreesDir, { withFileTypes: true })) {
+  for (const runEntry of readdirSync8(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path31.join(opts.worktreesDir, runEntry.name);
+    const runPath = path40.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
-      workerEntries = readdirSync6(runPath, { withFileTypes: true });
+      workerEntries = readdirSync8(runPath, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path31.resolve(path31.join(runPath, workerEntry.name));
+      const worktreePath = path40.resolve(path40.join(runPath, workerEntry.name));
       if (seen.has(worktreePath)) continue;
       if (indexedPaths.has(worktreePath)) continue;
       if (!isPathInside(worktreePath, opts.harnessRoot)) continue;
@@ -6220,7 +7775,7 @@ function scanWorktreeCandidates(opts) {
         bytes: null,
         runId: runEntry.name,
         worker: workerEntry.name,
-        ageMs: pathAgeMs(worktreePath, opts.now)
+        ageMs: pathAgeMs2(worktreePath, opts.now)
       });
     }
   }
@@ -6228,27 +7783,27 @@ function scanWorktreeCandidates(opts) {
 }
 
 // src/cleanup-dependency-scan.ts
-import { existsSync as existsSync21, readdirSync as readdirSync7, statSync as statSync4 } from "node:fs";
-import path32 from "node:path";
+import { existsSync as existsSync29, readdirSync as readdirSync9, statSync as statSync7 } from "node:fs";
+import path41 from "node:path";
 var DEPENDENCY_CACHE_DIRS = [
   { dirName: "node_modules", kind: "remove_node_modules" },
   { dirName: ".next", kind: "remove_next_cache" }
 ];
-function pathAgeMs2(target, now) {
+function pathAgeMs3(target, now) {
   try {
-    const mtime = statSync4(target).mtimeMs;
+    const mtime = statSync7(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);
+  const rel = path41.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path41.isAbsolute(rel);
 }
 function pushCandidate2(candidates, seen, opts, targetPath, kind, meta) {
-  if (!existsSync21(targetPath)) return;
-  const resolved = path32.resolve(targetPath);
+  if (!existsSync29(targetPath)) return;
+  const resolved = path41.resolve(targetPath);
   if (seen.has(resolved)) return;
   if (!isPathInside2(resolved, opts.harnessRoot)) return;
   seen.add(resolved);
@@ -6260,12 +7815,12 @@ function pushCandidate2(candidates, seen, opts, targetPath, kind, meta) {
     runId: meta.runId,
     worker: meta.worker,
     repo: meta.repo,
-    ageMs: pathAgeMs2(resolved, opts.now)
+    ageMs: pathAgeMs3(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);
+    pushCandidate2(candidates, seen, opts, path41.join(worktreePath, entry.dirName), entry.kind, meta);
   }
 }
 function scanDependencyCacheCandidates(opts) {
@@ -6279,20 +7834,20 @@ function scanDependencyCacheCandidates(opts) {
       repo: entry.run.repo
     });
   }
-  if (!existsSync21(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync7(opts.worktreesDir, { withFileTypes: true })) {
+  if (!existsSync29(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync9(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path32.join(opts.worktreesDir, runEntry.name);
+    const runPath = path41.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
-      workerEntries = readdirSync7(runPath, { withFileTypes: true });
+      workerEntries = readdirSync9(runPath, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path32.join(runPath, workerEntry.name);
+      const worktreePath = path41.join(runPath, workerEntry.name);
       scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, {
         runId: runEntry.name,
         worker: workerEntry.name
@@ -6303,11 +7858,11 @@ function scanDependencyCacheCandidates(opts) {
 }
 
 // src/cleanup-duplicate-worktrees.ts
-import { existsSync as existsSync22, statSync as statSync5 } from "node:fs";
-import path33 from "node:path";
-function pathAgeMs3(target, now) {
+import { existsSync as existsSync30, statSync as statSync8 } from "node:fs";
+import path42 from "node:path";
+function pathAgeMs4(target, now) {
   try {
-    const mtime = statSync5(target).mtimeMs;
+    const mtime = statSync8(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
@@ -6334,8 +7889,8 @@ function parseWorktreePorcelain(output) {
   return records;
 }
 function isUnderWorktreesDir(worktreePath, worktreesDir) {
-  const rel = path33.relative(path33.resolve(worktreesDir), path33.resolve(worktreePath));
-  return rel !== "" && !rel.startsWith("..") && !path33.isAbsolute(rel);
+  const rel = path42.relative(path42.resolve(worktreesDir), path42.resolve(worktreePath));
+  return rel !== "" && !rel.startsWith("..") && !path42.isAbsolute(rel);
 }
 function isCleanWorktree(worktreePath, repoRoot) {
   try {
@@ -6348,14 +7903,14 @@ function isCleanWorktree(worktreePath, repoRoot) {
   }
 }
 function scanDuplicateWorktreeCandidates(opts) {
-  if (!opts.includeOrphans || !existsSync22(opts.worktreesDir)) return [];
+  if (!opts.includeOrphans || !existsSync30(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));
+    if (entry.run.repo) repos.add(path42.resolve(entry.run.repo));
   }
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path33.resolve(entry.worktreePath));
+    indexedPaths.add(path42.resolve(entry.worktreePath));
   }
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -6368,15 +7923,15 @@ function scanDuplicateWorktreeCandidates(opts) {
     }
     const worktrees = parseWorktreePorcelain(porcelain);
     for (const wt of worktrees) {
-      const resolved = path33.resolve(wt.path);
-      if (resolved === path33.resolve(repoRoot)) continue;
+      const resolved = path42.resolve(wt.path);
+      if (resolved === path42.resolve(repoRoot)) continue;
       if (!isUnderWorktreesDir(resolved, opts.worktreesDir)) continue;
       if (indexedPaths.has(resolved)) continue;
       if (seen.has(resolved)) continue;
-      if (!existsSync22(resolved)) continue;
+      if (!existsSync30(resolved)) continue;
       if (!isCleanWorktree(resolved, repoRoot)) continue;
-      const rel = path33.relative(opts.worktreesDir, resolved);
-      const parts = rel.split(path33.sep);
+      const rel = path42.relative(opts.worktreesDir, resolved);
+      const parts = rel.split(path42.sep);
       const runId = parts[0];
       const worker = parts[1] ?? "unknown";
       seen.add(resolved);
@@ -6387,7 +7942,7 @@ function scanDuplicateWorktreeCandidates(opts) {
         runId,
         worker,
         repo: repoRoot,
-        ageMs: pathAgeMs3(resolved, opts.now)
+        ageMs: pathAgeMs4(resolved, opts.now)
       });
     }
   }
@@ -6395,12 +7950,12 @@ function scanDuplicateWorktreeCandidates(opts) {
 }
 
 // src/cleanup-worktree-index.ts
-import path34 from "node:path";
+import path43 from "node:path";
 function buildWorktreeIndexAt(harnessRoot) {
   const index = /* @__PURE__ */ new Map();
   for (const run of listRunRecordsForHarnessRoot(harnessRoot)) {
     for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path34.join(
+      const workerPath = path43.join(
         runDirectoryAt(harnessRoot, run.id),
         "workers",
         safeSlug(name),
@@ -6409,9 +7964,9 @@ function buildWorktreeIndexAt(harnessRoot) {
       const worker = readJson(workerPath, void 0);
       if (!worker?.worktreePath) continue;
       const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
-      index.set(path34.resolve(worker.worktreePath), {
+      index.set(path43.resolve(worker.worktreePath), {
         harnessRoot,
-        worktreePath: path34.resolve(worker.worktreePath),
+        worktreePath: path43.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -6423,10 +7978,6 @@ function buildWorktreeIndexAt(harnessRoot) {
   return index;
 }
 
-// src/cleanup-types.ts
-var DEFAULT_NODE_MODULES_AGE_MS = 6 * 60 * 60 * 1e3;
-var DEFAULT_WORKTREES_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-
 // src/cleanup-retention-config.ts
 function envFlag(name) {
   const v = process.env[name];
@@ -6443,6 +7994,9 @@ function resolveHarnessRetention(options = {}) {
   const finalizeStaleRuns2 = options.finalizeStaleRuns !== false && !envFlag("KYNVER_CLEANUP_SKIP_FINALIZE");
   const nodeModulesAgeMs = options.nodeModulesAgeMs ?? envMs("KYNVER_CLEANUP_NODE_MODULES_AGE_MS", DEFAULT_NODE_MODULES_AGE_MS);
   const worktreesAgeMs = options.worktreesAgeMs ?? envMs("KYNVER_CLEANUP_WORKTREES_AGE_MS", 0);
+  const terminalWorktreesAgeMs = options.terminalWorktreesAgeMs ?? envMs("KYNVER_CLEANUP_TERMINAL_WORKTREES_AGE_MS", DEFAULT_TERMINAL_WORKTREES_AGE_MS);
+  const runDirectoriesAgeMs = options.runDirectoriesAgeMs ?? envMs("KYNVER_CLEANUP_RUN_DIRECTORIES_AGE_MS", DEFAULT_RUN_DIRECTORIES_AGE_MS);
+  const maxActionsPerSweep = options.maxActionsPerSweep ?? envMs("KYNVER_CLEANUP_MAX_ACTIONS_PER_SWEEP", DEFAULT_MAX_ACTIONS_PER_SWEEP);
   const includeOrphans = options.includeOrphans === true || envFlag("KYNVER_CLEANUP_INCLUDE_ORPHANS");
   const scopeAll = envFlag("KYNVER_CLEANUP_SCOPE_ALL") || process.env.KYNVER_CLEANUP_SCOPE === "all";
   const runIdFilter = scopeAll ? options.runIdFilter : options.runIdFilter ?? (process.env.KYNVER_CLEANUP_RUN_ID || void 0);
@@ -6452,6 +8006,9 @@ function resolveHarnessRetention(options = {}) {
     finalizeStaleRuns: finalizeStaleRuns2,
     nodeModulesAgeMs,
     worktreesAgeMs: worktreesAgeMs > 0 ? worktreesAgeMs : 0,
+    terminalWorktreesAgeMs: terminalWorktreesAgeMs >= 0 ? terminalWorktreesAgeMs : 0,
+    runDirectoriesAgeMs: runDirectoriesAgeMs >= 0 ? runDirectoriesAgeMs : 0,
+    maxActionsPerSweep: Number.isFinite(maxActionsPerSweep) && maxActionsPerSweep > 0 ? Math.floor(maxActionsPerSweep) : DEFAULT_MAX_ACTIONS_PER_SWEEP,
     includeOrphans,
     runIdFilter: runIdFilter ? String(runIdFilter) : void 0,
     accountBytes
@@ -6464,21 +8021,24 @@ function resolvePipelineHarnessRetention(runId) {
   return resolveHarnessRetention({
     runIdFilter: scopeAll ? void 0 : runId,
     worktreesAgeMs,
+    terminalWorktreesAgeMs: scopeAll ? DEFAULT_TERMINAL_WORKTREES_AGE_MS : void 0,
+    runDirectoriesAgeMs: scopeAll ? DEFAULT_RUN_DIRECTORIES_AGE_MS : void 0,
+    includeOrphans: scopeAll ? true : void 0,
     finalizeStaleRuns: true,
     accountBytes: true
   });
 }
 
 // src/cleanup-orphan-safety.ts
-import { existsSync as existsSync23, statSync as statSync6 } from "node:fs";
-import path35 from "node:path";
+import { existsSync as existsSync31, statSync as statSync9 } from "node:fs";
+import path44 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 (!existsSync23(input.worktreePath)) return null;
+  if (!existsSync31(input.worktreePath)) return null;
   if (input.runId && input.workerName) {
-    const heartbeatPath = path35.join(
+    const heartbeatPath = path44.join(
       input.harnessRoot,
       "runs",
       input.runId,
@@ -6487,13 +8047,13 @@ function assessOrphanWorktreeSafety(input) {
       "heartbeat.jsonl"
     );
     try {
-      const mtime = statSync6(heartbeatPath).mtimeMs;
+      const mtime = statSync9(heartbeatPath).mtimeMs;
       if (now - mtime < heartbeatFreshMs) return "active_worker";
     } catch {
     }
   }
-  const gitDir = path35.join(input.worktreePath, ".git");
-  if (!existsSync23(gitDir)) return null;
+  const gitDir = path44.join(input.worktreePath, ".git");
+  if (!existsSync31(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);
@@ -6522,14 +8082,14 @@ function assessOrphanWorktreeSafety(input) {
 }
 
 // src/harness-storage-snapshot.ts
-import { existsSync as existsSync24, readdirSync as readdirSync8, statSync as statSync7 } from "node:fs";
-import path36 from "node:path";
+import { existsSync as existsSync32, readdirSync as readdirSync10, statSync as statSync10 } from "node:fs";
+import path45 from "node:path";
 function harnessStorageSnapshot(opts = {}) {
-  const harnessRoot = opts.harnessRoot ?? resolveHarnessRoot();
-  const worktreesDir = path36.join(harnessRoot, "worktrees");
+  const harnessRoot = normalizeHarnessRoot(opts.harnessRoot ?? resolveHarnessRoot());
+  const worktreesDir = harnessWorktreesDir(harnessRoot);
   const now = opts.now ?? Date.now();
   const scannedAt = new Date(now).toISOString();
-  if (!existsSync24(worktreesDir)) {
+  if (!existsSync32(worktreesDir)) {
     return {
       harnessRoot,
       worktreesDir,
@@ -6546,7 +8106,7 @@ function harnessStorageSnapshot(opts = {}) {
   let oldestMs = null;
   let entries;
   try {
-    entries = readdirSync8(worktreesDir, { withFileTypes: true });
+    entries = readdirSync10(worktreesDir, { withFileTypes: true });
   } catch {
     return {
       harnessRoot,
@@ -6561,14 +8121,14 @@ function harnessStorageSnapshot(opts = {}) {
   for (const runEntry of entries) {
     if (!runEntry.isDirectory()) continue;
     runCount += 1;
-    const runPath = path36.join(worktreesDir, runEntry.name);
+    const runPath = path45.join(worktreesDir, runEntry.name);
     try {
-      const st = statSync7(runPath);
+      const st = statSync10(runPath);
       oldestMs = oldestMs === null ? st.mtimeMs : Math.min(oldestMs, st.mtimeMs);
     } catch {
     }
     try {
-      for (const workerEntry of readdirSync8(runPath, { withFileTypes: true })) {
+      for (const workerEntry of readdirSync10(runPath, { withFileTypes: true })) {
         if (workerEntry.isDirectory()) workerCount += 1;
       }
     } catch {
@@ -6596,16 +8156,16 @@ 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";
+import { existsSync as existsSync33 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import path46 from "node:path";
 var WELL_KNOWN_HARNESS_SCAN_ROOTS = [
   "/var/tmp/kynver-harness",
-  path37.join(homedir6(), ".openclaw", "harness")
+  path46.join(homedir11(), ".openclaw", "harness")
 ];
 function addRoot(seen, roots, candidate) {
   if (!candidate?.trim()) return;
-  const resolved = path37.resolve(resolveUserPath(candidate.trim()));
+  const resolved = normalizeHarnessRoot(candidate.trim());
   if (seen.has(resolved)) return;
   seen.add(resolved);
   roots.push(resolved);
@@ -6623,42 +8183,13 @@ function resolveHarnessScanRoots(options = {}) {
   for (const candidate of extra ?? []) addRoot(seen, roots, candidate);
   if (shouldScanWellKnownRoots(options)) {
     for (const candidate of WELL_KNOWN_HARNESS_SCAN_ROOTS) {
-      const resolved = path37.resolve(candidate);
-      if (!seen.has(resolved) && existsSync25(resolved)) addRoot(seen, roots, resolved);
+      const resolved = path46.resolve(candidate);
+      if (!seen.has(resolved) && existsSync33(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];
@@ -6695,14 +8226,14 @@ function applyDiskPressureToRetention(retention, pressure) {
 
 // src/cleanup.ts
 function resolvePaths(options = {}) {
-  const harnessRoot = options.harnessRoot ? resolveUserPath(options.harnessRoot) : resolveHarnessRoot();
+  const harnessRoot = options.harnessRoot ? normalizeHarnessRoot(options.harnessRoot) : resolveHarnessRoot();
   const scanRoots = resolveHarnessScanRoots({ harnessRoot });
   const now = options.now ?? Date.now();
   return { harnessRoot, scanRoots, now };
 }
-function normalizeGuardSkip(skip) {
-  if (typeof skip === "string") return { reason: skip };
-  return skip;
+function normalizeGuardSkip(skip2) {
+  if (typeof skip2 === "string") return { reason: skip2 };
+  return skip2;
 }
 function recordSkip(skips, pathValue, reason, detail) {
   skips.push({ path: pathValue, reason, ...detail ? { detail } : {} });
@@ -6713,8 +8244,8 @@ function attachCandidateBytes(candidate, accountBytes) {
 }
 function tallySkipReasons(actions, skips) {
   const counts = {};
-  for (const skip of skips) {
-    counts[skip.reason] = (counts[skip.reason] ?? 0) + 1;
+  for (const skip2 of skips) {
+    counts[skip2.reason] = (counts[skip2.reason] ?? 0) + 1;
   }
   for (const action of actions) {
     if (action.skipReason) {
@@ -6742,9 +8273,9 @@ function mergeWorktreeIndexes(scanRoots) {
 }
 function worktreePathForCandidate(candidate, worktreesDir) {
   if (candidate.runId && candidate.worker) {
-    return path39.join(worktreesDir, candidate.runId, candidate.worker);
+    return path47.join(worktreesDir, candidate.runId, candidate.worker);
   }
-  return path39.resolve(candidate.path, "..");
+  return path47.resolve(candidate.path, "..");
 }
 function runHarnessCleanup(options = {}) {
   let retention = resolveHarnessRetention(options);
@@ -6757,8 +8288,11 @@ function runHarnessCleanup(options = {}) {
   const skips = [];
   const actions = [];
   const processedPaths = /* @__PURE__ */ new Set();
+  const maxActions = retention.maxActionsPerSweep;
+  const atSweepCap = () => actions.length >= maxActions;
   for (const harnessRoot of paths.scanRoots) {
-    const worktreesDir = path39.join(harnessRoot, "worktrees");
+    if (atSweepCap()) break;
+    const worktreesDir = path47.join(harnessRoot, "worktrees");
     const scanOpts = {
       harnessRoot,
       worktreesDir,
@@ -6770,8 +8304,9 @@ function runHarnessCleanup(options = {}) {
       now: paths.now
     };
     for (const raw of scanDependencyCacheCandidates(scanOpts)) {
+      if (atSweepCap()) break;
       const candidate = attachCandidateBytes(raw, retention.accountBytes);
-      const resolved = path39.resolve(candidate.path);
+      const resolved = path47.resolve(candidate.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const pathSkip = pathGuardForDependencyCache(candidate, harnessRoot, worktreesDir);
@@ -6781,7 +8316,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path39.resolve(worktreePath)) ?? null;
+      const indexed = index.get(path47.resolve(worktreePath)) ?? null;
       const guardReason = skipDependencyCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -6799,8 +8334,9 @@ function runHarnessCleanup(options = {}) {
       actions.push(removeDependencyCacheAction(candidate, retention.execute));
     }
     for (const raw of scanBuildCacheCandidates(scanOpts)) {
+      if (atSweepCap()) break;
       const candidate = attachCandidateBytes(raw, retention.accountBytes);
-      const resolved = path39.resolve(candidate.path);
+      const resolved = path47.resolve(candidate.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const pathSkip = isHarnessBuildCachePath(candidate.path, harnessRoot, worktreesDir);
@@ -6810,7 +8346,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path39.resolve(worktreePath)) ?? null;
+      const indexed = index.get(path47.resolve(worktreePath)) ?? null;
       const guardReason = skipBuildCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -6833,11 +8369,12 @@ function runHarnessCleanup(options = {}) {
     ];
     const worktreeSeen = /* @__PURE__ */ new Set();
     for (const raw of worktreeCandidates) {
-      const resolved = path39.resolve(raw.path);
+      if (atSweepCap()) break;
+      const resolved = path47.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 indexed = index.get(path47.resolve(candidate.path)) ?? null;
       const orphanSafety = indexed ? null : assessOrphanWorktreeSafety({
         worktreePath: candidate.path,
         harnessRoot,
@@ -6847,9 +8384,10 @@ function runHarnessCleanup(options = {}) {
       });
       const guardSkip = skipWorktreeRemoval({
         indexed,
-        worktreePath: path39.resolve(candidate.path),
+        worktreePath: path47.resolve(candidate.path),
         includeOrphans: retention.includeOrphans,
         worktreesAgeMs: retention.worktreesAgeMs,
+        terminalWorktreesAgeMs: retention.terminalWorktreesAgeMs,
         ageMs: candidate.ageMs,
         orphanSafety,
         worktreeRemovalGuard: options.worktreeRemovalGuard
@@ -6862,8 +8400,40 @@ function runHarnessCleanup(options = {}) {
       }
       actions.push(removeWorktree(candidate, retention.execute));
     }
+    if (!atSweepCap() && retention.runDirectoriesAgeMs >= 0) {
+      for (const raw of scanStaleRunDirectoryCandidates({
+        harnessRoot,
+        worktreesDir,
+        runDirectoriesAgeMs: retention.runDirectoriesAgeMs,
+        runIdFilter: retention.runIdFilter,
+        activeGuards,
+        now: paths.now
+      })) {
+        if (atSweepCap()) break;
+        const candidate = attachCandidateBytes(raw, retention.accountBytes);
+        const resolved = path47.resolve(candidate.path);
+        if (processedPaths.has(resolved)) continue;
+        processedPaths.add(resolved);
+        const runId = candidate.runId ?? path47.basename(resolved);
+        const dirSkip = skipRunDirectoryRemoval({
+          harnessRoot,
+          runId,
+          runPath: resolved,
+          ageMs: candidate.ageMs,
+          runDirectoriesAgeMs: retention.runDirectoriesAgeMs,
+          activeGuards
+        });
+        if (dirSkip) {
+          recordSkip(skips, candidate.path, dirSkip);
+          actions.push({ ...candidate, executed: false, skipped: true, skipReason: dirSkip });
+          continue;
+        }
+        actions.push(removeRunDirectory(candidate, retention.execute));
+      }
+    }
   }
   let candidateBytes = 0;
+  let removedRunDirectories = 0;
   let reclaimableBytes = 0;
   let removedBytes = 0;
   let removedPaths = 0;
@@ -6874,12 +8444,14 @@ function runHarnessCleanup(options = {}) {
     if (action.executed) {
       removedPaths += 1;
       removedBytes += action.bytes ?? 0;
+      if (action.kind === "remove_run_directory") removedRunDirectories += 1;
     } else if (action.skipped) {
       skippedPaths += 1;
       if (action.skipReason === "dry_run" && action.bytes) reclaimableBytes += action.bytes;
     }
   }
   const storage = retention.accountBytes ? harnessStorageSnapshot({ harnessRoot: paths.harnessRoot, now: paths.now }) : void 0;
+  const preservedLivePaths = collectPreservedLivePaths(actions, skips);
   return {
     harnessRoot: paths.harnessRoot,
     scanRoots: paths.scanRoots,
@@ -6908,7 +8480,9 @@ function runHarnessCleanup(options = {}) {
       skippedPaths,
       skipReasons: tallySkipReasons(actions, skips)
     },
-    ...storage ? { storage } : {}
+    ...storage ? { storage } : {},
+    ...preservedLivePaths.length > 0 ? { preservedLivePaths } : {},
+    ...removedRunDirectories > 0 ? { removedRunDirectories } : {}
   };
 }
 function runPipelineHarnessCleanup(runId) {
@@ -6929,8 +8503,8 @@ function isPipelineCleanupEnabled() {
 
 // src/installed-package-versions.ts
 import { readFile } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import path40 from "node:path";
+import { homedir as homedir12 } from "node:os";
+import path48 from "node:path";
 var MANAGED_PACKAGES = [
   "@kynver-app/runtime",
   "@kynver-app/openclaw-agent-os",
@@ -6944,13 +8518,13 @@ function unique(values) {
   return [...new Set(values.filter((value) => Boolean(value)))];
 }
 function moduleRoots() {
-  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"));
+  const home = homedir12();
+  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path48.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) ? path48.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path48.join(home, ".npm-global", "lib", "node_modules"));
   return unique([
-    path40.join(openClawPrefix, "lib", "node_modules"),
-    path40.join(openClawPrefix, "node_modules"),
-    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path40.join(npmGlobalRoot, "lib", "node_modules")
+    path48.join(openClawPrefix, "lib", "node_modules"),
+    path48.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path48.join(npmGlobalRoot, "lib", "node_modules")
   ]);
 }
 async function readVersion(packageJsonPath) {
@@ -6966,7 +8540,7 @@ async function collectInstalledPackageVersions(observedAt = (/* @__PURE__ */ new
   const out = {};
   for (const packageName of MANAGED_PACKAGES) {
     for (const root of roots) {
-      const packageJsonPath = path40.join(root, packageName, "package.json");
+      const packageJsonPath = path48.join(root, packageName, "package.json");
       const version = await readVersion(packageJsonPath);
       if (!version) continue;
       out[packageName] = { version, observedAt, path: packageJsonPath };
@@ -6982,7 +8556,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path41.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path49.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -7014,21 +8588,7 @@ async function postOperatorTick(agentOsId, runId, resourceGate, args, harnessCle
   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 activeHarnessWorkers = collectRunActiveHarnessWorkers(runId);
   const res = await postJson(url, secret, {
     agentOsId,
     runId,
@@ -7059,9 +8619,13 @@ async function runPipelineTick(args) {
   const completionAckSync = syncCompletionAcknowledgedFromOperatorTick(runId, operatorTick);
   const leaseRenewal = await renewActiveTaskLeases(runId, args);
   const completedWorkers = await completeFinishedWorkers(runId, args);
+  const dispatchResourceGate = observeRunnerResourceGate({
+    runId,
+    configuredMaxWorkersOverride: workspacePrefs?.maxConcurrentWorkers
+  });
   const staleReconcile = reconcileStaleWorkers();
   const planProgressSync = await syncActiveWorkerPlanProgress(runId, args);
-  const maxStartsAdvice = resolvePipelineMaxStarts(resourceGate, operatorTick);
+  const maxStartsAdvice = resolvePipelineMaxStarts(dispatchResourceGate, operatorTick);
   let maxStarts = maxStartsAdvice.maxStarts;
   const sweep = await sweepRun({ run: runId, agentOsId, pipeline: true, ...args });
   let dispatch = null;
@@ -7078,7 +8642,7 @@ async function runPipelineTick(args) {
     dispatch = {
       ok: true,
       skipped: true,
-      reason: execute ? resourceGate.reason ?? "no slots or queued work" : "execute disabled",
+      reason: execute ? dispatchResourceGate.reason ?? "no slots or queued work" : "execute disabled",
       maxStarts: 0
     };
   }
@@ -7089,6 +8653,7 @@ async function runPipelineTick(args) {
     agentOsId,
     execute,
     resourceGate,
+    dispatchResourceGate,
     leaseRenewal,
     completedWorkers,
     staleReconcile,
@@ -7140,7 +8705,7 @@ async function runDaemon(args) {
 }
 
 // src/plan-progress.ts
-import path42 from "node:path";
+import path50 from "node:path";
 
 // src/bounded-build/constants.ts
 var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
@@ -7178,7 +8743,7 @@ function formatNodeOptionsFlag(mb = resolveNodeOldSpaceSizeMb()) {
 }
 
 // src/bounded-build/systemd-wrap.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 var systemdAvailableCache;
 function isSystemdRunAvailable() {
   if (process.env.KYNVER_BUILD_SKIP_SYSTEMD === "1" || process.env.KYNVER_BUILD_SKIP_SYSTEMD === "true") {
@@ -7189,7 +8754,7 @@ function isSystemdRunAvailable() {
     systemdAvailableCache = false;
     return false;
   }
-  const res = spawnSync3("systemd-run", ["--version"], { encoding: "utf8", stdio: ["ignore", "ignore", "pipe"] });
+  const res = spawnSync4("systemd-run", ["--version"], { encoding: "utf8", stdio: ["ignore", "ignore", "pipe"] });
   systemdAvailableCache = res.status === 0;
   return systemdAvailableCache;
 }
@@ -7213,7 +8778,7 @@ function buildSystemdRunArgv(opts) {
 }
 
 // src/bounded-build/admission.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
 function positiveInt3(value, fallback) {
   const n = Number(value);
   if (!Number.isFinite(n) || n <= 0) return fallback;
@@ -7249,7 +8814,7 @@ function assessBuildAdmission(opts = {}) {
 }
 function sleepMs2(ms) {
   if (ms <= 0) return;
-  spawnSync4(process.execPath, ["-e", `const d=Date.now()+${Math.floor(ms)};while(Date.now()<d);`], {
+  spawnSync5(process.execPath, ["-e", `const d=Date.now()+${Math.floor(ms)};while(Date.now()<d);`], {
     stdio: "ignore"
   });
 }
@@ -7270,7 +8835,7 @@ function waitForBuildAdmission(timeoutMs, pollMs = 2e3, opts = {}) {
 }
 
 // src/bounded-build/exec.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 function envArgv(env) {
   const out = [];
   for (const [key, value] of Object.entries(env)) {
@@ -7280,7 +8845,7 @@ function envArgv(env) {
   return out;
 }
 function runSpawn(argv, opts) {
-  const res = spawnSync5(argv[0], argv.slice(1), {
+  const res = spawnSync6(argv[0], argv.slice(1), {
     cwd: opts.cwd,
     env: opts.env,
     encoding: "utf8",
@@ -7427,7 +8992,7 @@ async function emitPlanProgress(args) {
 }
 function verifyPlanLocal(args) {
   const worktree = required(args.worktree ? String(args.worktree) : void 0, "worktree");
-  const cwd = path42.resolve(worktree);
+  const cwd = path50.resolve(worktree);
   const summary = runHarnessVerifyCommands(cwd);
   const emitJson = args.json === true || args.json === "true";
   const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
@@ -7476,9 +9041,9 @@ async function verifyPlan(args) {
 }
 
 // src/harness-verify-cli.ts
-import path43 from "node:path";
+import path51 from "node:path";
 function runHarnessVerifyCli(args) {
-  const cwd = path43.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const cwd = path51.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;
@@ -7522,7 +9087,7 @@ function runHarnessVerifyCli(args) {
 }
 
 // src/plan-persist-cli.ts
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 var OPERATIONS = ["create", "add_version", "update_metadata"];
 var FAILURE_KINDS = [
   "approval_guard",
@@ -7534,7 +9099,7 @@ var FAILURE_KINDS = [
 function readBodyArg(args) {
   const bodyFile = args.bodyFile ? String(args.bodyFile) : void 0;
   if (bodyFile) {
-    return { body: readFileSync10(bodyFile, "utf8"), bodyPathHint: bodyFile };
+    return { body: readFileSync11(bodyFile, "utf8"), bodyPathHint: bodyFile };
   }
   const inline = args.body ? String(args.body) : void 0;
   if (inline) return { body: inline };
@@ -7678,21 +9243,17 @@ function formatMonitorTickNotice(tick) {
 }
 
 // src/monitor/monitor.service.ts
-import path45 from "node:path";
+import path53 from "node:path";
 
 // src/monitor/monitor.classify.ts
-function expectedLeaseOwner(runId) {
-  return `kynver-harness:${runId}`;
-}
 function classifyWorkerHealth(input) {
   const { worker, status, taskLease } = input;
   const leaseOwner = taskLease?.leaseOwner ?? null;
-  const expectedOwner = expectedLeaseOwner(worker.runId);
   if (worker.dispatched && taskLease) {
-    if (taskLease.status === "running" && leaseOwner && leaseOwner !== expectedOwner) {
+    if (taskLease.status === "running" && leaseOwner && !harnessLeaseOwnerMatchesRun(leaseOwner, worker.runId)) {
       return {
         health: "orphaned",
-        reason: `task lease held by ${leaseOwner}, expected ${expectedOwner}`
+        reason: `task lease held by ${leaseOwner}, expected harness run ${worker.runId}`
       };
     }
     if (taskLease.status === "running" && !status.alive && !status.finalResult) {
@@ -7734,11 +9295,11 @@ function classifyWorkerHealth(input) {
 }
 
 // src/monitor/monitor.store.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync6, readdirSync as readdirSync9, unlinkSync as unlinkSync2 } from "node:fs";
-import path44 from "node:path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync6, readdirSync as readdirSync11, unlinkSync as unlinkSync2 } from "node:fs";
+import path52 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path44.join(harnessRoot, "monitors");
+  const dir = path52.join(harnessRoot, "monitors");
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
@@ -7746,7 +9307,7 @@ function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path44.join(monitorsDir(), `${monitorId}.json`);
+  return path52.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -7756,18 +9317,18 @@ function saveMonitorSession(session) {
 }
 function deleteMonitorSession(monitorId) {
   const file = monitorPath(monitorId);
-  if (!existsSync26(file)) return false;
+  if (!existsSync34(file)) return false;
   unlinkSync2(file);
   return true;
 }
 function listMonitorSessions() {
   const dir = monitorsDir();
-  if (!existsSync26(dir)) return [];
+  if (!existsSync34(dir)) return [];
   const entries = [];
-  for (const name of readdirSync9(dir)) {
+  for (const name of readdirSync11(dir)) {
     if (!name.endsWith(".json")) continue;
     const session = readJson(
-      path44.join(dir, name),
+      path52.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -7858,7 +9419,7 @@ async function fetchTaskLeasesForWorkers(input) {
 // src/monitor/monitor.service.ts
 function workerRecord2(runId, name) {
   return readJson(
-    path45.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path53.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -8063,22 +9624,22 @@ async function runMonitorLoop(args) {
 }
 
 // src/monitor/monitor-spawn.ts
-import { spawn as spawn4 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync27, openSync as openSync4 } from "node:fs";
-import path46 from "node:path";
+import { spawn as spawn6 } from "node:child_process";
+import { closeSync as closeSync6, existsSync as existsSync35, openSync as openSync6 } from "node:fs";
+import path54 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path46.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
+  return path54.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
-  if (!existsSync27(cliPath)) return void 0;
+  if (!existsSync35(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path46.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path54.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
-    logFd = openSync4(logPath, "a");
+    logFd = openSync6(logPath, "a");
   } catch {
     logFd = void 0;
   }
@@ -8109,7 +9670,7 @@ function spawnMonitorSidecar(opts) {
     logFd ?? "ignore"
   ];
   try {
-    const child = spawn4(
+    const child = spawn6(
       nodeExecutable,
       args,
       hiddenSpawnOptions({
@@ -8118,7 +9679,7 @@ function spawnMonitorSidecar(opts) {
         env: process.env
       })
     );
-    if (logFd !== void 0) closeSync4(logFd);
+    if (logFd !== void 0) closeSync6(logFd);
     child.unref();
     const session = {
       monitorId,
@@ -8135,7 +9696,7 @@ function spawnMonitorSidecar(opts) {
   } catch {
     if (logFd !== void 0) {
       try {
-        closeSync4(logFd);
+        closeSync6(logFd);
       } catch {
       }
     }
@@ -8195,13 +9756,13 @@ async function monitorTickCli(args) {
 }
 
 // src/package-version.ts
-import { existsSync as existsSync28, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync36, readFileSync as readFileSync12 } 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 (existsSync28(join(dir, "package.json"))) return dir;
+    if (existsSync36(join(dir, "package.json"))) return dir;
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -8210,7 +9771,7 @@ function resolvePackageRoot(moduleUrl) {
 }
 function readOwnPackageVersion(moduleUrl = import.meta.url) {
   const pkgPath = join(resolvePackageRoot(moduleUrl), "package.json");
-  const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
   if (typeof pkg.version !== "string" || !pkg.version.trim()) {
     throw new Error(`Missing package.json version at ${pkgPath}`);
   }
@@ -8230,17 +9791,142 @@ function handleCliVersionFlag(argv, moduleUrl = import.meta.url, binName) {
   return true;
 }
 
+// src/post-restart-unblock.ts
+import path55 from "node:path";
+function skip(runId, worker, taskId, agentOsId, leaseOwner, reason) {
+  return { runId, worker, taskId, agentOsId, leaseOwner, action: "skipped", reason };
+}
+async function postRestartUnblock(args) {
+  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+  const agentOsIdFilter = args.agentOsId ? String(args.agentOsId).trim() : null;
+  const dryRun = args.dryRun === true || args.dryRun === "true";
+  const released = [];
+  const skipped = [];
+  const errors = [];
+  for (const run of listRunRecords()) {
+    for (const name of Object.keys(run.workers ?? {})) {
+      const workerPath = path55.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const worker = readJson(workerPath, void 0);
+      if (!worker) {
+        skipped.push(skip(run.id, name, "", "", "", "worker.json missing"));
+        continue;
+      }
+      const taskId = worker.taskId ?? "";
+      const agentOsId = worker.agentOsId ?? "";
+      const leaseOwner = worker.leaseOwner ?? "";
+      if (!worker.dispatched || !taskId || !agentOsId || !leaseOwner) {
+        skipped.push(
+          skip(run.id, name, taskId, agentOsId, leaseOwner, "not a fully-leased dispatched worker")
+        );
+        continue;
+      }
+      if (agentOsIdFilter && agentOsId !== agentOsIdFilter) continue;
+      if (worker.completionReportedAt) {
+        skipped.push(
+          skip(run.id, name, taskId, agentOsId, leaseOwner, "completion already reported")
+        );
+        continue;
+      }
+      const status = computeWorkerStatus(worker);
+      if (status.finalResult) {
+        skipped.push(
+          skip(run.id, name, taskId, agentOsId, leaseOwner, "has final result \u2014 let pipeline tick complete it")
+        );
+        continue;
+      }
+      if (status.alive) {
+        skipped.push(
+          skip(run.id, name, taskId, agentOsId, leaseOwner, "worker process is still alive")
+        );
+        continue;
+      }
+      if (dryRun) {
+        released.push({
+          runId: run.id,
+          worker: name,
+          taskId,
+          agentOsId,
+          leaseOwner,
+          action: "released",
+          reason: "dry-run: would release dead dispatched worker lease"
+        });
+        continue;
+      }
+      try {
+        const secret = await resolveCallbackSecretWithMint(
+          args.secret ? String(args.secret) : void 0,
+          agentOsId,
+          { baseUrl: base }
+        );
+        const releaseUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(taskId)}/release`;
+        const release = await postJsonWithCredentialRefresh(
+          releaseUrl,
+          secret,
+          { agentOsId, leaseOwner },
+          { agentOsId, baseUrl: base }
+        );
+        const releaseOk = release.ok === true || release.response?.ok === true;
+        if (releaseOk) {
+          released.push({
+            runId: run.id,
+            worker: name,
+            taskId,
+            agentOsId,
+            leaseOwner,
+            action: "released",
+            reason: "dead dispatched worker lease released; task requeued"
+          });
+        } else {
+          skipped.push({
+            runId: run.id,
+            worker: name,
+            taskId,
+            agentOsId,
+            leaseOwner,
+            action: "skipped",
+            reason: `release returned ok:false (likely owner mismatch or already released): HTTP ${release.status}`
+          });
+        }
+      } catch (err) {
+        errors.push({
+          runId: run.id,
+          worker: name,
+          taskId,
+          agentOsId,
+          leaseOwner,
+          action: "error",
+          reason: err.message
+        });
+      }
+    }
+  }
+  return { dryRun, released, skipped, errors };
+}
+async function postRestartUnblockCli(args) {
+  const result = await postRestartUnblock(args);
+  const summary = {
+    ok: result.errors.length === 0,
+    dryRun: result.dryRun,
+    released: result.released.length,
+    skipped: result.skipped.length,
+    errors: result.errors.length,
+    details: result
+  };
+  console.log(JSON.stringify(summary, null, 2));
+  if (result.errors.length > 0) process.exit(1);
+}
+
 // src/doctor/runtime-takeover.ts
-import path48 from "node:path";
+import path57 from "node:path";
 
 // src/doctor/runtime-takeover.probes.ts
-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";
+import { accessSync, constants, existsSync as existsSync37, readFileSync as readFileSync13 } from "node:fs";
+import { homedir as homedir13 } from "node:os";
+import path56 from "node:path";
+import { spawnSync as spawnSync7 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
-    const res = spawnSync6(bin, args, { encoding: "utf8" });
+    const res = spawnSync7(bin, args, { encoding: "utf8" });
     const stdout = (res.stdout || "").trim();
     const stderr = (res.stderr || "").trim();
     const ok = res.status === 0;
@@ -8265,7 +9951,7 @@ function tokenPrefix(token) {
   return trimmed.length <= 12 ? `${trimmed}\u2026` : `${trimmed.slice(0, 12)}\u2026`;
 }
 function isWritable(target) {
-  if (!existsSync29(target)) return false;
+  if (!existsSync37(target)) return false;
   try {
     accessSync(target, constants.W_OK);
     return true;
@@ -8278,15 +9964,15 @@ var defaultRuntimeTakeoverProbes = {
   commandOnPath: (bin) => captureCommand(process.platform === "win32" ? "where" : "which", [bin]),
   kynverVersion: (bin) => captureCommand(bin, ["--version"]),
   loadConfig: () => loadUserConfig(),
-  configFilePath: () => path47.join(homedir8(), ".kynver", "config.json"),
-  credentialsFilePath: () => path47.join(homedir8(), ".kynver", "credentials"),
+  configFilePath: () => path56.join(homedir13(), ".kynver", "config.json"),
+  credentialsFilePath: () => path56.join(homedir13(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path47.join(homedir8(), ".kynver", "credentials");
-    if (!existsSync29(credPath)) {
+    const credPath = path56.join(homedir13(), ".kynver", "credentials");
+    if (!existsSync37(credPath)) {
       return { hasApiKey: false };
     }
     try {
-      const parsed = JSON.parse(readFileSync12(credPath, "utf8"));
+      const parsed = JSON.parse(readFileSync13(credPath, "utf8"));
       return {
         hasApiKey: Boolean(parsed.apiKey?.trim()),
         runnerTokenPrefix: tokenPrefix(parsed.runnerToken),
@@ -8313,8 +9999,8 @@ var defaultRuntimeTakeoverProbes = {
     })()
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path47.join(homedir8(), ".openclaw", "harness"),
-  pathExists: (target) => existsSync29(target),
+  legacyOpenclawHarnessRoot: () => path56.join(homedir13(), ".openclaw", "harness"),
+  pathExists: (target) => existsSync37(target),
   pathWritable: (target) => isWritable(target),
   vercelVersion: () => captureCommand("vercel", ["--version"]),
   vercelWhoami: () => captureCommand("vercel", ["whoami"])
@@ -8642,8 +10328,8 @@ function assessVercelCli(probes) {
 }
 function assessHarnessDirs(probes) {
   const harnessRoot = probes.harnessRoot();
-  const runsDir = path48.join(harnessRoot, "runs");
-  const worktreesDir = path48.join(harnessRoot, "worktrees");
+  const runsDir = path57.join(harnessRoot, "runs");
+  const worktreesDir = path57.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -8879,9 +10565,9 @@ function applySchedulerCutoverAttestation(config) {
 }
 
 // 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");
+import path58 from "node:path";
+import { homedir as homedir14 } from "node:os";
+var CONFIG_FILE2 = path58.join(homedir14(), ".kynver", "config.json");
 function runSchedulerCutoverCheckCli(json = false) {
   const config = loadUserConfig();
   const report = assessSchedulerCutover(config);
@@ -8977,7 +10663,7 @@ function usage(code = 0) {
       "  kynver run create [--repo /path/repo] [--name name] [--base origin/main]",
       "  kynver run list",
       "  kynver run status --run RUN_ID",
-      "  kynver run dispatch --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--execute] [--lane any|implementation|review|landing] [--target-task-id TASK_ID] [--executor harness] [--max-starts 1] [--lease-ms MS] [--owned path[,path]] [--model claude-opus-4-8] [--disk-path /]",
+      "  kynver run dispatch --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--execute] [--lane any|implementation|review|landing] [--target-task-id TASK_ID] [--executor harness] [--max-starts 1] [--lease-ms MS] [--owned path[,path]] [--model claude-opus-4-8] [--disk-path /] [--reconcile-stale-blockers]",
       "  kynver run sweep --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--grace-ms MS]",
       '  kynver worker start --run RUN_ID --name worker --task "..." [--owned path[,path]] [--model MODEL] [--provider claude|cursor] [--agent-os-id AOS_ID] [--task-id TASK_ID] [--wait]',
       "  kynver worker status --run RUN_ID --name worker",
@@ -8987,6 +10673,7 @@ function usage(code = 0) {
       "  kynver worker discard-disposable --run RUN_ID --name worker --path scripts/helper.mjs[,other]",
       "  kynver worker auto-complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--poll-ms 5000] [--max-total-ms 21600000] [--complete-attempts 3] [--complete-backoff-ms 5000] [--base-url URL] [--secret SECRET]",
       "  kynver run reconcile",
+      "  kynver run unblock [--agent-os-id AOS_ID] [--base-url URL] [--secret SECRET] [--dry-run]",
       "  kynver plan progress --plan PLAN_ID --row ROW_KEY --role ROLE --status STATUS [--task TASK_ID] [--note NOTE] [--evidence type:value] [--agent-os-id AOS_ID]",
       "  kynver plan verify --plan PLAN_ID [--worktree PATH] [--task TASK_ID] [--human-override] [--local]",
       "  kynver harness verify --worktree PATH [--command CMD] [--json] [--wait-for-admission-ms MS] [--timeout-ms MS]",
@@ -9058,6 +10745,7 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "run" && action === "dispatch") return void await dispatchRun(args);
   if (scope === "run" && action === "sweep") return void await sweepRun(args);
   if (scope === "run" && action === "reconcile") return reconcileRunsCli();
+  if (scope === "run" && action === "unblock") return void await postRestartUnblockCli(args);
   if (scope === "worker" && action === "start") return void await startWorker(args);
   if (scope === "worker" && action === "status") return workerStatus(args);
   if (scope === "worker" && action === "tail") return tailWorker(args);