@kynver-app/runtime 0.1.95 → 0.1.102

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { mkdirSync as mkdirSync8, realpathSync } from "node:fs";
+import { mkdirSync as mkdirSync10, realpathSync } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/config.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir4, totalmem } from "node:os";
 import path8 from "node:path";
 
@@ -90,6 +90,9 @@ function readMaybeFile(file) {
 function sleepMs(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
+function sleepMsAsync(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function isPidAlive(pid) {
   if (!pid) return false;
   try {
@@ -485,23 +488,23 @@ function isWslHost() {
 function observeWslHostDisk(options = {}) {
   const wsl = options.forceWsl === void 0 ? isWslHost() : options.forceWsl;
   if (!wsl) return null;
-  const path67 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
+  const path71 = 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(path67);
+    stats = statfs(path71);
   } catch (error) {
     return {
       ok: false,
-      path: path67,
+      path: path71,
       freeBytes: 0,
       totalBytes: 0,
       usedPercent: 100,
       warnBelowBytes,
       criticalBelowBytes,
-      reason: `Windows host disk probe failed at ${path67}: ${error.message}`,
+      reason: `Windows host disk probe failed at ${path71}: ${error.message}`,
       probeError: error.message
     };
   }
@@ -515,11 +518,11 @@ function observeWslHostDisk(options = {}) {
   let reason = null;
   if (!ok) {
     const tag = criticalFree ? "critical" : "warning";
-    reason = `Windows host disk ${path67} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+    reason = `Windows host disk ${path71} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
   }
   return {
     ok,
-    path: path67,
+    path: path71,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -539,12 +542,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 path67 = input.diskPath?.trim() || "/";
+  const path71 = 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(path67);
+  const stats = statfsSync2(path71);
   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;
@@ -567,7 +570,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path67,
+    path: path71,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -701,6 +704,9 @@ function listRunWorkerNames(run) {
   return [...names];
 }
 
+// src/harness-worker-active.ts
+import { readFileSync as readFileSync7 } from "node:fs";
+
 // src/heartbeat.ts
 import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
 
@@ -1781,6 +1787,9 @@ function computeAttention(input) {
     return { state: "blocked", reason: input.completionBlocker };
   }
   if (input.finalResult) {
+    if (input.localOnly && hasMergedTargetPrReconciliation(input.finalResult)) {
+      return { state: "done", reason: "local-only worker superseded by merged PR" };
+    }
     const landingSnapshot = {
       finalResult: input.finalResult,
       changedFiles: input.changedFiles ?? [],
@@ -1846,9 +1855,24 @@ function computeAttention(input) {
   }
   return { state: "ok", reason: "recent activity" };
 }
+function hasMergedTargetPrReconciliation(value) {
+  let record = null;
+  if (typeof value === "string") record = extractEmbeddedWorkerFinalResultRecord(value);
+  else if (value && typeof value === "object" && !Array.isArray(value)) record = value;
+  if (!record) return false;
+  const raw = record.targetPrReconciliation ?? record.target_pr_reconciliation;
+  if (!Array.isArray(raw)) return false;
+  return raw.some((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+    return String(item.outcome ?? "").trim() === "merged";
+  });
+}
 function resolveFinalResult(worker, parsedFinalResult, heartbeat) {
-  if (parsedFinalResult) return parsedFinalResult;
   const ackSnapshot = worker.completionSnapshot?.finalResult;
+  if (worker.completionAckSource === "local-pr-merged-reconcile" && ackSnapshot !== void 0 && ackSnapshot !== null) {
+    return ackSnapshot;
+  }
+  if (parsedFinalResult) return parsedFinalResult;
   if (ackSnapshot !== void 0 && ackSnapshot !== null) return ackSnapshot;
   return terminalFinalResultFromHeartbeat(heartbeat);
 }
@@ -1895,7 +1919,8 @@ function computeWorkerStatus(worker, options = {}) {
     gitAncestry,
     completionBlocker,
     landingContract,
-    prUrl: worker.repairTargetPrUrl ?? worker.taskPrUrl ?? null
+    prUrl: worker.repairTargetPrUrl ?? worker.taskPrUrl ?? null,
+    localOnly: worker.localOnly === true
   });
   const workerStatusLabel = completionBlocker || attention.state === "blocked" ? "blocked" : completionAcknowledged || attention.state === "done" ? "done" : finalResult ? "exited" : alive ? "running" : "exited";
   return {
@@ -1949,6 +1974,33 @@ function deriveRunStatus(fallback, workers) {
   return fallback;
 }
 
+// src/harness-worker-active.ts
+function pidCommandLine(pid) {
+  if (!pid || process.platform !== "linux") return null;
+  try {
+    return readFileSync7(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ");
+  } catch {
+    return null;
+  }
+}
+function workerProcessMatchesRecord(worker) {
+  if (!worker.pid || process.platform !== "linux") return true;
+  const cmdline = pidCommandLine(worker.pid);
+  if (!cmdline) return false;
+  const probes = [worker.worktreePath, worker.workerDir, worker.heartbeatPath].filter(
+    (value) => typeof value === "string" && value.trim().length > 0
+  );
+  return probes.some((probe) => cmdline.includes(probe));
+}
+function isActiveHarnessWorker(worker) {
+  if (typeof worker.completionBlocker === "string" && worker.completionBlocker.trim()) {
+    return false;
+  }
+  const status = computeWorkerStatus(worker);
+  if (status.alive && !workerProcessMatchesRecord(worker)) return false;
+  return status.alive && !status.finalResult && status.attention.state !== "done";
+}
+
 // src/resource-gate.ts
 var DEFAULT_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
 var DEFAULT_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
@@ -1991,13 +2043,6 @@ function computeAutoMaxWorkers(totalMemBytes, opts = {}) {
 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";
-}
 function countActiveWorkersForRun(run) {
   let active = 0;
   for (const name of listRunWorkerNames(run)) {
@@ -2146,7 +2191,7 @@ var CREDENTIALS_FILE = path8.join(CONFIG_DIR, "credentials");
 function loadUserConfig() {
   if (!existsSync9(CONFIG_FILE)) return {};
   try {
-    return JSON.parse(readFileSync7(CONFIG_FILE, "utf8"));
+    return JSON.parse(readFileSync8(CONFIG_FILE, "utf8"));
   } catch {
     return {};
   }
@@ -2223,7 +2268,7 @@ function resolveSetupWorkerConfig(existing, args, totalMemBytes = totalmem()) {
 function loadCredentialsFile() {
   if (!existsSync9(CREDENTIALS_FILE)) return {};
   try {
-    return JSON.parse(readFileSync7(CREDENTIALS_FILE, "utf8"));
+    return JSON.parse(readFileSync8(CREDENTIALS_FILE, "utf8"));
   } catch {
     return {};
   }
@@ -2493,15 +2538,30 @@ async function withTimeout(fn) {
     clearTimeout(timeout);
   }
 }
+function callbackFetchError(error) {
+  return {
+    ok: false,
+    status: 0,
+    response: {
+      error: error instanceof Error ? error.message : String(error),
+      timeoutMs: callbackTimeoutMs()
+    }
+  };
+}
 async function postJson(url, secret, body) {
-  const res = await withTimeout(
-    (signal) => fetch(url, {
-      method: "POST",
-      headers: buildHarnessCallbackHeaders(secret),
-      body: JSON.stringify(body),
-      signal
-    })
-  );
+  let res;
+  try {
+    res = await withTimeout(
+      (signal) => fetch(url, {
+        method: "POST",
+        headers: buildHarnessCallbackHeaders(secret),
+        body: JSON.stringify(body),
+        signal
+      })
+    );
+  } catch (error) {
+    return callbackFetchError(error);
+  }
   let response = null;
   try {
     response = await res.json();
@@ -2519,13 +2579,18 @@ async function postJsonWithCredentialRefresh(url, secret, body, opts) {
   return { ...retry, refreshedAuth: true };
 }
 async function getJson(url, secret) {
-  const res = await withTimeout(
-    (signal) => fetch(url, {
-      method: "GET",
-      headers: buildHarnessCallbackHeaders(secret),
-      signal
-    })
-  );
+  let res;
+  try {
+    res = await withTimeout(
+      (signal) => fetch(url, {
+        method: "GET",
+        headers: buildHarnessCallbackHeaders(secret),
+        signal
+      })
+    );
+  } catch (error) {
+    return callbackFetchError(error);
+  }
   let response = null;
   try {
     response = await res.json();
@@ -2535,41 +2600,6 @@ async function getJson(url, secret) {
   return { ok: res.ok, status: res.status, response };
 }
 
-// src/dispatch-lane-normalization.ts
-function trimLower(value) {
-  return (value ?? "").trim().toLowerCase();
-}
-function roleLaneToDispatchLane(roleLane) {
-  switch (trimLower(roleLane)) {
-    case "implementer":
-    case "repair_implementer":
-    case "plan_author":
-    case "runtime_verifier":
-      return "implementation";
-    case "plan_reviewer":
-    case "report_reviewer":
-    case "deep_reviewer":
-      return "review";
-    default:
-      return null;
-  }
-}
-function normalizeDispatchNextLaneFilter(raw) {
-  const key = trimLower(raw);
-  if (!key) return void 0;
-  if (key === "implementation" || key === "review" || key === "landing" || key === "any") {
-    return key;
-  }
-  const mapped = roleLaneToDispatchLane(key);
-  if (mapped) return mapped;
-  if (key === "implement" || key === "repair" || key === "coding") return "implementation";
-  if (key === "land" || key === "merge") return "landing";
-  return void 0;
-}
-function resolveDispatchNextLaneFilter(raw) {
-  return normalizeDispatchNextLaneFilter(raw) ?? "any";
-}
-
 // src/worker-persona-catalog.ts
 var WORKER_PERSONA_CATALOG = [
   {
@@ -2672,6 +2702,41 @@ function workerPersonaReviewSlugs() {
   );
 }
 
+// src/dispatch-lane-normalization.ts
+function trimLower(value) {
+  return (value ?? "").trim().toLowerCase();
+}
+function roleLaneToDispatchLane(roleLane) {
+  switch (trimLower(roleLane)) {
+    case "implementer":
+    case "repair_implementer":
+    case "plan_author":
+    case "runtime_verifier":
+      return "implementation";
+    case "plan_reviewer":
+    case "report_reviewer":
+    case "deep_reviewer":
+      return "review";
+    default:
+      return null;
+  }
+}
+function normalizeDispatchNextLaneFilter(raw) {
+  const key = trimLower(raw);
+  if (!key) return void 0;
+  if (key === "implementation" || key === "review" || key === "landing" || key === "any") {
+    return key;
+  }
+  const mapped = roleLaneToDispatchLane(key);
+  if (mapped) return mapped;
+  if (key === "implement" || key === "repair" || key === "coding") return "implementation";
+  if (key === "land" || key === "merge") return "landing";
+  return void 0;
+}
+function resolveDispatchNextLaneFilter(raw) {
+  return normalizeDispatchNextLaneFilter(raw) ?? "any";
+}
+
 // src/model-routing-task-enrich.ts
 function taskString(task, key) {
   const v = task[key];
@@ -3129,7 +3194,7 @@ function probeCursorOAuthBinding(nowIso = (/* @__PURE__ */ new Date()).toISOStri
 }
 
 // src/orchestration-providers/hermes-cli-adapter.ts
-import { existsSync as existsSync14, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync9 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import path13 from "node:path";
 var PROFILE_ENV_KEYS = [
@@ -3145,7 +3210,7 @@ function hermesProfileEnvPath() {
 }
 function profileEnvKeyPresence(envPath) {
   try {
-    const text = readFileSync8(envPath, "utf8");
+    const text = readFileSync9(envPath, "utf8");
     const present = [];
     for (const key of PROFILE_ENV_KEYS) {
       const re = new RegExp(`^${key}=`, "m");
@@ -4106,7 +4171,7 @@ function buildPrompt(input) {
     "Completion handoff (required): before you stop, ensure the harness records a final result \u2014 summarize outcome in your last message and append a heartbeat line with phase `complete`. If you leave uncommitted changes or committed work without a PR, the orchestrator blocks completion until a GitHub PR exists (or you discard/commit cleanly). One-off helper scripts must be removed (`kynver worker discard-disposable --path <file>`) or committed before completion \u2014 maintenance/board-drain workers are not exempt. Exiting with only dirty files and no PR routes to salvage review, not production review.",
     "PR-ready handoff: for substantial implementation work, commit, push, and open a GitHub PR (draft OK) on your branch before finishing \u2014 or rely on the harness to run `gh pr create` at completion when `gh` is authenticated.",
     "Expert review / production-review workers (Dalton/Lorentz, plan-review-task, scheduledJob reviewer children): do NOT open new implementation PRs \u2014 review the parent task's existing PR and record reviewVerdict in finalResult; landing-contract targetPrReconciliation does not apply.",
-    "Worker resource guard: do not run full monorepo verification (`npm run typecheck`, `npm run build`, or equivalent) from this worker lane unless an operator explicitly requests it. Use targeted checks for touched paths and rely on CI/operator lanes for heavy gates.",
+    "Worker resource guard: do not run full monorepo verification (`npm run typecheck`, `npm run build`, or equivalent) from this worker lane unless an operator explicitly requests it. Use targeted checks for touched paths and rely on CI/operator lanes for heavy gates. When heavy verification is required, route through `node scripts/verify-pr-local.mjs` or `kynver harness verify` \u2014 they acquire the global heavy-verification lease so parallel workers do not launch simultaneous typechecks.",
     "npm publish boundary: do not run `npm publish`, do not republish `@kynver-app/*` packages, and do not block on an operator to publish. When you need newer runtime code than npm, use this repo checkout (`npm run kynver:build`, `npm run kynver`) and record evidence: packages/kynver-runtime/package.json version + git ref in your completion report.",
     "If verification fails (including OOM), append a heartbeat line immediately with the last command, failure reason, dirty-file status, commit/PR handoff state, and next action so recovery does not require log spelunking.",
     "Landing-wrapper cleanup on a git ref: use `node scripts/agent-os-land-pr-cleanup-verify.mjs --ref origin/main` (JSON, exit 0). Do not use `git show <ref>:scripts/agent-os-land-pr.mjs | rg \u2026` \u2014 ripgrep exit 1 when markers are absent is reported as a failed command in Telegram/status tooling.",
@@ -4982,8 +5047,8 @@ function dirtyPathsCoveredByDisposableRemoval(changedFiles, removed) {
   if (removed.length === 0) return false;
   const removedSet = new Set(removed.map((p) => normalizeRelativePath(p)));
   return material.every((line) => {
-    const path67 = normalizeRelativePath(pathFromGitStatusLine(line));
-    return removedSet.has(path67);
+    const path71 = normalizeRelativePath(pathFromGitStatusLine(line));
+    return removedSet.has(path71);
   });
 }
 
@@ -6277,7 +6342,7 @@ function collectRunActiveHarnessWorkers(runId) {
       path22.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
-    if (!worker?.taskId || !isPidAlive(worker.pid)) continue;
+    if (!worker?.taskId || !isActiveHarnessWorker(worker)) continue;
     out.push({
       runId: run.id,
       workerName: name,
@@ -6516,7 +6581,7 @@ function isTmpOnlyPath(filePath) {
 // src/plan-persist/outbox-store.ts
 import {
   existsSync as existsSync21,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   renameSync,
   readdirSync as readdirSync5,
   writeFileSync as writeFileSync3,
@@ -6544,7 +6609,7 @@ function findOutboxByIdempotencyKey(key) {
 function readOutboxItem(jsonPath) {
   if (!existsSync21(jsonPath)) return null;
   try {
-    return JSON.parse(readFileSync9(jsonPath, "utf8"));
+    return JSON.parse(readFileSync10(jsonPath, "utf8"));
   } catch {
     return null;
   }
@@ -6552,7 +6617,7 @@ function readOutboxItem(jsonPath) {
 function readOutboxBody(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
   const bodyFile = path24.join(outboxDir, item.bodyPath);
-  return readFileSync9(bodyFile, "utf8");
+  return readFileSync10(bodyFile, "utf8");
 }
 function writeOutboxItem(input, opts) {
   const { outboxDir } = ensurePlanOutboxDirs();
@@ -7138,7 +7203,7 @@ async function dispatchRun(args) {
         );
       }
       const attempt = Number(task.attempt) || 1;
-      if (attempt >= retryLimits.maxTaskAttempts) {
+      if (attempt > retryLimits.maxTaskAttempts) {
         return abortClaimedSpawn(
           task,
           `task attempt ${attempt} exceeds KYNVER_MAX_TASK_ATTEMPTS (${retryLimits.maxTaskAttempts})`
@@ -7274,7 +7339,12 @@ async function dispatchRun(args) {
     const admissionExhaustion = readAdmissionExhaustion(result);
     const capacityIdle = admissionExhaustion?.capacityIdle === true || startedCount === 0 && Number(result.resourceGate?.slotsAvailable) > 0;
     if (capacityIdle && admissionExhaustion?.summary) {
-      console.error(`[dispatch] ${admissionExhaustion.summary}`);
+      const retryCeiling = admissionExhaustion.skipReasonCounts?.retry_ceiling_exceeded ?? 0;
+      const recovery = admissionExhaustion.overAttemptIdleRecovery;
+      const recoveryNote = recovery?.attempted === true ? `; over_attempt_recovery minted=${recovery.minted ?? 0} started=${recovery.started ?? 0}` : retryCeiling > 0 ? "; over_attempt_recovery not attempted" : "";
+      console.error(
+        `[dispatch] ${admissionExhaustion.summary}${retryCeiling > 0 ? `; retry_ceiling_exceeded=${retryCeiling}` : ""}${recoveryNote}`
+      );
     }
     const summary = {
       runId: run.id,
@@ -7370,14 +7440,14 @@ async function sweepRun(args) {
 
 // src/worktree.ts
 import { existsSync as existsSync25, mkdirSync as mkdirSync6 } from "node:fs";
-import path34 from "node:path";
+import path35 from "node:path";
 
 // src/run-list.ts
-import { existsSync as existsSync24, readFileSync as readFileSync10 } from "node:fs";
-import path33 from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync11 } from "node:fs";
+import path34 from "node:path";
 
 // src/stale-reconcile.ts
-import path32 from "node:path";
+import path33 from "node:path";
 
 // src/finalize.ts
 import path27 from "node:path";
@@ -7960,6 +8030,193 @@ function reconcileWorkerMetadata() {
   return { workers: outcomes, runMetadataRetention };
 }
 
+// src/local-pr-attention-reconcile.ts
+import { execFileSync } from "node:child_process";
+import path32 from "node:path";
+function normalizePrUrl3(url) {
+  const m = url.trim().match(/github\.com\/([^/]+\/[^/]+)\/(?:pull|pulls)\/(\d+)/i);
+  if (!m) return null;
+  return `https://github.com/${m[1]}/pull/${m[2]}`;
+}
+function prNumberFromUrl(url) {
+  const m = normalizePrUrl3(url)?.match(/\/pull\/(\d+)$/);
+  if (!m) return null;
+  const n = Number.parseInt(m[1], 10);
+  return Number.isFinite(n) ? n : null;
+}
+function extractText(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function extractPrNumbersFromText(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(/github\.com\/[^/\s)>"']+\/[^/\s)>"']+\/(?:pull|pulls)\/(\d+)/gi)) {
+    const n = Number.parseInt(match[1], 10);
+    if (Number.isFinite(n)) out.add(n);
+  }
+  for (const match of text.matchAll(/\bPR\s*#?\s*(\d{2,})\b/gi)) {
+    const n = Number.parseInt(match[1], 10);
+    if (Number.isFinite(n)) out.add(n);
+  }
+  for (const match of text.matchAll(/\bpr[-_]?(\d{2,})\b/gi)) {
+    const n = Number.parseInt(match[1], 10);
+    if (Number.isFinite(n)) out.add(n);
+  }
+  return [...out];
+}
+function extractTargetPrReconciliation(value) {
+  let record = null;
+  if (typeof value === "string") record = extractEmbeddedWorkerFinalResultRecord(value);
+  else if (value && typeof value === "object" && !Array.isArray(value)) record = value;
+  if (!record) return [];
+  const raw = record.targetPrReconciliation ?? record.target_pr_reconciliation;
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const row = item;
+    const prUrl = normalizePrUrl3(String(row.prUrl ?? row.pr_url ?? ""));
+    const outcome = String(row.outcome ?? "").trim();
+    if (!prUrl || outcome !== "merged") continue;
+    out.push({
+      prUrl,
+      mergeCommit: typeof row.mergeCommit === "string" ? row.mergeCommit : typeof row.merge_commit === "string" ? row.merge_commit : null,
+      reason: typeof row.reason === "string" ? row.reason : null
+    });
+  }
+  return out;
+}
+function defaultLookupPr(input) {
+  try {
+    const repo = execFileSync("git", ["config", "--get", "remote.origin.url"], {
+      cwd: input.repoDir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const repoMatch = repo.match(/github\.com[:/]([^/]+\/[^/.]+)(?:\.git)?$/i);
+    const repoSlug = repoMatch?.[1];
+    if (!repoSlug) return null;
+    const raw = execFileSync(
+      "gh",
+      ["pr", "view", String(input.prNumber), "--repo", repoSlug, "--json", "state,mergedAt,mergeCommit,url"],
+      { cwd: input.repoDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    );
+    const parsed = JSON.parse(raw);
+    return {
+      prUrl: normalizePrUrl3(parsed.url ?? `https://github.com/${repoSlug}/pull/${input.prNumber}`) ?? `https://github.com/${repoSlug}/pull/${input.prNumber}`,
+      state: parsed.state ?? "",
+      mergedAt: parsed.mergedAt ?? null,
+      mergeCommit: parsed.mergeCommit?.oid ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+function finalResultForWorker(worker) {
+  const heartbeat = parseHeartbeat(worker.heartbeatPath);
+  return worker.completionSnapshot?.finalResult ?? terminalFinalResultFromHeartbeat(heartbeat);
+}
+function collectMergedEvidenceByPr(run) {
+  const byPr = /* @__PURE__ */ new Map();
+  const runDir2 = runDirectory(run.id);
+  for (const name of listRunWorkerNames(run)) {
+    const worker = readJson(
+      path32.join(runDir2, "workers", safeSlug(name), "worker.json"),
+      void 0
+    );
+    if (!worker) continue;
+    for (const evidence of extractTargetPrReconciliation(finalResultForWorker(worker))) {
+      const n = prNumberFromUrl(evidence.prUrl);
+      if (n != null && !byPr.has(n)) byPr.set(n, evidence);
+    }
+  }
+  return byPr;
+}
+function candidatePrNumbers(worker, statusFinalResult) {
+  const heartbeat = parseHeartbeat(worker.heartbeatPath);
+  const text = [
+    worker.name,
+    worker.repairTargetPrUrl,
+    worker.taskPrUrl,
+    worker.branch,
+    heartbeat.lastHeartbeatSummary,
+    extractText(statusFinalResult)
+  ].filter(Boolean).join("\n");
+  return extractPrNumbersFromText(text);
+}
+function isLocalOnlyAttentionNoise(worker) {
+  return worker.localOnly === true && !worker.taskId && !worker.agentOsId;
+}
+function reconcileLocalOnlyMergedPrAttention(options = {}) {
+  const lookupPr = options.lookupPr ?? defaultLookupPr;
+  const outcomes = [];
+  const liveLookupCache = /* @__PURE__ */ new Map();
+  for (const run of listRunRecords()) {
+    const mergedByPr = collectMergedEvidenceByPr(run);
+    const runDir2 = runDirectory(run.id);
+    for (const name of listRunWorkerNames(run)) {
+      const workerPath = path32.join(runDir2, "workers", safeSlug(name), "worker.json");
+      const worker = readJson(workerPath, void 0);
+      if (!worker || !isLocalOnlyAttentionNoise(worker)) continue;
+      const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
+      if (status.attention.state !== "needs_attention") continue;
+      let merged = null;
+      for (const prNumber of candidatePrNumbers(worker, status.finalResult)) {
+        merged = mergedByPr.get(prNumber) ?? null;
+        if (!merged) {
+          const repoDir = run.repo || worker.worktreePath;
+          const cacheKey = `${repoDir}#${prNumber}`;
+          const live = liveLookupCache.has(cacheKey) ? liveLookupCache.get(cacheKey) ?? null : lookupPr({ repoDir, prNumber });
+          if (!liveLookupCache.has(cacheKey)) liveLookupCache.set(cacheKey, live);
+          if (live && (live.state === "MERGED" || live.mergedAt)) {
+            merged = { prUrl: live.prUrl, mergeCommit: live.mergeCommit ?? null, reason: "GitHub reports PR merged" };
+          }
+        }
+        if (merged) break;
+      }
+      if (!merged) {
+        outcomes.push({ runId: run.id, worker: name, action: "skipped", reason: "no merged PR evidence" });
+        continue;
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      worker.status = "done";
+      worker.completionSnapshot = {
+        prUrl: merged.prUrl,
+        summary: `Local-only worker superseded by merged PR ${merged.prUrl}`,
+        finalResult: {
+          summary: `Local-only repair/salvage worker superseded by merged PR ${merged.prUrl}`,
+          targetPrReconciliation: [
+            {
+              prUrl: merged.prUrl,
+              outcome: "merged",
+              mergeCommit: merged.mergeCommit ?? null,
+              reason: merged.reason ?? "PR already merged; local-only worker no longer requires attention"
+            }
+          ]
+        }
+      };
+      worker.completionAckSource = "local-pr-merged-reconcile";
+      worker.reconciledAt = now;
+      worker.reconcileReason = "local-only needs_attention superseded by merged PR";
+      saveWorker(run.id, worker);
+      outcomes.push({
+        runId: run.id,
+        worker: name,
+        action: "marked_done",
+        reason: worker.reconcileReason,
+        prUrl: merged.prUrl,
+        mergeCommit: merged.mergeCommit ?? null
+      });
+    }
+  }
+  return { workers: outcomes };
+}
+
 // src/stale-reconcile.ts
 var STALE_RECONCILE_HEARTBEAT_MS = 15 * 60 * 1e3;
 function staleReconcileDisabled() {
@@ -7968,13 +8225,14 @@ function staleReconcileDisabled() {
 function reconcileStaleWorkers() {
   const metadataReconcile = reconcileWorkerMetadata();
   if (staleReconcileDisabled()) {
-    return { workers: [], finalizedRuns: finalizeStaleRuns(), metadataReconcile };
+    const localPrAttentionReconcile2 = reconcileLocalOnlyMergedPrAttention();
+    return { workers: [], finalizedRuns: finalizeStaleRuns(), metadataReconcile, localPrAttentionReconcile: localPrAttentionReconcile2 };
   }
   const outcomes = [];
   const now = Date.now();
   for (const run of listRunRecords()) {
     for (const name of listRunWorkerNames(run)) {
-      const workerPath = path32.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path33.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker || worker.status !== "running") {
         outcomes.push({
@@ -8046,7 +8304,8 @@ function reconcileStaleWorkers() {
       });
     }
   }
-  return { workers: outcomes, finalizedRuns: finalizeStaleRuns(), metadataReconcile };
+  const localPrAttentionReconcile = reconcileLocalOnlyMergedPrAttention();
+  return { workers: outcomes, finalizedRuns: finalizeStaleRuns(), metadataReconcile, localPrAttentionReconcile };
 }
 function reconcileRunsCli() {
   const result = reconcileStaleWorkers();
@@ -8057,6 +8316,10 @@ function reconcileRunsCli() {
     acc[row.action] = (acc[row.action] ?? 0) + 1;
     return acc;
   }, {});
+  const localPrAttentionTotals = result.localPrAttentionReconcile.workers.reduce((acc, row) => {
+    acc[row.action] = (acc[row.action] ?? 0) + 1;
+    return acc;
+  }, {});
   const runRetentionTotals = result.metadataReconcile.runMetadataRetention.runs.reduce((acc, row) => {
     acc[row.action] = (acc[row.action] ?? 0) + 1;
     return acc;
@@ -8074,10 +8337,15 @@ function reconcileRunsCli() {
             total: result.metadataReconcile.runMetadataRetention.runs.length
           }
         },
+        localPrAttentionReconcile: {
+          totals: localPrAttentionTotals,
+          total: result.localPrAttentionReconcile.workers.length
+        },
         finalizedRuns: result.finalizedRuns.length,
         details: {
           workers: result.workers,
           metadataReconcile: result.metadataReconcile.workers,
+          localPrAttentionReconcile: result.localPrAttentionReconcile.workers,
           runMetadataRetention: result.metadataReconcile.runMetadataRetention.runs,
           finalizedRuns: result.finalizedRuns
         }
@@ -8092,13 +8360,13 @@ function reconcileRunsCli() {
 function heartbeatByteLength(heartbeatPath) {
   if (!heartbeatPath || !existsSync24(heartbeatPath)) return 0;
   try {
-    return readFileSync10(heartbeatPath, "utf8").trim().length;
+    return readFileSync11(heartbeatPath, "utf8").trim().length;
   } catch {
     return 0;
   }
 }
 function workerEvidence(run, workerName) {
-  const workerPath = path33.join(runDirectory(run.id), "workers", safeSlug(workerName), "worker.json");
+  const workerPath = path34.join(runDirectory(run.id), "workers", safeSlug(workerName), "worker.json");
   const worker = readJson(workerPath, void 0);
   if (!worker) {
     return {
@@ -8155,7 +8423,7 @@ function aggregateRunAttention(workers) {
 function countOpenWorkers(run) {
   let open = 0;
   for (const name of listRunWorkerNames(run)) {
-    const workerPath = path33.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+    const workerPath = path34.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 });
@@ -8231,7 +8499,7 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path34.join(dir, "run.json"), run);
+  writeJson(path35.join(dir, "run.json"), run);
   console.log(JSON.stringify({ runId: id, runDir: dir, repo, base, baseCommit }, null, 2));
 }
 function listRuns() {
@@ -8244,7 +8512,7 @@ function failExists(message) {
 
 // src/discard-disposable.ts
 import { existsSync as existsSync26, rmSync as rmSync2 } from "node:fs";
-import path35 from "node:path";
+import path36 from "node:path";
 function normalizeRelativePath2(value) {
   const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").trim();
   if (!normalized || normalized.startsWith("/") || normalized.includes("..")) {
@@ -8266,12 +8534,12 @@ function discardDisposableArtifacts(args) {
   if (paths.length === 0) {
     return { ok: false, removed: [], reason: "requires at least one --path" };
   }
-  const worktreeRoot = path35.resolve(worker.worktreePath);
+  const worktreeRoot = path36.resolve(worker.worktreePath);
   const removed = [];
   for (const raw of paths) {
     const rel = normalizeRelativePath2(raw);
-    const abs = path35.resolve(worktreeRoot, rel);
-    if (!abs.startsWith(worktreeRoot + path35.sep) && abs !== worktreeRoot) {
+    const abs = path36.resolve(worktreeRoot, rel);
+    if (!abs.startsWith(worktreeRoot + path36.sep) && abs !== worktreeRoot) {
       return { ok: false, removed, reason: `path escapes worktree: ${raw}` };
     }
     if (!existsSync26(abs)) {
@@ -8338,7 +8606,7 @@ function validateDaemonInstallIdentity(config = loadUserConfig(), env = process.
 // src/cron/cron-env.ts
 import { existsSync as existsSync27 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import path36 from "node:path";
+import path37 from "node:path";
 function envFlag(name, defaultValue) {
   const raw = process.env[name]?.trim().toLowerCase();
   if (!raw) return defaultValue;
@@ -8354,7 +8622,7 @@ function envInt(name, fallback, min = 1) {
 function defaultKynverCronStorePath() {
   const explicit = process.env.KYNVER_CRON_STORE_PATH?.trim() || process.env.OPENCLAW_CRON_STORE_PATH?.trim();
   if (explicit) return explicit;
-  return path36.join(homedir11(), ".kynver", "agent-os-cron.json");
+  return path37.join(homedir11(), ".kynver", "agent-os-cron.json");
 }
 function defaultKynverCronStatePath(storePath = defaultKynverCronStorePath()) {
   const explicit = process.env.KYNVER_CRON_TICK_STATE_PATH?.trim();
@@ -8427,12 +8695,12 @@ async function fireKynverCronJob(input) {
 }
 
 // src/cron/cron-lock.ts
-import { closeSync as closeSync6, existsSync as existsSync28, openSync as openSync6, readFileSync as readFileSync11, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { closeSync as closeSync6, existsSync as existsSync28, openSync as openSync6, readFileSync as readFileSync12, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "node:fs";
 var STALE_LOCK_MS = 10 * 6e4;
 function readLockInfo(lockPath) {
   if (!existsSync28(lockPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync11(lockPath, "utf8"));
+    const parsed = JSON.parse(readFileSync12(lockPath, "utf8"));
     if (typeof parsed.pid === "number" && typeof parsed.at === "string") return parsed;
   } catch {
     return null;
@@ -8596,7 +8864,7 @@ async function loadCronJobs(storePath = defaultKynverCronStorePath()) {
 // src/cron/cron-tick-state.ts
 import { randomBytes } from "node:crypto";
 import { promises as fs2 } from "node:fs";
-import path37 from "node:path";
+import path38 from "node:path";
 var EMPTY = { version: 1, jobs: {} };
 async function readFileIfExists2(filePath) {
   try {
@@ -8623,7 +8891,7 @@ async function loadCronTickState(statePath) {
   return parseCronTickState(raw);
 }
 async function writeStateAtomic(statePath, state) {
-  await fs2.mkdir(path37.dirname(statePath), { recursive: true });
+  await fs2.mkdir(path38.dirname(statePath), { recursive: true });
   const suffix = randomBytes(6).toString("hex");
   const tmp = `${statePath}.tmp-${process.pid}-${Date.now()}-${suffix}`;
   await fs2.writeFile(tmp, `${JSON.stringify(state, null, 2)}
@@ -8800,7 +9068,7 @@ async function runKynverCronTick(opts = {}) {
 }
 
 // src/pipeline-tick.ts
-import path55 from "node:path";
+import path56 from "node:path";
 
 // src/pipeline-dispatch.ts
 var RESERVED_REVIEW_STARTS = 1;
@@ -8956,7 +9224,7 @@ function buildBoxResourceSnapshotFromGate(gate, input = {}) {
 }
 
 // src/plan-progress-daemon-sync.ts
-import path38 from "node:path";
+import path39 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -8980,7 +9248,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path38.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path39.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -9037,10 +9305,10 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 }
 
 // src/cleanup.ts
-import path52 from "node:path";
+import path53 from "node:path";
 
 // src/cleanup-guards.ts
-import path39 from "node:path";
+import path40 from "node:path";
 
 // src/cleanup-build-cache-paths.ts
 var HARNESS_BUILD_CACHE_RELATIVE_PATHS = [
@@ -9181,7 +9449,7 @@ function skipWorktreeRemoval(input) {
 function skipDependencyCacheRemoval(input) {
   const { indexed, nodeModulesAgeMs, ageMs, worktreePath, activeWorktreePaths, diskPressure } = input;
   if (!diskPressure && ageMs < nodeModulesAgeMs) return "below_age_threshold";
-  if (activeWorktreePaths.has(path39.resolve(worktreePath))) return "active_worker";
+  if (activeWorktreePaths.has(path40.resolve(worktreePath))) return "active_worker";
   if (indexed && isWorkerProcessLive(indexed)) return "active_worker";
   if (indexed && indexedWorktreeHasMaterialChanges(indexed)) return "dirty_worktree";
   return null;
@@ -9208,11 +9476,11 @@ var LIVE_SKIP_REASONS = /* @__PURE__ */ new Set([
 function collectPreservedLivePaths(actions, skips) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const push = (path67, reason, detail) => {
-    const key = `${path67}\0${reason}`;
+  const push = (path71, reason, detail) => {
+    const key = `${path71}\0${reason}`;
     if (seen.has(key) || out.length >= MAX_PRESERVED_LIVE_PATH_SAMPLES) return;
     seen.add(key);
-    out.push({ path: path67, reason, ...detail ? { detail } : {} });
+    out.push({ path: path71, reason, ...detail ? { detail } : {} });
   };
   for (const skip2 of skips) {
     if (!LIVE_SKIP_REASONS.has(skip2.reason)) continue;
@@ -9228,11 +9496,11 @@ function collectPreservedLivePaths(actions, skips) {
 
 // src/cleanup-run-directory.ts
 import { existsSync as existsSync30, readdirSync as readdirSync9, statSync as statSync7 } from "node:fs";
-import path41 from "node:path";
+import path42 from "node:path";
 
 // src/cleanup-active-worktrees.ts
 import { existsSync as existsSync29, readdirSync as readdirSync8, statSync as statSync6 } from "node:fs";
-import path40 from "node:path";
+import path41 from "node:path";
 function workerHasRecentHarnessActivity(worker, now) {
   const paths = [worker.heartbeatPath, worker.stdoutPath, worker.stderrPath];
   for (const target of paths) {
@@ -9258,11 +9526,11 @@ function collectActiveWorktreeGuards(harnessRoots, now = Date.now()) {
       let runHasLive = false;
       for (const name of Object.keys(run.workers || {})) {
         const worker = readJson(
-          path40.join(runDirectoryAt(harnessRoot, run.id), "workers", safeSlug(name), "worker.json"),
+          path41.join(runDirectoryAt(harnessRoot, run.id), "workers", safeSlug(name), "worker.json"),
           void 0
         );
         if (!worker?.worktreePath) continue;
-        const worktreePath = path40.resolve(worker.worktreePath);
+        const worktreePath = path41.resolve(worker.worktreePath);
         if (!isActiveHarnessWorker2(worker, now)) continue;
         runHasLive = true;
         activeWorktreePaths.add(worktreePath);
@@ -9290,7 +9558,7 @@ function pathAgeMs(target, now) {
   }
 }
 function loadRunStatus(harnessRoot, runId) {
-  const runPath = path41.join(harnessRoot, "runs", runId, "run.json");
+  const runPath = path42.join(harnessRoot, "runs", runId, "run.json");
   if (!existsSync30(runPath)) return null;
   return readJson(runPath, null);
 }
@@ -9326,7 +9594,7 @@ function scanStaleRunDirectoryCandidates(opts) {
     if (!runEntry.isDirectory()) continue;
     const runId = runEntry.name;
     if (opts.runIdFilter && runId !== opts.runIdFilter) continue;
-    const runPath = path41.join(opts.worktreesDir, runId);
+    const runPath = path42.join(opts.worktreesDir, runId);
     if (!runDirectoryIsEmpty(runPath)) continue;
     candidates.push({
       kind: "remove_run_directory",
@@ -9344,14 +9612,14 @@ function scanStaleRunDirectoryCandidates(opts) {
 import { existsSync as existsSync33, rmSync as rmSync4 } from "node:fs";
 
 // src/cleanup-dir-size.ts
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync as existsSync31, readdirSync as readdirSync10, statSync as statSync8 } from "node:fs";
-import path42 from "node:path";
+import path43 from "node:path";
 var DEFAULT_DU_TIMEOUT_MS = 2500;
 function directorySizeBytesDu(root, timeoutMs = DEFAULT_DU_TIMEOUT_MS) {
   if (!existsSync31(root)) return 0;
   try {
-    const out = execFileSync("du", ["-sb", root], {
+    const out = execFileSync2("du", ["-sb", root], {
       encoding: "utf8",
       timeout: timeoutMs,
       stdio: ["ignore", "pipe", "ignore"]
@@ -9380,7 +9648,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path42.join(current, name);
+      const full = path43.join(current, name);
       let st;
       try {
         st = statSync8(full);
@@ -9431,20 +9699,20 @@ function pathHasForeignOwnedEntry(targetPath, maxEntries = 32) {
 
 // src/cleanup-privileged-remove.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import path44 from "node:path";
+import path45 from "node:path";
 
 // src/cleanup-harness-path-validate.ts
-import path43 from "node:path";
+import path44 from "node:path";
 function isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, cacheDirName) {
-  const resolved = path43.resolve(targetPath);
-  const suffix = `${path43.sep}${cacheDirName}`;
+  const resolved = path44.resolve(targetPath);
+  const suffix = `${path44.sep}${cacheDirName}`;
   const cachePath = resolved.endsWith(suffix) ? resolved : null;
   if (!cachePath) return "path_outside_harness";
-  const rel = path43.relative(worktreesDir, cachePath);
-  if (rel.startsWith("..") || path43.isAbsolute(rel)) return "path_outside_harness";
-  const parts = rel.split(path43.sep);
+  const rel = path44.relative(worktreesDir, cachePath);
+  if (rel.startsWith("..") || path44.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path44.sep);
   if (parts.length < 3 || parts[parts.length - 1] !== cacheDirName) return "path_outside_harness";
-  if (!resolved.startsWith(path43.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path44.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
@@ -9454,16 +9722,16 @@ function isHarnessNextCachePath(targetPath, harnessRoot, worktreesDir) {
   return isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, ".next");
 }
 function isHarnessBuildCachePath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path43.resolve(targetPath);
-  const relToWt = path43.relative(worktreesDir, resolved);
-  if (relToWt.startsWith("..") || path43.isAbsolute(relToWt)) return "path_outside_harness";
-  const parts = relToWt.split(path43.sep);
+  const resolved = path44.resolve(targetPath);
+  const relToWt = path44.relative(worktreesDir, resolved);
+  if (relToWt.startsWith("..") || path44.isAbsolute(relToWt)) return "path_outside_harness";
+  const parts = relToWt.split(path44.sep);
   if (parts.length < 3) return "path_outside_harness";
-  if (!resolved.startsWith(path43.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path44.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 function isHarnessGeneratedCachePath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path43.resolve(targetPath);
+  const resolved = path44.resolve(targetPath);
   return isHarnessNodeModulesPath(resolved, harnessRoot, worktreesDir) === null || isHarnessNextCachePath(resolved, harnessRoot, worktreesDir) === null || isHarnessBuildCachePath(resolved, harnessRoot, worktreesDir) === null;
 }
 
@@ -9497,12 +9765,12 @@ function tryPrivilegedReclaimHarnessCache(targetPath, harnessRoot, worktreesDir)
     "chown",
     "-R",
     `${effectiveUid}:${effectiveGid}`,
-    path44.resolve(targetPath)
+    path45.resolve(targetPath)
   ]);
   if (chown.ok) {
     return { ok: true, method: "chown_then_rm" };
   }
-  const rm = runSudoNonInteractive(["rm", "-rf", path44.resolve(targetPath)]);
+  const rm = runSudoNonInteractive(["rm", "-rf", path45.resolve(targetPath)]);
   if (rm.ok) {
     return { ok: true, method: "sudo_rm" };
   }
@@ -9704,7 +9972,7 @@ function removeWorktree(candidate, execute) {
 
 // src/cleanup-scan.ts
 import { existsSync as existsSync34, readdirSync as readdirSync12, statSync as statSync9 } from "node:fs";
-import path45 from "node:path";
+import path46 from "node:path";
 function pathAgeMs2(target, now) {
   try {
     const mtime = statSync9(target).mtimeMs;
@@ -9714,16 +9982,16 @@ function pathAgeMs2(target, now) {
   }
 }
 function isPathInside(child, parent) {
-  const rel = path45.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path45.isAbsolute(rel);
+  const rel = path46.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path46.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 = path45.join(worktreePath, rel);
+    const target = path46.join(worktreePath, rel);
     if (!existsSync34(target)) continue;
-    const resolved = path45.resolve(target);
+    const resolved = path46.resolve(target);
     if (seen.has(resolved)) continue;
     if (!isPathInside(resolved, opts.harnessRoot)) continue;
     seen.add(resolved);
@@ -9755,10 +10023,10 @@ function scanBuildCacheCandidates(opts) {
   if (!opts.includeOrphans || !existsSync34(opts.worktreesDir)) return candidates;
   for (const runEntry of readdirSync12(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path45.join(opts.worktreesDir, runEntry.name);
+    const runPath = path46.join(opts.worktreesDir, runEntry.name);
     for (const workerEntry of readdirSync12(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path45.join(runPath, workerEntry.name);
+      const worktreePath = path46.join(runPath, workerEntry.name);
       candidates.push(
         ...collectBuildCacheForWorktree(worktreePath, opts, seen, {
           runId: runEntry.name,
@@ -9796,12 +10064,12 @@ function scanWorktreeCandidates(opts) {
   if (!orphanEnabled || !existsSync34(opts.worktreesDir)) return candidates;
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path45.resolve(entry.worktreePath));
+    indexedPaths.add(path46.resolve(entry.worktreePath));
   }
   for (const runEntry of readdirSync12(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path45.join(opts.worktreesDir, runEntry.name);
+    const runPath = path46.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
       workerEntries = readdirSync12(runPath, { withFileTypes: true });
@@ -9810,7 +10078,7 @@ function scanWorktreeCandidates(opts) {
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path45.resolve(path45.join(runPath, workerEntry.name));
+      const worktreePath = path46.resolve(path46.join(runPath, workerEntry.name));
       if (seen.has(worktreePath)) continue;
       if (indexedPaths.has(worktreePath)) continue;
       if (!isPathInside(worktreePath, opts.harnessRoot)) continue;
@@ -9830,7 +10098,7 @@ function scanWorktreeCandidates(opts) {
 
 // src/cleanup-dependency-scan.ts
 import { existsSync as existsSync35, readdirSync as readdirSync13, statSync as statSync10 } from "node:fs";
-import path46 from "node:path";
+import path47 from "node:path";
 var DEPENDENCY_CACHE_DIRS = [
   { dirName: "node_modules", kind: "remove_node_modules" },
   { dirName: ".next", kind: "remove_next_cache" }
@@ -9844,12 +10112,12 @@ function pathAgeMs3(target, now) {
   }
 }
 function isPathInside2(child, parent) {
-  const rel = path46.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path46.isAbsolute(rel);
+  const rel = path47.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path47.isAbsolute(rel);
 }
 function pushCandidate2(candidates, seen, opts, targetPath, kind, meta) {
   if (!existsSync35(targetPath)) return;
-  const resolved = path46.resolve(targetPath);
+  const resolved = path47.resolve(targetPath);
   if (seen.has(resolved)) return;
   if (!isPathInside2(resolved, opts.harnessRoot)) return;
   seen.add(resolved);
@@ -9866,7 +10134,7 @@ function pushCandidate2(candidates, seen, opts, targetPath, kind, meta) {
 }
 function scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, meta) {
   for (const entry of DEPENDENCY_CACHE_DIRS) {
-    pushCandidate2(candidates, seen, opts, path46.join(worktreePath, entry.dirName), entry.kind, meta);
+    pushCandidate2(candidates, seen, opts, path47.join(worktreePath, entry.dirName), entry.kind, meta);
   }
 }
 function scanDependencyCacheCandidates(opts) {
@@ -9884,7 +10152,7 @@ function scanDependencyCacheCandidates(opts) {
   for (const runEntry of readdirSync13(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path46.join(opts.worktreesDir, runEntry.name);
+    const runPath = path47.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
       workerEntries = readdirSync13(runPath, { withFileTypes: true });
@@ -9893,7 +10161,7 @@ function scanDependencyCacheCandidates(opts) {
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path46.join(runPath, workerEntry.name);
+      const worktreePath = path47.join(runPath, workerEntry.name);
       scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, {
         runId: runEntry.name,
         worker: workerEntry.name
@@ -9905,7 +10173,7 @@ function scanDependencyCacheCandidates(opts) {
 
 // src/cleanup-duplicate-worktrees.ts
 import { existsSync as existsSync36, statSync as statSync11 } from "node:fs";
-import path47 from "node:path";
+import path48 from "node:path";
 function pathAgeMs4(target, now) {
   try {
     const mtime = statSync11(target).mtimeMs;
@@ -9935,8 +10203,8 @@ function parseWorktreePorcelain(output) {
   return records;
 }
 function isUnderWorktreesDir(worktreePath, worktreesDir) {
-  const rel = path47.relative(path47.resolve(worktreesDir), path47.resolve(worktreePath));
-  return rel !== "" && !rel.startsWith("..") && !path47.isAbsolute(rel);
+  const rel = path48.relative(path48.resolve(worktreesDir), path48.resolve(worktreePath));
+  return rel !== "" && !rel.startsWith("..") && !path48.isAbsolute(rel);
 }
 function isCleanWorktree(worktreePath, repoRoot) {
   try {
@@ -9952,11 +10220,11 @@ function scanDuplicateWorktreeCandidates(opts) {
   if (!opts.includeOrphans || !existsSync36(opts.worktreesDir)) return [];
   const repos = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    if (entry.run.repo) repos.add(path47.resolve(entry.run.repo));
+    if (entry.run.repo) repos.add(path48.resolve(entry.run.repo));
   }
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path47.resolve(entry.worktreePath));
+    indexedPaths.add(path48.resolve(entry.worktreePath));
   }
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -9969,15 +10237,15 @@ function scanDuplicateWorktreeCandidates(opts) {
     }
     const worktrees = parseWorktreePorcelain(porcelain);
     for (const wt of worktrees) {
-      const resolved = path47.resolve(wt.path);
-      if (resolved === path47.resolve(repoRoot)) continue;
+      const resolved = path48.resolve(wt.path);
+      if (resolved === path48.resolve(repoRoot)) continue;
       if (!isUnderWorktreesDir(resolved, opts.worktreesDir)) continue;
       if (indexedPaths.has(resolved)) continue;
       if (seen.has(resolved)) continue;
       if (!existsSync36(resolved)) continue;
       if (!isCleanWorktree(resolved, repoRoot)) continue;
-      const rel = path47.relative(opts.worktreesDir, resolved);
-      const parts = rel.split(path47.sep);
+      const rel = path48.relative(opts.worktreesDir, resolved);
+      const parts = rel.split(path48.sep);
       const runId = parts[0];
       const worker = parts[1] ?? "unknown";
       seen.add(resolved);
@@ -9996,12 +10264,12 @@ function scanDuplicateWorktreeCandidates(opts) {
 }
 
 // src/cleanup-worktree-index.ts
-import path48 from "node:path";
+import path49 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 = path48.join(
+      const workerPath = path49.join(
         runDirectoryAt(harnessRoot, run.id),
         "workers",
         safeSlug(name),
@@ -10009,9 +10277,9 @@ function buildWorktreeIndexAt(harnessRoot) {
       );
       const worker = readJson(workerPath, void 0);
       if (!worker?.worktreePath) continue;
-      index.set(path48.resolve(worker.worktreePath), {
+      index.set(path49.resolve(worker.worktreePath), {
         harnessRoot,
-        worktreePath: path48.resolve(worker.worktreePath),
+        worktreePath: path49.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -10081,14 +10349,14 @@ function resolvePipelineHarnessRetention(runId) {
 
 // src/cleanup-orphan-safety.ts
 import { existsSync as existsSync37, statSync as statSync12 } from "node:fs";
-import path49 from "node:path";
+import path50 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 (!existsSync37(input.worktreePath)) return null;
   if (input.runId && input.workerName) {
-    const heartbeatPath = path49.join(
+    const heartbeatPath = path50.join(
       input.harnessRoot,
       "runs",
       input.runId,
@@ -10102,7 +10370,7 @@ function assessOrphanWorktreeSafety(input) {
     } catch {
     }
   }
-  const gitDir = path49.join(input.worktreePath, ".git");
+  const gitDir = path50.join(input.worktreePath, ".git");
   if (!existsSync37(gitDir)) return null;
   const porcelain = gitCapture(input.worktreePath, ["status", "--porcelain"]);
   if (porcelain.status !== 0) return "pr_or_unmerged_commits";
@@ -10133,7 +10401,7 @@ function assessOrphanWorktreeSafety(input) {
 
 // src/harness-storage-snapshot.ts
 import { existsSync as existsSync38, readdirSync as readdirSync14, statSync as statSync13 } from "node:fs";
-import path50 from "node:path";
+import path51 from "node:path";
 function harnessStorageSnapshot(opts = {}) {
   const harnessRoot = normalizeHarnessRoot(opts.harnessRoot ?? resolveHarnessRoot());
   const worktreesDir = harnessWorktreesDir(harnessRoot);
@@ -10171,7 +10439,7 @@ function harnessStorageSnapshot(opts = {}) {
   for (const runEntry of entries) {
     if (!runEntry.isDirectory()) continue;
     runCount += 1;
-    const runPath = path50.join(worktreesDir, runEntry.name);
+    const runPath = path51.join(worktreesDir, runEntry.name);
     try {
       const st = statSync13(runPath);
       oldestMs = oldestMs === null ? st.mtimeMs : Math.min(oldestMs, st.mtimeMs);
@@ -10208,10 +10476,10 @@ function harnessStorageSnapshot(opts = {}) {
 // src/cleanup-harness-roots.ts
 import { existsSync as existsSync39 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import path51 from "node:path";
+import path52 from "node:path";
 var WELL_KNOWN_HARNESS_SCAN_ROOTS = [
   "/var/tmp/kynver-harness",
-  path51.join(homedir12(), ".openclaw", "harness")
+  path52.join(homedir12(), ".openclaw", "harness")
 ];
 function addRoot(seen, roots, candidate) {
   if (!candidate?.trim()) return;
@@ -10233,7 +10501,7 @@ function resolveHarnessScanRoots(options = {}) {
   for (const candidate of extra ?? []) addRoot(seen, roots, candidate);
   if (shouldScanWellKnownRoots(options)) {
     for (const candidate of WELL_KNOWN_HARNESS_SCAN_ROOTS) {
-      const resolved = path51.resolve(candidate);
+      const resolved = path52.resolve(candidate);
       if (!seen.has(resolved) && existsSync39(resolved)) addRoot(seen, roots, resolved);
     }
   }
@@ -10388,9 +10656,9 @@ function mergeWorktreeIndexes(scanRoots) {
 }
 function worktreePathForCandidate(candidate, worktreesDir) {
   if (candidate.runId && candidate.worker) {
-    return path52.join(worktreesDir, candidate.runId, candidate.worker);
+    return path53.join(worktreesDir, candidate.runId, candidate.worker);
   }
-  return path52.resolve(candidate.path, "..");
+  return path53.resolve(candidate.path, "..");
 }
 function runHarnessCleanup(options = {}) {
   let retention = resolveHarnessRetention(options);
@@ -10415,7 +10683,7 @@ function runHarnessCleanup(options = {}) {
   for (const harnessRoot of paths.scanRoots) {
     if (atSweepCap()) break;
     emitCleanupProgress("root", harnessRoot);
-    const worktreesDir = path52.join(harnessRoot, "worktrees");
+    const worktreesDir = path53.join(harnessRoot, "worktrees");
     const scanOpts = {
       harnessRoot,
       worktreesDir,
@@ -10428,7 +10696,7 @@ function runHarnessCleanup(options = {}) {
     };
     for (const raw of scanDependencyCacheCandidates(scanOpts)) {
       if (atSweepCap()) break;
-      const resolved = path52.resolve(raw.path);
+      const resolved = path53.resolve(raw.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const candidate = { ...raw, path: resolved };
@@ -10439,7 +10707,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path52.resolve(worktreePath)) ?? null;
+      const indexed = index.get(path53.resolve(worktreePath)) ?? null;
       const guardReason = skipDependencyCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -10463,7 +10731,7 @@ function runHarnessCleanup(options = {}) {
     }
     for (const raw of scanBuildCacheCandidates(scanOpts)) {
       if (atSweepCap()) break;
-      const resolved = path52.resolve(raw.path);
+      const resolved = path53.resolve(raw.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const candidate = { ...raw, path: resolved };
@@ -10474,7 +10742,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path52.resolve(worktreePath)) ?? null;
+      const indexed = index.get(path53.resolve(worktreePath)) ?? null;
       const guardReason = skipBuildCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -10504,11 +10772,11 @@ function runHarnessCleanup(options = {}) {
     const worktreeSeen = /* @__PURE__ */ new Set();
     for (const raw of worktreeCandidates) {
       if (atSweepCap()) break;
-      const resolved = path52.resolve(raw.path);
+      const resolved = path53.resolve(raw.path);
       if (worktreeSeen.has(resolved)) continue;
       worktreeSeen.add(resolved);
       const candidate = { ...raw, path: resolved };
-      const indexed = index.get(path52.resolve(candidate.path)) ?? null;
+      const indexed = index.get(path53.resolve(candidate.path)) ?? null;
       const orphanSafety = indexed ? null : assessOrphanWorktreeSafety({
         worktreePath: candidate.path,
         harnessRoot,
@@ -10518,7 +10786,7 @@ function runHarnessCleanup(options = {}) {
       });
       const guardSkip = skipWorktreeRemoval({
         indexed,
-        worktreePath: path52.resolve(candidate.path),
+        worktreePath: path53.resolve(candidate.path),
         includeOrphans: retention.includeOrphans,
         worktreesAgeMs: retention.worktreesAgeMs,
         terminalWorktreesAgeMs: retention.terminalWorktreesAgeMs,
@@ -10550,11 +10818,11 @@ function runHarnessCleanup(options = {}) {
         now: paths.now
       })) {
         if (atSweepCap()) break;
-        const resolved = path52.resolve(raw.path);
+        const resolved = path53.resolve(raw.path);
         if (processedPaths.has(resolved)) continue;
         processedPaths.add(resolved);
         const candidate = { ...raw, path: resolved };
-        const runId = candidate.runId ?? path52.basename(resolved);
+        const runId = candidate.runId ?? path53.basename(resolved);
         const dirSkip = skipRunDirectoryRemoval({
           harnessRoot,
           runId,
@@ -10690,11 +10958,11 @@ function isPipelineCleanupEnabled() {
 // src/installed-package-versions.ts
 import { readFile } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
-import path54 from "node:path";
+import path55 from "node:path";
 
 // src/memory-cost-package-version-guard.ts
-import { existsSync as existsSync40, readFileSync as readFileSync12 } from "node:fs";
-import path53 from "node:path";
+import { existsSync as existsSync40, readFileSync as readFileSync13 } from "node:fs";
+import path54 from "node:path";
 var MEMORY_COST_PACKAGE_MIN_VERSIONS = {
   "@kynver-app/runtime": "0.1.83",
   "@kynver-app/openclaw-agent-os": "0.1.43",
@@ -10745,7 +11013,7 @@ function maxSemver(versions) {
 }
 function readPackageJsonVersion(packageJsonPath) {
   try {
-    const parsed = JSON.parse(readFileSync12(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(readFileSync13(packageJsonPath, "utf8"));
     return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : null;
   } catch {
     return null;
@@ -10756,8 +11024,8 @@ function resolveRepoRoot(cwd, explicitRepoRoot) {
     (value) => Boolean(value?.trim())
   );
   for (const candidate of candidates) {
-    const resolved = path53.resolve(candidate);
-    if (existsSync40(path53.join(resolved, "packages/kynver-runtime/package.json")) && existsSync40(path53.join(resolved, "package.json"))) {
+    const resolved = path54.resolve(candidate);
+    if (existsSync40(path54.join(resolved, "packages/kynver-runtime/package.json")) && existsSync40(path54.join(resolved, "package.json"))) {
       return resolved;
     }
   }
@@ -10770,7 +11038,7 @@ function probeRepoPackageVersions(input = {}) {
   if (!repoRoot) return {};
   const out = {};
   for (const packageName of MEMORY_COST_MANAGED_PACKAGES) {
-    const packageJsonPath = path53.join(repoRoot, REPO_PACKAGE_JSON_RELATIVE[packageName]);
+    const packageJsonPath = path54.join(repoRoot, REPO_PACKAGE_JSON_RELATIVE[packageName]);
     const version = readPackageJsonVersion(packageJsonPath);
     if (!version) continue;
     out[packageName] = { version, source: "repo", path: packageJsonPath };
@@ -10890,12 +11158,12 @@ function unique(values) {
 }
 function moduleRoots() {
   const home = homedir13();
-  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path54.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) ? path54.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path54.join(home, ".npm-global", "lib", "node_modules"));
+  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path55.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) ? path55.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path55.join(home, ".npm-global", "lib", "node_modules"));
   return unique([
-    path54.join(openClawPrefix, "lib", "node_modules"),
-    path54.join(openClawPrefix, "node_modules"),
-    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path54.join(npmGlobalRoot, "lib", "node_modules")
+    path55.join(openClawPrefix, "lib", "node_modules"),
+    path55.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path55.join(npmGlobalRoot, "lib", "node_modules")
   ]);
 }
 async function readVersion(packageJsonPath) {
@@ -10911,7 +11179,7 @@ function installedPackageJsonCandidates(packageName) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const root of roots) {
-    const candidate = path54.join(root, packageName, "package.json");
+    const candidate = path55.join(root, packageName, "package.json");
     if (seen.has(candidate)) continue;
     seen.add(candidate);
     out.push(candidate);
@@ -10942,7 +11210,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path55.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path56.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -11089,6 +11357,15 @@ async function runPipelineTick(args) {
 var DEFAULT_INTERVAL_MS = 6e4;
 var IDLE_INTERVAL_MS = 5 * 6e4;
 var MAX_IDLE_STREAK = 10;
+var SLEEP_POLL_MS = 250;
+async function awaitDaemonBackoff(ms, isStopping) {
+  let remaining = ms;
+  while (remaining > 0 && !isStopping()) {
+    const step = Math.min(SLEEP_POLL_MS, remaining);
+    await sleepMsAsync(step);
+    remaining -= step;
+  }
+}
 async function runDaemon(args) {
   const runId = String(required(String(args.run || ""), "--run"));
   const agentOsId = String(required(String(args.agentOsId || loadUserConfig().agentOsId || ""), "--agent-os-id"));
@@ -11146,17 +11423,17 @@ async function runDaemon(args) {
         idleStreak = 0;
       }
       const backoff = idleStreak >= MAX_IDLE_STREAK ? IDLE_INTERVAL_MS : intervalMs;
-      sleepMs(backoff);
+      await awaitDaemonBackoff(backoff, () => stopping);
     } catch (error) {
       console.error(JSON.stringify({ event: "daemon_tick_error", error: error.message }));
-      sleepMs(intervalMs);
+      await awaitDaemonBackoff(intervalMs, () => stopping);
     }
   }
   console.error(JSON.stringify({ event: "daemon_stop", runId, agentOsId }));
 }
 
 // src/plan-progress.ts
-import path57 from "node:path";
+import path60 from "node:path";
 
 // src/bounded-build/constants.ts
 var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
@@ -11286,14 +11563,235 @@ function waitForBuildAdmission(timeoutMs, pollMs = 2e3, opts = {}) {
 }
 
 // src/bounded-build/exec.ts
+import { spawnSync as spawnSync8 } from "node:child_process";
+
+// src/heavy-verification/slot.ts
+import {
+  closeSync as closeSync7,
+  existsSync as existsSync41,
+  mkdirSync as mkdirSync8,
+  openSync as openSync7,
+  readdirSync as readdirSync15,
+  readFileSync as readFileSync14,
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync5
+} from "node:fs";
+import path58 from "node:path";
+
+// src/heavy-verification/paths.ts
+import { mkdirSync as mkdirSync7 } from "node:fs";
+import path57 from "node:path";
+function resolveHeavyVerificationRoot() {
+  return path57.join(resolveKynverStateRoot(), "heavy-verification");
+}
+function heavyVerificationSlotsDir() {
+  return path57.join(resolveHeavyVerificationRoot(), "slots");
+}
+function ensureHeavyVerificationDirs() {
+  const dir = heavyVerificationSlotsDir();
+  mkdirSync7(dir, { recursive: true });
+  return dir;
+}
+
+// src/heavy-verification/slot.ts
+var DEFAULT_HEAVY_VERIFICATION_STALE_MS = 2 * 60 * 6e4;
+var DEFAULT_HEAVY_VERIFICATION_MAX_CONCURRENT = 1;
+function positiveInt5(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+function isHeavyVerificationGateSkipped() {
+  const v = process.env.KYNVER_HEAVY_VERIFICATION_SKIP?.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes";
+}
+function resolveHeavyVerificationMaxConcurrent() {
+  const env = process.env.KYNVER_HEAVY_VERIFICATION_MAX_CONCURRENT;
+  if (env) return positiveInt5(env, DEFAULT_HEAVY_VERIFICATION_MAX_CONCURRENT);
+  return DEFAULT_HEAVY_VERIFICATION_MAX_CONCURRENT;
+}
+function indexedSlotId(index) {
+  return `slot-${index}`;
+}
+function slotFilePath(slotId, slotsDir = heavyVerificationSlotsDir()) {
+  return path58.join(slotsDir, `${slotId}.json`);
+}
+function readSlotRecord(filePath) {
+  if (!existsSync41(filePath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync14(filePath, "utf8"));
+    if (typeof parsed.slotId === "string" && typeof parsed.pid === "number" && typeof parsed.acquiredAt === "string" && typeof parsed.command === "string") {
+      return parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function slotIsStale(record, staleMs = DEFAULT_HEAVY_VERIFICATION_STALE_MS) {
+  if (!record) return true;
+  if (!isPidAlive(record.pid)) return true;
+  const atMs = Date.parse(record.acquiredAt);
+  if (Number.isNaN(atMs)) return true;
+  return Date.now() - atMs > staleMs;
+}
+function reclaimStaleSlot(filePath, staleMs) {
+  const record = readSlotRecord(filePath);
+  if (!slotIsStale(record, staleMs)) return;
+  try {
+    unlinkSync4(filePath);
+  } catch {
+  }
+}
+function ensureSlotsDir(slotsDir) {
+  mkdirSync8(slotsDir, { recursive: true });
+  return slotsDir;
+}
+function reclaimStaleHeavyVerificationSlots(opts = {}) {
+  const slotsDir = ensureSlotsDir(opts.slotsDir ?? ensureHeavyVerificationDirs());
+  const staleMs = opts.staleMs ?? DEFAULT_HEAVY_VERIFICATION_STALE_MS;
+  let reclaimed = 0;
+  for (const name of readdirSync15(slotsDir)) {
+    if (!name.endsWith(".json")) continue;
+    const filePath = path58.join(slotsDir, name);
+    const before = existsSync41(filePath);
+    reclaimStaleSlot(filePath, staleMs);
+    if (before && !existsSync41(filePath)) reclaimed += 1;
+  }
+  return reclaimed;
+}
+function listActiveHeavyVerificationSlots(opts = {}) {
+  const slotsDir = opts.slotsDir ?? ensureHeavyVerificationDirs();
+  const staleMs = opts.staleMs ?? DEFAULT_HEAVY_VERIFICATION_STALE_MS;
+  reclaimStaleHeavyVerificationSlots({ slotsDir, staleMs });
+  const active = [];
+  for (const name of readdirSync15(slotsDir)) {
+    if (!name.endsWith(".json")) continue;
+    const record = readSlotRecord(path58.join(slotsDir, name));
+    if (record && !slotIsStale(record, staleMs)) active.push(record);
+  }
+  return active;
+}
+function countActiveHeavyVerificationSlots(opts = {}) {
+  return listActiveHeavyVerificationSlots(opts).length;
+}
+function tryAcquireHeavyVerificationSlot(command, opts = {}) {
+  if (isHeavyVerificationGateSkipped()) {
+    return {
+      admitted: true,
+      slotId: null,
+      activeSlots: 0,
+      maxSlots: resolveHeavyVerificationMaxConcurrent(),
+      reason: null
+    };
+  }
+  const slotsDir = opts.slotsDir ?? ensureHeavyVerificationDirs();
+  const staleMs = opts.staleMs ?? DEFAULT_HEAVY_VERIFICATION_STALE_MS;
+  const maxSlots = opts.maxSlots ?? resolveHeavyVerificationMaxConcurrent();
+  reclaimStaleHeavyVerificationSlots({ slotsDir, staleMs });
+  for (let index = 0; index < maxSlots; index += 1) {
+    const slotId = indexedSlotId(index);
+    const filePath = slotFilePath(slotId, slotsDir);
+    const existing = readSlotRecord(filePath);
+    if (existing && slotIsStale(existing, staleMs)) {
+      try {
+        unlinkSync4(filePath);
+      } catch {
+      }
+    } else if (existing && !slotIsStale(existing, staleMs)) {
+      continue;
+    }
+    const record = {
+      slotId,
+      pid: process.pid,
+      acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      command
+    };
+    try {
+      const fd = openSync7(filePath, "wx");
+      writeFileSync5(fd, JSON.stringify(record, null, 2), "utf8");
+      closeSync7(fd);
+      const activeSlots2 = countActiveHeavyVerificationSlots({ slotsDir, staleMs });
+      return {
+        admitted: true,
+        slotId,
+        activeSlots: activeSlots2,
+        maxSlots,
+        reason: null
+      };
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        continue;
+      }
+      throw err;
+    }
+  }
+  const activeSlots = countActiveHeavyVerificationSlots({ slotsDir, staleMs });
+  return {
+    admitted: false,
+    slotId: null,
+    activeSlots,
+    maxSlots,
+    reason: `heavy verification at capacity (${activeSlots}/${maxSlots} slots)`
+  };
+}
+function releaseHeavyVerificationSlot(slotId, opts = {}) {
+  if (!slotId) return;
+  const filePath = slotFilePath(slotId, opts.slotsDir ?? heavyVerificationSlotsDir());
+  try {
+    unlinkSync4(filePath);
+  } catch {
+  }
+}
+function assessHeavyVerificationGate(command, opts = {}) {
+  if (isHeavyVerificationGateSkipped()) {
+    return {
+      admitted: true,
+      slotId: null,
+      activeSlots: 0,
+      maxSlots: resolveHeavyVerificationMaxConcurrent(),
+      reason: null
+    };
+  }
+  const slotsDir = opts.slotsDir ?? ensureHeavyVerificationDirs();
+  const staleMs = opts.staleMs ?? DEFAULT_HEAVY_VERIFICATION_STALE_MS;
+  const maxSlots = opts.maxSlots ?? resolveHeavyVerificationMaxConcurrent();
+  reclaimStaleHeavyVerificationSlots({ slotsDir, staleMs });
+  const activeSlots = countActiveHeavyVerificationSlots({ slotsDir, staleMs });
+  const admitted = activeSlots < maxSlots;
+  return {
+    admitted,
+    slotId: null,
+    activeSlots,
+    maxSlots,
+    reason: admitted ? null : `heavy verification at capacity (${activeSlots}/${maxSlots} slots); waiting for ${command}`
+  };
+}
+
+// src/heavy-verification/gate.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
+function sleepMs3(ms) {
+  if (ms <= 0) return;
+  spawnSync7(process.execPath, ["-e", `const d=Date.now()+${Math.floor(ms)};while(Date.now()<d);`], {
+    stdio: "ignore"
+  });
+}
+function waitForHeavyVerificationSlot(command, timeoutMs, pollMs = 2e3, opts = {}) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let verdict = tryAcquireHeavyVerificationSlot(command, opts);
+  while (!verdict.admitted && Date.now() < deadline) {
+    sleepMs3(Math.min(pollMs, deadline - Date.now()));
+    verdict = tryAcquireHeavyVerificationSlot(command, opts);
+  }
+  return verdict;
+}
 
 // src/harness-worktree-build-guard.ts
-import path56 from "node:path";
+import path59 from "node:path";
 function isPathUnderHarnessWorktree(cwd) {
   const worktreesDir = harnessWorktreesDir(resolveHarnessRoot());
-  const rel = path56.relative(worktreesDir, path56.resolve(cwd));
-  return rel.length > 0 && !rel.startsWith("..") && !path56.isAbsolute(rel);
+  const rel = path59.relative(worktreesDir, path59.resolve(cwd));
+  return rel.length > 0 && !rel.startsWith("..") && !path59.isAbsolute(rel);
 }
 function assessHarnessWorktreeBuildGuard(cwd) {
   if (!isPathUnderHarnessWorktree(cwd)) return { ok: true };
@@ -11317,7 +11815,7 @@ function envArgv(env) {
   return out;
 }
 function runSpawn(argv, opts) {
-  const res = spawnSync7(argv[0], argv.slice(1), {
+  const res = spawnSync8(argv[0], argv.slice(1), {
     cwd: opts.cwd,
     env: opts.env,
     encoding: "utf8",
@@ -11333,8 +11831,25 @@ function runSpawn(argv, opts) {
 }
 function runBoundedBuildCheck(input) {
   const waitMs = input.waitForAdmissionMs ?? 6e5;
+  const verificationGate = waitMs > 0 ? waitForHeavyVerificationSlot(input.command, waitMs) : tryAcquireOrAssessVerificationGate(input.command);
+  if (!verificationGate.admitted) {
+    return {
+      ok: false,
+      exitCode: 1,
+      stdout: "",
+      stderr: verificationGate.reason ?? "heavy verification gate denied",
+      admitted: false,
+      wrappedWithSystemd: false,
+      nodeOptionsFlag: formatNodeOptionsFlag(),
+      admission: assessBuildAdmission(),
+      verificationGate,
+      command: input.command
+    };
+  }
+  const slotId = verificationGate.slotId;
   const admission = waitMs > 0 ? waitForBuildAdmission(waitMs) : assessBuildAdmission();
   if (!admission.admitted) {
+    releaseHeavyVerificationSlot(slotId);
     return {
       ok: false,
       exitCode: 1,
@@ -11344,11 +11859,13 @@ function runBoundedBuildCheck(input) {
       wrappedWithSystemd: false,
       nodeOptionsFlag: formatNodeOptionsFlag(),
       admission,
+      verificationGate,
       command: input.command
     };
   }
   const worktreeGuard = assessHarnessWorktreeBuildGuard(input.cwd);
   if (!worktreeGuard.ok) {
+    releaseHeavyVerificationSlot(slotId);
     return {
       ok: false,
       exitCode: 1,
@@ -11358,6 +11875,7 @@ function runBoundedBuildCheck(input) {
       wrappedWithSystemd: false,
       nodeOptionsFlag: formatNodeOptionsFlag(),
       admission,
+      verificationGate,
       command: input.command
     };
   }
@@ -11390,12 +11908,19 @@ function runBoundedBuildCheck(input) {
       wrappedWithSystemd: useSystemd,
       nodeOptionsFlag,
       admission,
+      verificationGate,
       command: input.command
     };
   } finally {
     registerBuildEnd();
+    releaseHeavyVerificationSlot(slotId);
   }
 }
+function tryAcquireOrAssessVerificationGate(command) {
+  const acquired = waitForHeavyVerificationSlot(command, 0);
+  if (acquired.admitted) return acquired;
+  return { ...assessHeavyVerificationGate(command), slotId: null };
+}
 
 // src/harness-verify.ts
 var DEFAULT_HARNESS_VERIFY_COMMANDS = ["npm run typecheck", "npm run test"];
@@ -11478,7 +12003,7 @@ async function emitPlanProgress(args) {
 }
 function verifyPlanLocal(args) {
   const worktree = required(args.worktree ? String(args.worktree) : void 0, "worktree");
-  const cwd = path57.resolve(worktree);
+  const cwd = path60.resolve(worktree);
   const summary = runHarnessVerifyCommands(cwd);
   const emitJson = args.json === true || args.json === "true";
   const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
@@ -11527,9 +12052,9 @@ async function verifyPlan(args) {
 }
 
 // src/harness-verify-cli.ts
-import path58 from "node:path";
+import path61 from "node:path";
 function runHarnessVerifyCli(args) {
-  const cwd = path58.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const cwd = path61.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;
@@ -11557,6 +12082,7 @@ function runHarnessVerifyCli(args) {
       wrappedWithSystemd: s.result.wrappedWithSystemd,
       nodeOptionsFlag: s.result.nodeOptionsFlag,
       admission: s.result.admission,
+      verificationGate: s.result.verificationGate,
       stderr: s.result.stderr.slice(0, 4e3)
     }))
   };
@@ -11573,7 +12099,7 @@ function runHarnessVerifyCli(args) {
 }
 
 // src/plan-persist-cli.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 var OPERATIONS = ["create", "add_version", "update_metadata"];
 var FAILURE_KINDS = [
   "approval_guard",
@@ -11585,7 +12111,7 @@ var FAILURE_KINDS = [
 function readBodyArg(args) {
   const bodyFile = args.bodyFile ? String(args.bodyFile) : void 0;
   if (bodyFile) {
-    return { body: readFileSync13(bodyFile, "utf8"), bodyPathHint: bodyFile };
+    return { body: readFileSync15(bodyFile, "utf8"), bodyPathHint: bodyFile };
   }
   const inline = args.body ? String(args.body) : void 0;
   if (inline) return { body: inline };
@@ -11736,7 +12262,7 @@ function formatMonitorTickNotice(tick) {
 }
 
 // src/monitor/monitor.service.ts
-import path60 from "node:path";
+import path63 from "node:path";
 
 // src/monitor/monitor.classify.ts
 function classifyWorkerHealth(input) {
@@ -11788,19 +12314,19 @@ function classifyWorkerHealth(input) {
 }
 
 // src/monitor/monitor.store.ts
-import { existsSync as existsSync41, mkdirSync as mkdirSync7, readdirSync as readdirSync15, unlinkSync as unlinkSync4 } from "node:fs";
-import path59 from "node:path";
+import { existsSync as existsSync42, mkdirSync as mkdirSync9, readdirSync as readdirSync16, unlinkSync as unlinkSync5 } from "node:fs";
+import path62 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path59.join(harnessRoot, "monitors");
-  mkdirSync7(dir, { recursive: true });
+  const dir = path62.join(harnessRoot, "monitors");
+  mkdirSync9(dir, { recursive: true });
   return dir;
 }
 function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path59.join(monitorsDir(), `${monitorId}.json`);
+  return path62.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -11810,18 +12336,18 @@ function saveMonitorSession(session) {
 }
 function deleteMonitorSession(monitorId) {
   const file = monitorPath(monitorId);
-  if (!existsSync41(file)) return false;
-  unlinkSync4(file);
+  if (!existsSync42(file)) return false;
+  unlinkSync5(file);
   return true;
 }
 function listMonitorSessions() {
   const dir = monitorsDir();
-  if (!existsSync41(dir)) return [];
+  if (!existsSync42(dir)) return [];
   const entries = [];
-  for (const name of readdirSync15(dir)) {
+  for (const name of readdirSync16(dir)) {
     if (!name.endsWith(".json")) continue;
     const session = readJson(
-      path59.join(dir, name),
+      path62.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -11912,7 +12438,7 @@ async function fetchTaskLeasesForWorkers(input) {
 // src/monitor/monitor.service.ts
 function workerRecord2(runId, name) {
   return readJson(
-    path60.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path63.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -12118,21 +12644,21 @@ async function runMonitorLoop(args) {
 
 // src/monitor/monitor-spawn.ts
 import { spawn as spawn6 } from "node:child_process";
-import { closeSync as closeSync7, existsSync as existsSync42, openSync as openSync7 } from "node:fs";
-import path61 from "node:path";
+import { closeSync as closeSync8, existsSync as existsSync43, openSync as openSync8 } from "node:fs";
+import path64 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path61.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
+  return path64.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
-  if (!existsSync42(cliPath)) return void 0;
+  if (!existsSync43(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path61.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path64.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
-    logFd = openSync7(logPath, "a");
+    logFd = openSync8(logPath, "a");
   } catch {
     logFd = void 0;
   }
@@ -12172,7 +12698,7 @@ function spawnMonitorSidecar(opts) {
         env: process.env
       })
     );
-    if (logFd !== void 0) closeSync7(logFd);
+    if (logFd !== void 0) closeSync8(logFd);
     child.unref();
     const session = {
       monitorId,
@@ -12189,7 +12715,7 @@ function spawnMonitorSidecar(opts) {
   } catch {
     if (logFd !== void 0) {
       try {
-        closeSync7(logFd);
+        closeSync8(logFd);
       } catch {
       }
     }
@@ -12249,13 +12775,13 @@ async function monitorTickCli(args) {
 }
 
 // src/package-version.ts
-import { existsSync as existsSync43, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync44, readFileSync as readFileSync16 } 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 (existsSync43(join(dir, "package.json"))) return dir;
+    if (existsSync44(join(dir, "package.json"))) return dir;
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -12264,7 +12790,7 @@ function resolvePackageRoot(moduleUrl) {
 }
 function readOwnPackageVersion(moduleUrl = import.meta.url) {
   const pkgPath = join(resolvePackageRoot(moduleUrl), "package.json");
-  const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync16(pkgPath, "utf8"));
   if (typeof pkg.version !== "string" || !pkg.version.trim()) {
     throw new Error(`Missing package.json version at ${pkgPath}`);
   }
@@ -12330,8 +12856,32 @@ function shouldEnforceMemoryCostPackageGuardCli(scope, action) {
   return false;
 }
 
+// src/run-resolve.ts
+function resolveHarnessRunByName(runName) {
+  const name = runName.trim();
+  if (!name) return null;
+  const rows = buildRunListRows();
+  return rows.find((row) => row.name === name && row.status !== "completed") ?? null;
+}
+function resolveHarnessRunCli(args) {
+  const name = String(required(String(args.name || ""), "--name"));
+  const hit = resolveHarnessRunByName(name);
+  console.log(
+    JSON.stringify(
+      {
+        runId: hit?.id ?? null,
+        name,
+        status: hit?.status ?? null,
+        effectiveStatus: hit?.effectiveStatus ?? null
+      },
+      null,
+      2
+    )
+  );
+}
+
 // src/post-restart-unblock.ts
-import path62 from "node:path";
+import path65 from "node:path";
 function skip(runId, worker, taskId, agentOsId, leaseOwner, reason) {
   return { runId, worker, taskId, agentOsId, leaseOwner, action: "skipped", reason };
 }
@@ -12344,7 +12894,7 @@ async function postRestartUnblock(args) {
   const errors = [];
   for (const run of listRunRecords()) {
     for (const name of Object.keys(run.workers ?? {})) {
-      const workerPath = path62.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path65.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"));
@@ -12456,9 +13006,9 @@ async function postRestartUnblockCli(args) {
 }
 
 // src/default-repo-cli.ts
-import path63 from "node:path";
+import path66 from "node:path";
 import { homedir as homedir14 } from "node:os";
-var CONFIG_FILE2 = path63.join(homedir14(), ".kynver", "config.json");
+var CONFIG_FILE2 = path66.join(homedir14(), ".kynver", "config.json");
 function ensureDefaultRepo(opts) {
   const existing = loadUserConfig();
   const resolved = resolveDefaultRepo({ ...opts, config: existing });
@@ -12539,16 +13089,16 @@ function summarizeResolvedDefaultRepo(resolved) {
 }
 
 // src/doctor/runtime-takeover.ts
-import path65 from "node:path";
+import path68 from "node:path";
 
 // src/doctor/runtime-takeover.probes.ts
-import { accessSync, constants, existsSync as existsSync44, readFileSync as readFileSync15 } from "node:fs";
+import { accessSync, constants, existsSync as existsSync45, readFileSync as readFileSync17 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import path64 from "node:path";
-import { spawnSync as spawnSync8 } from "node:child_process";
+import path67 from "node:path";
+import { spawnSync as spawnSync9 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
-    const res = spawnSync8(bin, args, { encoding: "utf8" });
+    const res = spawnSync9(bin, args, { encoding: "utf8" });
     const stdout = (res.stdout || "").trim();
     const stderr = (res.stderr || "").trim();
     const ok = res.status === 0;
@@ -12573,7 +13123,7 @@ function tokenPrefix(token) {
   return trimmed.length <= 12 ? `${trimmed}\u2026` : `${trimmed.slice(0, 12)}\u2026`;
 }
 function isWritable(target) {
-  if (!existsSync44(target)) return false;
+  if (!existsSync45(target)) return false;
   try {
     accessSync(target, constants.W_OK);
     return true;
@@ -12586,15 +13136,15 @@ var defaultRuntimeTakeoverProbes = {
   commandOnPath: (bin) => captureCommand(process.platform === "win32" ? "where" : "which", [bin]),
   kynverVersion: (bin) => captureCommand(bin, ["--version"]),
   loadConfig: () => loadUserConfig(),
-  configFilePath: () => path64.join(homedir15(), ".kynver", "config.json"),
-  credentialsFilePath: () => path64.join(homedir15(), ".kynver", "credentials"),
+  configFilePath: () => path67.join(homedir15(), ".kynver", "config.json"),
+  credentialsFilePath: () => path67.join(homedir15(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path64.join(homedir15(), ".kynver", "credentials");
-    if (!existsSync44(credPath)) {
+    const credPath = path67.join(homedir15(), ".kynver", "credentials");
+    if (!existsSync45(credPath)) {
       return { hasApiKey: false };
     }
     try {
-      const parsed = JSON.parse(readFileSync15(credPath, "utf8"));
+      const parsed = JSON.parse(readFileSync17(credPath, "utf8"));
       return {
         hasApiKey: Boolean(parsed.apiKey?.trim()),
         runnerTokenPrefix: tokenPrefix(parsed.runnerToken),
@@ -12624,8 +13174,8 @@ var defaultRuntimeTakeoverProbes = {
     })()
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path64.join(homedir15(), ".openclaw", "harness"),
-  pathExists: (target) => existsSync44(target),
+  legacyOpenclawHarnessRoot: () => path67.join(homedir15(), ".openclaw", "harness"),
+  pathExists: (target) => existsSync45(target),
   pathWritable: (target) => isWritable(target)
 };
 
@@ -13031,8 +13581,8 @@ function assessVercelDeployEvidence(probes) {
 }
 function assessHarnessDirs(probes) {
   const harnessRoot = probes.harnessRoot();
-  const runsDir = path65.join(harnessRoot, "runs");
-  const worktreesDir = path65.join(harnessRoot, "worktrees");
+  const runsDir = path68.join(harnessRoot, "runs");
+  const worktreesDir = path68.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -13296,9 +13846,9 @@ function applySchedulerCutoverAttestation(config) {
 }
 
 // src/scheduler-cutover-cli.ts
-import path66 from "node:path";
+import path69 from "node:path";
 import { homedir as homedir16 } from "node:os";
-var CONFIG_FILE3 = path66.join(homedir16(), ".kynver", "config.json");
+var CONFIG_FILE3 = path69.join(homedir16(), ".kynver", "config.json");
 function runSchedulerCutoverCheckCli(json = false) {
   const config = loadUserConfig();
   const report = assessSchedulerCutover(config);
@@ -13435,6 +13985,157 @@ async function runCronTickCli(args) {
   );
 }
 
+// src/lane/landing-maintainer-tick.ts
+import os9 from "node:os";
+
+// src/lane/lane-spec.ts
+var LANDING_MAINTAINER_LANE_SPEC = {
+  slug: "landing-maintainer",
+  originCron: "maintain-8-blocker-and-pr-landing-workers",
+  defaultRepo: "Totalsolutionsync/Kynver",
+  landScript: "scripts/agent-os-land-pr.mjs",
+  landScriptArgs: ["--skip-not-ready"]
+};
+
+// src/lane/landing-maintainer-local.ts
+import { spawnSync as spawnSync10 } from "node:child_process";
+import path70 from "node:path";
+function runLandingWrapper(prNumber, repoRoot, execute) {
+  const script = path70.join(repoRoot, LANDING_MAINTAINER_LANE_SPEC.landScript);
+  const args = [script, String(prNumber), ...LANDING_MAINTAINER_LANE_SPEC.landScriptArgs];
+  if (!execute) {
+    return {
+      action: { kind: "land_pr", prNumber, reason: "dry-run" },
+      executed: false,
+      exitCode: 0,
+      stdout: `dry-run: node ${args.join(" ")}`,
+      stderr: ""
+    };
+  }
+  const result = spawnSync10("node", args, {
+    cwd: repoRoot,
+    encoding: "utf8",
+    timeout: 10 * 60 * 1e3
+  });
+  return {
+    action: { kind: "land_pr", prNumber, reason: "landing wrapper invoked" },
+    executed: true,
+    exitCode: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+}
+function resolveLandingMaintainerRepoRoot(args) {
+  const explicit = args.repoPath ? String(args.repoPath).trim() : "";
+  if (explicit) return path70.resolve(explicit);
+  const resolved = resolveDefaultRepo();
+  return resolved?.repo ?? process.cwd();
+}
+
+// src/lane/landing-maintainer-tick.ts
+async function runLandingMaintainerLaneTick(args) {
+  const agentOsId = String(required(String(args.agentOsId || ""), "--agent-os-id"));
+  const repoSlug = String(args.repo || LANDING_MAINTAINER_LANE_SPEC.defaultRepo).trim();
+  const fleet = args.fleet === true || args.fleet === "true";
+  const execute = args.execute !== false && args.execute !== "false";
+  const runId = args.run ? String(args.run) : void 0;
+  const resourceGate = observeRunnerResourceGate({
+    runId: runId ?? "fleet-lane-tick"
+  });
+  const boxCapacity = {
+    ...buildBoxResourceSnapshotFromGate(resourceGate, {
+      harnessRunId: runId,
+      boxKind: resolveBoxKindFromConfig(loadUserConfig()),
+      hostLabel: os9.hostname()
+    }),
+    providerHealthy: resourceGate.ok,
+    authorizedForRepair: resourceGate.ok,
+    authorizedForLanding: resourceGate.ok,
+    systemHealthBlockers: resourceGate.ok ? [] : [resourceGate.reason ?? "resource_gate_blocked"],
+    actionableWorkers: resourceGate.activeWorkers
+  };
+  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+  const secret = await resolveCallbackSecretWithMint(
+    args.secret ? String(args.secret) : void 0,
+    agentOsId,
+    { baseUrl: base }
+  );
+  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/fleet-landing-maintainer/tick`;
+  const res = await postJson(url, secret, {
+    repo: repoSlug,
+    fleet,
+    execute,
+    runId,
+    boxCapacity
+  });
+  const coordinator = res.response;
+  const localOutcomes = [];
+  const repoRoot = resolveLandingMaintainerRepoRoot(args);
+  const actions = Array.isArray(coordinator?.localActions) ? coordinator.localActions : [];
+  const holderBoxId = boxCapacity.boxId;
+  for (const action of actions) {
+    if (action.kind === "land_pr" && typeof action.prNumber === "number") {
+      const outcome = runLandingWrapper(action.prNumber, repoRoot, execute);
+      localOutcomes.push({
+        action: outcome.action,
+        executed: outcome.executed,
+        exitCode: outcome.exitCode
+      });
+      if (execute && outcome.executed) {
+        const merged = outcome.exitCode === 0;
+        const prUrl = typeof action.prUrl === "string" && action.prUrl.trim() ? action.prUrl.trim() : `https://github.com/${repoSlug}/pull/${action.prNumber}`;
+        try {
+          await postJson(
+            `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/fleet-landing-maintainer/outcome`,
+            secret,
+            { repo: repoSlug, prUrl, holderBoxId, merged }
+          );
+        } catch {
+        }
+      }
+      continue;
+    }
+    localOutcomes.push({
+      action,
+      executed: false,
+      exitCode: null
+    });
+  }
+  return {
+    repo: repoSlug,
+    fleet,
+    execute,
+    coordinator,
+    localOutcomes
+  };
+}
+
+// src/lane/lane-tick-cli.ts
+async function runLaneTickCli(args, laneFromArgv) {
+  const lane = String(laneFromArgv ?? args.lane ?? "").trim();
+  if (lane !== "landing-maintainer") {
+    console.error(`unknown lane: ${lane || "(none)"}`);
+    process.exit(1);
+  }
+  const result = await runLandingMaintainerLaneTick(args);
+  if (args.json === true || args.json === "true") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(
+    [
+      `fleet landing-maintainer tick`,
+      `repo=${result.repo}`,
+      `fleet=${result.fleet}`,
+      `execute=${result.execute}`,
+      `localOutcomes=${result.localOutcomes.length}`
+    ].join(" ")
+  );
+  for (const row of result.localOutcomes) {
+    console.log(`  ${row.action.kind} pr=${row.action.prNumber ?? "-"} executed=${row.executed}`);
+  }
+}
+
 // src/cli.ts
 function isHelpFlag(arg) {
   return arg === "help" || arg === "--help" || arg === "-h";
@@ -13455,6 +14156,7 @@ function usage(code = 0) {
       "  kynver daemon --run RUN_ID --agent-os-id AOS_ID [--execute] [--interval-ms MS]",
       "  kynver run create [--repo /path/repo] [--name name] [--base origin/main]",
       "  kynver run list",
+      "  kynver run resolve --name RUN_NAME",
       "  kynver run status --run RUN_ID [--json] [--compact]",
       "  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]",
@@ -13490,6 +14192,7 @@ function usage(code = 0) {
       "  kynver scheduler attest-cutover [--json]",
       "  kynver cron status [--json]",
       "  kynver cron tick [--agent-os-id AOS_ID] [--json]",
+      "  kynver lane tick landing-maintainer [--fleet] [--repo OWNER/NAME] [--agent-os-id AOS_ID] [--execute] [--json]",
       "  kynver board contract [--agent-os-id ID] [--base-url URL] [--since ISO] [--limit N]"
     ].join("\n")
   );
@@ -13501,7 +14204,7 @@ async function main(argv = process.argv.slice(2)) {
   const scope = argv.shift();
   let action;
   let rest;
-  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner" || scope === "harness" || scope === "monitor" || scope === "doctor" || scope === "config" || scope === "scheduler" || scope === "cron" || scope === "board") {
+  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner" || scope === "harness" || scope === "monitor" || scope === "doctor" || scope === "config" || scope === "scheduler" || scope === "cron" || scope === "lane" || scope === "board") {
     action = argv.shift();
     rest = argv;
   } else {
@@ -13510,8 +14213,8 @@ async function main(argv = process.argv.slice(2)) {
   if (action && isHelpFlag(action) || rest.some(isHelpFlag)) return usage(0);
   const args = parseArgs(rest);
   const { runsDir, worktreesDir } = getPaths();
-  mkdirSync8(runsDir, { recursive: true });
-  mkdirSync8(worktreesDir, { recursive: true });
+  mkdirSync10(runsDir, { recursive: true });
+  mkdirSync10(worktreesDir, { recursive: true });
   if (shouldEnforceMemoryCostPackageGuardCli(scope, action)) {
     let repoRoot;
     const runId = args.run ? String(args.run).trim() : "";
@@ -13558,11 +14261,16 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "cron" && action === "tick") {
     return void await runCronTickCli(args);
   }
+  if (scope === "lane" && action === "tick") {
+    const laneName = rest.shift();
+    return void await runLaneTickCli(parseArgs(rest), laneName);
+  }
   if (scope === "board" && action === "contract") {
     return void await runCommandCenterContractCli(args);
   }
   if (scope === "run" && action === "create") return createRun(args);
   if (scope === "run" && action === "list") return listRuns();
+  if (scope === "run" && action === "resolve") return resolveHarnessRunCli(args);
   if (scope === "run" && action === "status") return runStatus(args);
   if (scope === "run" && action === "dispatch") return void await dispatchRun(args);
   if (scope === "run" && action === "sweep") return void await sweepRun(args);