@kynver-app/runtime 0.1.18 → 0.1.21

package/dist/index.js

@@ -10,6 +10,10 @@ function fail(message) {
   console.error(message);
   process.exit(1);
 }
+function hiddenSpawnOptions(opts) {
+  if (process.platform !== "win32") return opts;
+  return { windowsHide: true, ...opts };
+}
 function required(value, name) {
   if (!value) fail(`missing ${name}`);
   return value;
@@ -393,12 +397,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 path16 = input.diskPath?.trim() || "/";
+  const path18 = 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 = statfsSync(path16);
+  const stats = statfsSync(path18);
   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;
@@ -418,7 +422,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path16,
+    path: path18,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -692,22 +696,36 @@ function gitIsAncestor(cwd, ancestor, descendant) {
   if (res.status === 1) return { isAncestor: false, error: null };
   return { isAncestor: null, error: res.error || res.stderr || res.stdout || `git exited ${res.status}` };
 }
-function computeGitAncestry(worktreePath, base = "origin/main") {
+function computeGitAncestry(worktreePath, baseOrOptions = "origin/main") {
+  const options = typeof baseOrOptions === "string" ? { base: baseOrOptions } : baseOrOptions;
+  const baseLabel = options.baseCommit?.trim() || options.base?.trim() || "origin/main";
+  const pinnedBaseCommit = options.baseCommit?.trim() || null;
   if (!worktreePath) {
-    return unknownAncestry(base, "missing worktree path");
+    return unknownAncestry(baseLabel, "missing worktree path");
   }
   const head = gitCapture(worktreePath, ["rev-parse", "HEAD"]);
-  if (head.status !== 0) return unknownAncestry(base, head.error || head.stderr || head.stdout || "failed to resolve HEAD");
-  const baseHead = gitCapture(worktreePath, ["rev-parse", base]);
-  if (baseHead.status !== 0) {
-    return unknownAncestry(base, baseHead.error || baseHead.stderr || baseHead.stdout || `failed to resolve ${base}`, head.stdout.trim());
+  if (head.status !== 0) {
+    return unknownAncestry(baseLabel, head.error || head.stderr || head.stdout || "failed to resolve HEAD");
+  }
+  let baseSha;
+  if (pinnedBaseCommit) {
+    baseSha = pinnedBaseCommit;
+  } else {
+    const baseHead = gitCapture(worktreePath, ["rev-parse", baseLabel]);
+    if (baseHead.status !== 0) {
+      return unknownAncestry(
+        baseLabel,
+        baseHead.error || baseHead.stderr || baseHead.stdout || `failed to resolve ${baseLabel}`,
+        head.stdout.trim()
+      );
+    }
+    baseSha = baseHead.stdout.trim();
   }
   const headSha = head.stdout.trim();
-  const baseSha = baseHead.stdout.trim();
   if (headSha === baseSha) {
     return {
       checked: true,
-      base,
+      base: baseLabel,
       head: headSha,
       baseHead: baseSha,
       baseIsAncestorOfHead: true,
@@ -721,7 +739,7 @@ function computeGitAncestry(worktreePath, base = "origin/main") {
   if (baseIsAncestorOfHead.isAncestor == null || headIsAncestorOfBase.isAncestor == null) {
     return {
       checked: false,
-      base,
+      base: baseLabel,
       head: headSha,
       baseHead: baseSha,
       baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
@@ -733,7 +751,7 @@ function computeGitAncestry(worktreePath, base = "origin/main") {
   const relation = baseIsAncestorOfHead.isAncestor ? "ahead" : headIsAncestorOfBase.isAncestor ? "merged" : "diverged";
   return {
     checked: true,
-    base,
+    base: baseLabel,
     head: headSha,
     baseHead: baseSha,
     baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
@@ -760,12 +778,74 @@ function scrubClaudeEnv(env) {
   return next;
 }
 
+// src/landing-gate.ts
+function trimOrNull(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+function hasFinalResult(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "boolean") return value;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function hasCommittedLandingRef(snapshot) {
+  if (trimOrNull(snapshot.headCommit)) return true;
+  if (trimOrNull(snapshot.prUrl)) return true;
+  if (trimOrNull(snapshot.artifactBundlePath)) return true;
+  if (trimOrNull(snapshot.patchPath)) return true;
+  const ancestry = snapshot.gitAncestry;
+  if (ancestry?.checked && ancestry.headIsAncestorOfBase === false && trimOrNull(ancestry.head)) {
+    return true;
+  }
+  return false;
+}
+function assessWorkerLanding(snapshot) {
+  if (!hasFinalResult(snapshot.finalResult)) return { blocked: false };
+  if (snapshot.changedFiles.length === 0) return { blocked: false };
+  if (!hasCommittedLandingRef(snapshot)) {
+    return {
+      blocked: true,
+      reason: "dirty_worktree_no_pr",
+      detail: `Worktree has ${snapshot.changedFiles.length} uncommitted change(s) with no commit or PR; commit, open a PR, or discard before landing`
+    };
+  }
+  return {
+    blocked: true,
+    detail: `Worktree has ${snapshot.changedFiles.length} uncommitted change(s); commit or discard before landing`
+  };
+}
+function landingAttentionReason(verdict) {
+  if (!verdict.blocked) return void 0;
+  return verdict.detail ?? verdict.reason ?? "dirty_worktree_no_pr";
+}
+
 // src/status.ts
 var NO_START_MS = 18e4;
 var STALE_MS = 6e5;
 function computeAttention(input) {
   const now = Date.now();
-  if (input.finalResult) return { state: "done", reason: "final result recorded" };
+  if (input.completionBlocker) {
+    return { state: "blocked", reason: input.completionBlocker };
+  }
+  if (input.finalResult) {
+    const landing = assessWorkerLanding({
+      finalResult: input.finalResult,
+      changedFiles: input.changedFiles ?? [],
+      gitAncestry: input.gitAncestry ?? null
+    });
+    if (landing.blocked) {
+      const detail = landingAttentionReason(landing);
+      return {
+        state: "needs_attention",
+        reason: landing.reason ? `landing blocked (${landing.reason}): ${detail}` : `landing blocked: ${detail}`
+      };
+    }
+    return { state: "done", reason: "final result recorded" };
+  }
   if (!input.alive) {
     const classified = classifyExitFailure(input.error);
     if (classified) return { state: "blocked", reason: classified.reason };
@@ -796,7 +876,10 @@ function computeWorkerStatus(worker, options = {}) {
   const stderrBytes = fileSize(worker.stderrPath);
   const heartbeatBytes = fileSize(worker.heartbeatPath);
   const changedFiles = gitStatusShort(worker.worktreePath);
-  const gitAncestry = computeGitAncestry(worker.worktreePath, options.base);
+  const gitAncestry = computeGitAncestry(worker.worktreePath, {
+    base: options.base,
+    baseCommit: options.baseCommit
+  });
   const lastActivityAt = latestIso([
     parsed.lastEventAt,
     heartbeat.lastHeartbeatAt,
@@ -805,6 +888,7 @@ function computeWorkerStatus(worker, options = {}) {
     fileMtime(worker.heartbeatPath)
   ]);
   const error = parsed.error || (!alive && !parsed.finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0);
+  const completionBlocker = typeof worker.completionBlocker === "string" && worker.completionBlocker.trim() ? worker.completionBlocker.trim() : null;
   const attention = computeAttention({
     alive,
     finalResult: parsed.finalResult,
@@ -814,14 +898,18 @@ function computeWorkerStatus(worker, options = {}) {
     lastActivityAt,
     heartbeatBlocker: heartbeat.heartbeatBlocker,
     startedAt: worker.startedAt,
-    error
+    error,
+    changedFiles,
+    gitAncestry,
+    completionBlocker
   });
+  const workerStatusLabel = completionBlocker || attention.state === "blocked" ? "blocked" : attention.state === "done" ? "done" : parsed.finalResult ? "exited" : alive ? "running" : "exited";
   return {
     runId: worker.runId,
     worker: worker.name,
     pid: worker.pid,
     alive,
-    status: parsed.finalResult ? "done" : alive ? "running" : "exited",
+    status: workerStatusLabel,
     attention,
     branch: worker.branch,
     worktreePath: worker.worktreePath,
@@ -850,6 +938,10 @@ function isFinishedWorkerStatus(status) {
   if (status.status === "exited" || status.status === "done") return true;
   return false;
 }
+function isLandingBlockedWorkerStatus(status) {
+  if (!status.finalResult) return false;
+  return status.attention.state === "needs_attention" || status.attention.state === "blocked";
+}
 function deriveRunStatus(fallback, workers) {
   if (workers.length === 0) return fallback;
   if (workers.some((w) => w.attention === "needs_attention" || w.attention === "stale" || w.attention === "blocked")) {
@@ -900,6 +992,10 @@ function readAvailableMemBytes() {
   }
   return os.freemem();
 }
+function isActiveHarnessWorker(worker) {
+  const status = computeWorkerStatus(worker);
+  return status.alive && !status.finalResult && status.attention.state !== "done";
+}
 function countActiveWorkersForRun(run) {
   let active = 0;
   for (const name of Object.keys(run.workers || {})) {
@@ -907,11 +1003,8 @@ function countActiveWorkersForRun(run) {
       path5.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
-    if (!worker) continue;
-    const status = computeWorkerStatus(worker);
-    if (status.alive && !status.finalResult && status.attention.state !== "done") {
-      active++;
-    }
+    if (!worker || !isActiveHarnessWorker(worker)) continue;
+    active++;
   }
   return active;
 }
@@ -936,7 +1029,7 @@ function observeRunnerResourceGate(input) {
   const maxConcurrentWorkers = Math.max(0, Math.min(targetCap, capacityFromTotal));
   const slotsByCapacity = Math.max(0, maxConcurrentWorkers - activeWorkers);
   const slotsByFreeMem = capacityFromFree;
-  const slotsAvailable = Math.min(slotsByCapacity, slotsByFreeMem);
+  let slotsAvailable = Math.min(slotsByCapacity, slotsByFreeMem);
   let reason = null;
   if (slotsAvailable <= 0) {
     if (activeWorkers >= maxConcurrentWorkers) {
@@ -963,39 +1056,6 @@ function observeRunnerResourceGate(input) {
   };
 }
 
-// src/supervisor.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3 } from "node:fs";
-import path9 from "node:path";
-
-// src/prompt.ts
-function buildPrompt(input) {
-  const ownership = input.ownedPaths.length ? `Owned paths: ${input.ownedPaths.join(", ")}. Do not edit outside these paths without stopping and reporting why.` : "Owned paths: unrestricted for this worker, but keep edits tightly scoped.";
-  const progressLines = [
-    "Structured plan progress (required when planId is set):",
-    "- Harness checkpoints only: `kynver plan progress --plan <planId> --row <rowKey> --role implementer --status running|partial|blocked` (the by-id harness route rejects `done` and confirm events).",
-    "- When a slice is finished, emit `partial` with evidence (`--evidence pr:<url>`, `--evidence path:<file>`, or `--evidence command:<cmd>`). Do not propose or confirm row `done` from the worker CLI.",
-    "- Propose/confirm row `done` is MCP/session only: chat agents use `agent_os_plan_progress_event_append` on the slug route (implementer proposes with `proposed: true`; report_reviewer/deep_reviewer confirm with `proposed: false`).",
-    "- When blocked on operator/Ghost/runtime review, create a linked review task (MCP `agent_os_plan_review_task_create` or API) and pass `--review-task <taskId>`.",
-    "- Before the completion report: mark completion-report rows partial with evidence; do not skip report review.",
-    "- After implementation: wait for report_reviewer then deep_reviewer confirmation (via MCP/session agents) before follow-up rows close.",
-    input.planId ? `Active planId: ${input.planId}${input.taskId ? ` \xB7 taskId: ${input.taskId}` : ""}` : "No planId on this worker \u2014 still emit progress when you touch plan-scoped work."
-  ];
-  return [
-    "You are running under the Kynver AgentOS runtime.",
-    "Immediately state your plan before editing.",
-    ownership,
-    `Worktree: ${input.worktreePath}`,
-    `Progress heartbeat file: ${input.heartbeatPath}`,
-    "After each major step, append one JSON line to the heartbeat file with fields: ts, phase, summary, changedFiles, blocker.",
-    "Final response must include files changed, verification commands, and unresolved risks.",
-    "",
-    ...progressLines,
-    "",
-    "Task:",
-    input.task
-  ].join("\n");
-}
-
 // src/providers/claude.ts
 import { closeSync, openSync } from "node:fs";
 import { spawn } from "node:child_process";
@@ -1054,7 +1114,7 @@ function preflightCursorModel(model, defaultModel) {
 }
 
 // src/providers/claude.ts
-var CLAUDE_DEFAULT_MODEL = "claude-opus-4-7";
+var CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6";
 var claudeProvider = {
   name: "claude",
   defaultModel: CLAUDE_DEFAULT_MODEL,
@@ -1083,12 +1143,12 @@ var claudeProvider = {
         "--include-partial-messages",
         opts.prompt
       ],
-      {
+      hiddenSpawnOptions({
         cwd: opts.worktreePath,
         detached: true,
         stdio: ["ignore", stdoutFd, stderrFd],
         env: scrubClaudeEnv(process.env)
-      }
+      })
     );
     closeSync(stdoutFd);
     closeSync(stderrFd);
@@ -1100,34 +1160,234 @@ var claudeProvider = {
   }
 };
 
+// src/model-routing.ts
+var GLOBAL_DEFAULT_MODEL = "claude-sonnet-4-6";
+function taskString(task, key) {
+  const v = task[key];
+  return typeof v === "string" ? v.trim() : "";
+}
+function normalizeRef(ref) {
+  return ref.toLowerCase();
+}
+function resolveGlobalDefaultModel(config = loadUserConfig()) {
+  const fromConfig = config.defaultModel?.trim();
+  if (fromConfig) return fromConfig;
+  const fromEnv = process.env.KYNVER_DEFAULT_MODEL?.trim();
+  if (fromEnv) return fromEnv;
+  return GLOBAL_DEFAULT_MODEL;
+}
+function inferProviderFromModel(model) {
+  const m = (model ?? "").toLowerCase();
+  if (!m) return "claude";
+  if (m.includes("composer") || m.includes("cursor") || m.includes("codex") || m.startsWith("gpt-") || m.startsWith("gpt5")) {
+    return "cursor";
+  }
+  return "claude";
+}
+function isOpusLane(ref, title) {
+  if (ref.includes("deep") && ref.includes("review")) return true;
+  if (ref.includes("security")) return true;
+  if (ref.includes("plan_author") || ref.includes("plan-author")) return true;
+  if (title.includes("deep review") || title.includes("security review")) return true;
+  if (ref.includes("plan") && !ref.includes("review") && (ref.includes("author") || ref.includes("strategy"))) {
+    return true;
+  }
+  return false;
+}
+function inferModelRoutingFromTask(task) {
+  const ref = normalizeRef(taskString(task, "executorRef"));
+  const title = taskString(task, "title").toLowerCase();
+  const priority = taskString(task, "priority") || "normal";
+  const roleLane = normalizeRef(taskString(task, "roleLane"));
+  if (ref.includes("cursor") || ref.includes("codex") || ref.includes("composer") || ref.includes("copilot") || roleLane === "implementer" || roleLane === "repair_implementer") {
+    return { provider: "cursor", rule: "lane:implementation" };
+  }
+  if (ref.includes("landing") || title.startsWith("land:") || title.includes(" merge")) {
+    return {
+      model: "claude-haiku-4-5-20251001",
+      provider: "claude",
+      rule: "lane:landing"
+    };
+  }
+  if (ref.includes("review") || title.startsWith("review ") || roleLane.includes("review")) {
+    if (isOpusLane(ref, title) || roleLane === "deep_reviewer") {
+      return { model: "claude-opus-4-7", provider: "claude", rule: "lane:deep_review" };
+    }
+    return { model: "claude-sonnet-4-6", provider: "claude", rule: "lane:review" };
+  }
+  if (isOpusLane(ref, title) || roleLane === "plan_author") {
+    return { model: "claude-opus-4-7", provider: "claude", rule: "lane:planning" };
+  }
+  if (priority === "critical") {
+    return { model: "claude-opus-4-7", provider: "claude", rule: "priority:critical" };
+  }
+  if (priority === "low") {
+    return {
+      model: "claude-haiku-4-5-20251001",
+      provider: "claude",
+      rule: "priority:low"
+    };
+  }
+  return {
+    model: resolveGlobalDefaultModel(),
+    provider: "claude",
+    rule: "default:sonnet"
+  };
+}
+function resolveWorkerLaunch(input) {
+  if (input.explicitModel?.trim()) {
+    const model2 = input.explicitModel.trim();
+    return {
+      model: model2,
+      provider: input.explicitProvider?.trim() || inferProviderFromModel(model2),
+      rule: "explicit:cli",
+      requestedModel: model2
+    };
+  }
+  if (input.task && Object.keys(input.task).length > 0) {
+    const inferred = inferModelRoutingFromTask(input.task);
+    return {
+      ...inferred,
+      requestedModel: inferred.model
+    };
+  }
+  const model = resolveGlobalDefaultModel();
+  return {
+    model,
+    provider: input.explicitProvider?.trim() || inferProviderFromModel(model),
+    rule: "default:global",
+    requestedModel: model
+  };
+}
+function resolveModelFallback(startedModel, launchModel, providerDefault) {
+  return startedModel || launchModel || providerDefault || resolveGlobalDefaultModel() || CLAUDE_DEFAULT_MODEL;
+}
+
+// src/retry-limits.ts
+function positiveInt2(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+function readHarnessRetryLimits() {
+  return {
+    maxTaskAttempts: positiveInt2(process.env.KYNVER_MAX_TASK_ATTEMPTS, 3),
+    dispatchCooldownMs: positiveInt2(process.env.KYNVER_DISPATCH_COOLDOWN_MS, 5e3)
+  };
+}
+
+// src/supervisor.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync3 } from "node:fs";
+import path10 from "node:path";
+
+// src/prompt.ts
+function buildPrompt(input) {
+  const ownership = input.ownedPaths.length ? `Owned paths: ${input.ownedPaths.join(", ")}. Do not edit outside these paths without stopping and reporting why.` : "Owned paths: unrestricted for this worker, but keep edits tightly scoped.";
+  const compact = Boolean(input.model?.toLowerCase().includes("haiku"));
+  const progressLines = compact ? [
+    "Plan progress: when planId is set, use `kynver plan progress` for running|partial|blocked only; row `done` is MCP/session only.",
+    input.planId ? `Active planId: ${input.planId}` : "No planId on this worker."
+  ] : [
+    "Structured plan progress (required when planId is set):",
+    "- Harness checkpoints only: `kynver plan progress --plan <planId> --row <rowKey> --role implementer --status running|partial|blocked` (the by-id harness route rejects `done` and confirm events).",
+    "- When a slice is finished, emit `partial` with evidence (`--evidence pr:<url>`, `--evidence path:<file>`, or `--evidence command:<cmd>`). Do not propose or confirm row `done` from the worker CLI.",
+    "- Propose/confirm row `done` is MCP/session only: chat agents use `agent_os_plan_progress_event_append` on the slug route (implementer proposes with `proposed: true`; report_reviewer/deep_reviewer confirm with `proposed: false`).",
+    "- When blocked on operator/Ghost/runtime review, create a linked review task (MCP `agent_os_plan_review_task_create` or API) and pass `--review-task <taskId>`.",
+    "- Before the completion report: mark completion-report rows partial with evidence; do not skip report review.",
+    "- After implementation: wait for report_reviewer then deep_reviewer confirmation (via MCP/session agents) before follow-up rows close.",
+    input.planId ? `Active planId: ${input.planId}${input.taskId ? ` \xB7 taskId: ${input.taskId}` : ""}` : "No planId on this worker \u2014 still emit progress when you touch plan-scoped work."
+  ];
+  return [
+    "You are running under the Kynver AgentOS runtime.",
+    "Immediately state your plan before editing.",
+    ownership,
+    `Worktree: ${input.worktreePath}`,
+    `Progress heartbeat file: ${input.heartbeatPath}`,
+    "After each major step, append one JSON line to the heartbeat file with fields: ts, phase, summary, changedFiles, blocker.",
+    "Final response must include files changed, verification commands, and unresolved risks.",
+    "",
+    ...progressLines,
+    "",
+    "Task:",
+    input.task
+  ].join("\n");
+}
+
 // src/providers/cursor.ts
-import { closeSync as closeSync2, existsSync as existsSync7, openSync as openSync2, readdirSync as readdirSync3 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync8, openSync as openSync2 } from "node:fs";
 import { spawn as spawn2 } from "node:child_process";
+import path7 from "node:path";
+
+// src/providers/cursor-windows.ts
+import { existsSync as existsSync7, readdirSync as readdirSync3 } from "node:fs";
 import path6 from "node:path";
-var DEFAULT_CURSOR_MODEL = "composer-2.5";
-function latestVersionDir(versionsRoot) {
+var CURSOR_VERSION_DIR = /^\d{4}\.\d{1,2}\.\d{1,2}-[a-f0-9]+$/i;
+function parseCursorVersionSortKey(versionName) {
+  const datePart = versionName.split("-")[0];
+  const parts = datePart.split(".");
+  if (parts.length !== 3) return null;
+  const [year, month, day] = parts;
+  if (!year || !month || !day) return null;
+  return Number(`${year}${month.padStart(2, "0")}${day.padStart(2, "0")}`);
+}
+function pickLatestCursorVersionDir(agentRoot) {
+  const versionsRoot = path6.join(agentRoot, "versions");
   if (!existsSync7(versionsRoot)) return null;
-  const versions = readdirSync3(versionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^\d{4}\.\d/.test(entry.name)).map((entry) => entry.name).sort((a, b) => b.localeCompare(a));
-  return versions[0] ? path6.join(versionsRoot, versions[0]) : null;
-}
-function resolveBundledCursor(versionDir) {
+  let bestDir = null;
+  let bestKey = -1;
+  for (const entry of readdirSync3(versionsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !CURSOR_VERSION_DIR.test(entry.name)) continue;
+    const key = parseCursorVersionSortKey(entry.name);
+    if (key == null || key <= bestKey) continue;
+    bestKey = key;
+    bestDir = path6.join(versionsRoot, entry.name);
+  }
+  return bestDir;
+}
+function resolveWindowsCursorBundled(agentRoot) {
+  const root = agentRoot?.trim() || path6.join(process.env.LOCALAPPDATA || "", "cursor-agent");
+  const directNode = path6.join(root, "node.exe");
+  const directIndex = path6.join(root, "index.js");
+  if (existsSync7(directNode) && existsSync7(directIndex)) {
+    return { nodeExe: directNode, indexJs: directIndex, versionDir: root };
+  }
+  const versionDir = pickLatestCursorVersionDir(root);
+  if (!versionDir) return null;
   const nodeExe = path6.join(versionDir, "node.exe");
   const indexJs = path6.join(versionDir, "index.js");
   if (!existsSync7(nodeExe) || !existsSync7(indexJs)) return null;
-  return { executable: nodeExe, prefixArgs: [indexJs], shell: false, detached: true };
+  return { nodeExe, indexJs, versionDir };
 }
-function resolveWindowsCursorSpawn(agentBin) {
-  const agentRoot = path6.dirname(agentBin);
-  const direct = resolveBundledCursor(agentRoot);
-  if (direct) return direct;
-  const versionDir = latestVersionDir(path6.join(agentRoot, "versions"));
-  return versionDir ? resolveBundledCursor(versionDir) : null;
+
+// src/providers/cursor.ts
+var DEFAULT_CURSOR_MODEL = "composer-2.5";
+function bundledSpawnTarget(nodeExe, indexJs, versionDir) {
+  return {
+    executable: nodeExe,
+    prefixArgs: [indexJs],
+    shell: false,
+    detached: true,
+    bundledVersionDir: versionDir
+  };
 }
 function resolveCursorSpawn(agentBin) {
-  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(agentBin)) {
-    const bundled = resolveWindowsCursorSpawn(agentBin);
-    if (bundled) return bundled;
-    return { executable: agentBin, prefixArgs: [], shell: true, detached: false };
+  if (process.platform === "win32") {
+    const isCursorWrapper = /\.(cmd|bat)$/i.test(agentBin);
+    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync8(path7.join(path7.dirname(agentBin), "index.js"));
+    const isDefaultShim = agentBin === "agent";
+    if (isCursorWrapper || isBundledNode || isDefaultShim) {
+      const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path7.dirname(agentBin)) : isBundledNode ? {
+        nodeExe: agentBin,
+        indexJs: path7.join(path7.dirname(agentBin), "index.js"),
+        versionDir: path7.dirname(agentBin)
+      } : resolveWindowsCursorBundled();
+      if (bundled) {
+        return bundledSpawnTarget(bundled.nodeExe, bundled.indexJs, bundled.versionDir);
+      }
+      throw new Error(
+        "Cursor Agent on Windows has no headless bundled node.exe under %LOCALAPPDATA%\\cursor-agent\\versions\\\u2026. Run `agent login` / update Cursor Agent CLI, use `--provider claude`, or set KYNVER_CURSOR_AGENT_ROOT to the cursor-agent folder."
+      );
+    }
   }
   return { executable: agentBin, prefixArgs: [], shell: false, detached: true };
 }
@@ -1135,11 +1395,23 @@ function resolveAgentBin() {
   const configured = process.env.KYNVER_CURSOR_AGENT_BIN?.trim() || process.env.CURSOR_AGENT_BIN?.trim();
   if (configured) return configured;
   if (process.platform === "win32") {
-    const localAgent = path6.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
-    if (existsSync7(localAgent)) return localAgent;
+    const bundled = resolveWindowsCursorBundled(
+      process.env.KYNVER_CURSOR_AGENT_ROOT?.trim() || void 0
+    );
+    if (bundled) return bundled.nodeExe;
+    const localAgent = path7.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
+    if (existsSync8(localAgent)) return localAgent;
   }
   return "agent";
 }
+function cursorWorkerEnv(agentBin, spawnTarget) {
+  return {
+    ...process.env,
+    CI: "1",
+    NO_COLOR: "1",
+    ...spawnTarget.bundledVersionDir ? { CURSOR_INVOKED_AS: path7.basename(agentBin) || "agent.cmd" } : {}
+  };
+}
 var cursorProvider = {
   name: "cursor",
   defaultModel: DEFAULT_CURSOR_MODEL,
@@ -1172,16 +1444,13 @@ var cursorProvider = {
         model,
         opts.prompt
       ],
-      {
+      hiddenSpawnOptions({
         cwd: opts.worktreePath,
         detached: spawnTarget.detached,
         shell: spawnTarget.shell,
         stdio: ["ignore", stdoutFd, stderrFd],
-        env: {
-          ...process.env,
-          ...spawnTarget.prefixArgs.length > 0 ? { CURSOR_INVOKED_AS: path6.basename(agentBin) } : {}
-        }
-      }
+        env: cursorWorkerEnv(agentBin, spawnTarget)
+      })
     );
     closeSync2(stdoutFd);
     closeSync2(stderrFd);
@@ -1213,12 +1482,12 @@ function resolveWorkerProvider(name) {
 
 // src/auto-complete.ts
 import { spawn as spawn3 } from "node:child_process";
-import { existsSync as existsSync8, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync9, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
+import path9 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/worker-ops.ts
-import path7 from "node:path";
+import path8 from "node:path";
 async function postCompletion(url, secret, body) {
   const res = await fetch(url, {
     method: "POST",
@@ -1247,9 +1516,13 @@ function persistCompletionBlocker(worker, reason) {
   else delete worker.completionBlocker;
   saveWorker(worker.runId, worker);
 }
+function workerStatusOptions(run) {
+  return run ? { base: run.base, baseCommit: run.baseCommit } : {};
+}
 async function tryCompleteWorker(args) {
   const worker = loadWorker(String(args.run), String(args.name));
-  const status = computeWorkerStatus(worker);
+  const run = loadRun(worker.runId);
+  const status = computeWorkerStatus(worker, workerStatusOptions(run));
   const agentOsId = (args.agentOsId ? String(args.agentOsId) : worker.agentOsId) || "";
   const taskId = (args.taskId ? String(args.taskId) : worker.taskId) || null;
   if (!agentOsId) {
@@ -1293,7 +1566,8 @@ async function tryCompleteWorker(args) {
 async function completeWorker(args) {
   try {
     const worker = loadWorker(String(args.run), String(args.name));
-    const status = computeWorkerStatus(worker);
+    const run = loadRun(worker.runId);
+    const status = computeWorkerStatus(worker, workerStatusOptions(run));
     const agentOsId = (args.agentOsId ? String(args.agentOsId) : worker.agentOsId) || "";
     const taskId = (args.taskId ? String(args.taskId) : worker.taskId) || null;
     if (!agentOsId) {
@@ -1340,8 +1614,9 @@ async function completeWorker(args) {
 }
 function workerStatus(args) {
   const worker = loadWorker(String(args.run), String(args.name));
-  const status = computeWorkerStatus(worker);
-  writeJson(path7.join(worker.workerDir, "last-status.json"), status);
+  const run = loadRun(worker.runId);
+  const status = computeWorkerStatus(worker, workerStatusOptions(run));
+  writeJson(path8.join(worker.workerDir, "last-status.json"), status);
   console.log(JSON.stringify(status, null, 2));
 }
 function runStatus(args) {
@@ -1349,20 +1624,27 @@ function runStatus(args) {
   const names = Object.keys(run.workers || {});
   const workers = names.map((name) => {
     const worker = readJson(
-      path7.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path8.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) {
       return { worker: name, status: "missing", attention: "needs_attention", attentionReason: "worker.json not found" };
     }
-    const status = computeWorkerStatus(worker, { base: run.base });
+    const status = computeWorkerStatus(worker, {
+      base: run.base,
+      baseCommit: run.baseCommit
+    });
+    const headCommit = status.gitAncestry.headIsAncestorOfBase === false && status.gitAncestry.head ? status.gitAncestry.head : void 0;
     const rawBlocker = worker.completionBlocker;
     const completionBlocker = typeof rawBlocker === "string" && rawBlocker ? rawBlocker : void 0;
+    const boardStatus = completionBlocker ? "blocked" : status.status;
+    const boardAttention = completionBlocker ? "blocked" : status.attention.state;
     return {
       worker: status.worker,
-      status: completionBlocker ? "blocked" : status.status,
-      attention: completionBlocker ? "blocked" : status.attention.state,
+      status: boardStatus,
+      attention: boardAttention,
       attentionReason: completionBlocker ?? status.attention.reason,
+      landingBlocked: status.finalResult ? boardAttention === "needs_attention" || boardAttention === "blocked" : false,
       pid: status.pid,
       alive: status.alive,
       currentTool: status.currentTool,
@@ -1371,7 +1653,14 @@ function runStatus(args) {
       lastHeartbeatSummary: status.lastHeartbeatSummary,
       heartbeatBlocker: status.heartbeatBlocker,
       changedFileCount: status.changedFiles.length,
+      changedFiles: status.changedFiles,
       branch: status.branch,
+      model: typeof worker.model === "string" ? worker.model : void 0,
+      routingRule: typeof worker.routingRule === "string" ? worker.routingRule : void 0,
+      requestedModel: typeof worker.requestedModel === "string" ? worker.requestedModel : void 0,
+      headCommit,
+      gitAncestry: status.gitAncestry,
+      finalResult: status.finalResult,
       ancestry: status.gitAncestry.relation,
       ancestryChecked: status.gitAncestry.checked
     };
@@ -1385,7 +1674,7 @@ function runStatus(args) {
     needsAttention: workers.filter((w) => w.attention && w.attention !== "ok" && w.attention !== "done").map((w) => w.worker),
     workers
   };
-  writeJson(path7.join(runDirectory(run.id), "last-board.json"), board);
+  writeJson(path8.join(runDirectory(run.id), "last-board.json"), board);
   console.log(JSON.stringify(board, null, 2));
 }
 function tailWorker(args) {
@@ -1524,12 +1813,12 @@ async function autoCompleteWorkerCli(raw) {
   }
 }
 function resolveDefaultCliPath() {
-  return path8.join(fileURLToPath(new URL(".", import.meta.url)), "cli.js");
+  return path9.join(fileURLToPath(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnCompletionSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath();
-  if (!existsSync8(cliPath)) return void 0;
-  const logPath = path8.join(opts.workerDir, "auto-complete.log");
+  if (!existsSync9(cliPath)) return void 0;
+  const logPath = path9.join(opts.workerDir, "auto-complete.log");
   let logFd;
   try {
     logFd = openSync3(logPath, "a");
@@ -1555,11 +1844,15 @@ function spawnCompletionSidecar(opts) {
   if (opts.baseUrl) args.push("--base-url", opts.baseUrl);
   if (opts.secret) args.push("--secret", opts.secret);
   try {
-    const child = spawn3(nodeExecutable, args, {
-      detached: true,
-      stdio,
-      env: process.env
-    });
+    const child = spawn3(
+      nodeExecutable,
+      args,
+      hiddenSpawnOptions({
+        detached: true,
+        stdio,
+        env: process.env
+      })
+    );
     if (logFd !== void 0) closeSync3(logFd);
     child.unref();
     return { pid: child.pid, logPath, cliPath };
@@ -1583,8 +1876,17 @@ function spawnWorkerProcess(run, opts) {
   const name = safeSlug(rawName);
   if (run.workers?.[name]) throw new Error(`worker already exists in run ${run.id}: ${name}`);
   if (!opts.task) throw new Error(`missing task text for worker ${name}`);
-  const provider = resolveWorkerProvider(opts.provider);
-  let launchModel = opts.model;
+  const routing = opts.routingRule || opts.requestedModel ? {
+    provider: opts.provider || "claude",
+    model: opts.model,
+    rule: opts.routingRule || "explicit:spawn",
+    requestedModel: opts.requestedModel ?? opts.model
+  } : resolveWorkerLaunch({
+    explicitModel: opts.model,
+    explicitProvider: opts.provider
+  });
+  const provider = resolveWorkerProvider(routing.provider);
+  let launchModel = routing.model;
   if (provider.preflightModel) {
     const preflight = provider.preflightModel(opts.model);
     if (!preflight.ok) {
@@ -1598,21 +1900,24 @@ function spawnWorkerProcess(run, opts) {
     launchModel = preflight.model;
   }
   const { worktreesDir } = getPaths();
-  const workerDir = path9.join(runDirectory(run.id), "workers", name);
+  const workerDir = path10.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
-  const worktreePath = path9.join(worktreesDir, run.id, name);
+  const worktreePath = path10.join(worktreesDir, run.id, name);
   const branch = opts.branch || `agent/${run.id}/${name}`;
-  if (existsSync9(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
+  if (existsSync10(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
   git(run.repo, ["fetch", "origin", "--prune"], { allowFailure: true });
   git(run.repo, ["worktree", "add", "-b", branch, worktreePath, run.baseCommit], { throwError: true });
-  const stdoutPath = path9.join(workerDir, "stdout.jsonl");
-  const stderrPath = path9.join(workerDir, "stderr.log");
-  const heartbeatPath = path9.join(workerDir, "heartbeat.jsonl");
+  const stdoutPath = path10.join(workerDir, "stdout.jsonl");
+  const stderrPath = path10.join(workerDir, "stderr.log");
+  const heartbeatPath = path10.join(workerDir, "heartbeat.jsonl");
   const prompt = buildPrompt({
     task: opts.task,
     ownedPaths: opts.ownedPaths || [],
     worktreePath,
-    heartbeatPath
+    heartbeatPath,
+    planId: opts.planId,
+    taskId: opts.taskId,
+    model: launchModel
   });
   let started;
   try {
@@ -1634,7 +1939,7 @@ function spawnWorkerProcess(run, opts) {
     git(run.repo, ["branch", "-D", branch], { allowFailure: true });
     throw error;
   }
-  const model = started.model || launchModel || provider.defaultModel || "claude-opus-4-7";
+  const model = resolveModelFallback(started.model, launchModel, provider.defaultModel);
   const worker = {
     name,
     runId: run.id,
@@ -1653,21 +1958,32 @@ function spawnWorkerProcess(run, opts) {
     ...opts.planId ? { planId: String(opts.planId) } : {},
     ...opts.leaseOwner ? { leaseOwner: String(opts.leaseOwner) } : {},
     ...opts.dispatched ? { dispatched: true } : {},
+    routingRule: routing.rule,
+    ...routing.requestedModel ? { requestedModel: routing.requestedModel } : {},
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveWorker(run.id, worker);
-  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path9.join(workerDir, "worker.json") } };
+  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path10.join(workerDir, "worker.json") } };
   run.status = "running";
   saveRun(run);
   if (worker.agentOsId && worker.taskId) {
+    let sidecarSpawned;
     try {
-      spawnCompletionSidecar({
+      sidecarSpawned = spawnCompletionSidecar({
         runId: run.id,
         workerName: name,
         workerDir,
         agentOsId: worker.agentOsId
       });
-    } catch {
+    } catch (error) {
+      const reason = `completion sidecar failed to spawn: ${error.message}`;
+      worker.completionBlocker = reason;
+      saveWorker(run.id, worker);
+    }
+    if (!sidecarSpawned) {
+      const reason = "completion sidecar failed to spawn (CLI not found or spawn error)";
+      worker.completionBlocker = reason;
+      saveWorker(run.id, worker);
     }
   }
   return worker;
@@ -1802,17 +2118,34 @@ async function dispatchRun(args) {
       console.log(JSON.stringify(summary2, null, 2));
       return;
     }
+    const retryLimits = readHarnessRetryLimits();
     const outcomes = [];
     for (const decision of result.started) {
       const task = decision.task;
+      const attempt = Number(task.attempt) || 1;
+      if (attempt > retryLimits.maxTaskAttempts) {
+        outcomes.push({
+          taskId: task.id,
+          started: false,
+          error: `task attempt ${attempt} exceeds KYNVER_MAX_TASK_ATTEMPTS (${retryLimits.maxTaskAttempts})`
+        });
+        continue;
+      }
       const name = safeSlug(`t-${task.id}-a${task.attempt}`);
+      const routing = resolveWorkerLaunch({
+        explicitModel: args.model ? String(args.model) : void 0,
+        task
+      });
       try {
         const planId = task.planId ? String(task.planId) : void 0;
         const worker = spawnWorkerProcess(run, {
           name,
           task: buildDispatchTaskText(task, agentOsId),
           ownedPaths: args.owned ? String(args.owned).split(",").map((s) => s.trim()).filter(Boolean) : [],
-          model: args.model ? String(args.model) : void 0,
+          model: routing.model,
+          provider: routing.provider,
+          routingRule: routing.rule,
+          requestedModel: routing.requestedModel,
           agentOsId,
           taskId: String(task.id),
           planId,
@@ -1824,7 +2157,10 @@ async function dispatchRun(args) {
           started: true,
           worker: worker.name,
           pid: worker.pid,
-          branch: worker.branch
+          branch: worker.branch,
+          model: worker.model,
+          provider: routing.provider,
+          routingRule: routing.rule
         });
       } catch (error) {
         const releaseUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(String(task.id))}/release`;
@@ -1879,7 +2215,7 @@ function redactHarness(text, secret) {
 }
 
 // src/validate.ts
-import path10 from "node:path";
+import path11 from "node:path";
 var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 var WORKER_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
 function validateRunId(runId) {
@@ -1893,15 +2229,15 @@ function validateWorkerName(name) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path10.resolve(repo);
+  const resolved = path11.resolve(repo);
   if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
   return resolved;
 }
 function validateOwnedPaths(repoRoot, ownedPaths) {
   return ownedPaths.map((owned) => {
-    const resolved = path10.resolve(repoRoot, owned);
-    const rel = path10.relative(repoRoot, resolved);
-    if (rel.startsWith("..") || path10.isAbsolute(rel)) {
+    const resolved = path11.resolve(repoRoot, owned);
+    const rel = path11.relative(repoRoot, resolved);
+    if (rel.startsWith("..") || path11.isAbsolute(rel)) {
       throw new Error(`owned path escapes repo: ${owned}`);
     }
     return resolved;
@@ -1913,14 +2249,14 @@ function validateTailLines(lines) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
-import path11 from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4 } from "node:fs";
+import path12 from "node:path";
 function createRun(args) {
   const repo = validateRepo(required(String(args.repo || ""), "--repo"));
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync10(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync11(dir)) failExists(`run already exists: ${id}`);
   mkdirSync4(dir, { recursive: true });
   const base = String(args.base || "origin/main");
   const baseCommit = git(repo, ["rev-parse", base]).trim();
@@ -1934,12 +2270,12 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path11.join(dir, "run.json"), run);
+  writeJson(path12.join(dir, "run.json"), run);
   console.log(JSON.stringify({ runId: id, runDir: dir, repo, base, baseCommit }, null, 2));
 }
 function listRuns() {
   const { runsDir } = getPaths();
-  const rows = listRunIds(runsDir).map((id) => readJson(path11.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
+  const rows = listRunIds(runsDir).map((id) => readJson(path12.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
     id: run.id,
     name: run.name,
     status: run.status,
@@ -1954,7 +2290,7 @@ function failExists(message) {
 }
 
 // src/sweep.ts
-import path12 from "node:path";
+import path13 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -1966,7 +2302,7 @@ async function sweepRun(args) {
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path13.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
@@ -2013,10 +2349,13 @@ import { mkdirSync as mkdirSync5, realpathSync } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/pipeline-tick.ts
+import path17 from "node:path";
+
+// src/stale-reconcile.ts
 import path15 from "node:path";
 
 // src/finalize.ts
-import path13 from "node:path";
+import path14 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set(["running", "dispatching", "pending", "queued"]);
 function terminalStatusFor(run) {
   const names = Object.keys(run.workers || {});
@@ -2024,13 +2363,17 @@ function terminalStatusFor(run) {
   let anyAlive = false;
   let anyResult = false;
   let anyCompletionBlocked = false;
+  let anyLandingBlocked = false;
   for (const name of names) {
     const worker = readJson(
-      path13.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path14.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) continue;
-    const status = computeWorkerStatus(worker);
+    const status = computeWorkerStatus(worker, {
+      base: run.base,
+      baseCommit: run.baseCommit
+    });
     if (status.alive && !status.finalResult) {
       anyAlive = true;
       break;
@@ -2038,10 +2381,14 @@ function terminalStatusFor(run) {
     if (typeof worker.completionBlocker === "string" && worker.completionBlocker) {
       anyCompletionBlocked = true;
     }
-    if (status.finalResult) anyResult = true;
+    if (isLandingBlockedWorkerStatus(status)) {
+      anyLandingBlocked = true;
+    }
+    if (status.finalResult && status.attention.state === "done") anyResult = true;
   }
   if (anyAlive) return null;
   if (anyCompletionBlocked) return null;
+  if (anyLandingBlocked) return null;
   return anyResult ? "completed" : "failed";
 }
 function finalizeStaleRuns() {
@@ -2058,8 +2405,82 @@ function finalizeStaleRuns() {
   return finalized;
 }
 
+// src/stale-reconcile.ts
+var STALE_RECONCILE_HEARTBEAT_MS = 15 * 60 * 1e3;
+function staleReconcileDisabled() {
+  return process.env.KYNVER_NO_STALE_CLEANUP === "1";
+}
+function reconcileStaleWorkers() {
+  if (staleReconcileDisabled()) {
+    return { workers: [], finalizedRuns: finalizeStaleRuns() };
+  }
+  const outcomes = [];
+  const now = Date.now();
+  for (const run of listRunRecords()) {
+    for (const name of Object.keys(run.workers || {})) {
+      const workerPath = path15.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const worker = readJson(workerPath, void 0);
+      if (!worker || worker.status !== "running") {
+        outcomes.push({
+          runId: run.id,
+          worker: name,
+          action: "skipped",
+          reason: worker ? `worker status is ${worker.status}` : "worker.json missing"
+        });
+        continue;
+      }
+      const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
+      if (status.finalResult) {
+        outcomes.push({ runId: run.id, worker: name, action: "skipped", reason: "final result present" });
+        continue;
+      }
+      if (!status.alive) {
+        const nextStatus = status.attention.state === "blocked" ? "blocked" : status.status === "done" ? "done" : "exited";
+        worker.status = nextStatus;
+        worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+        worker.reconcileReason = status.attention.reason;
+        saveWorker(run.id, worker);
+        outcomes.push({
+          runId: run.id,
+          worker: name,
+          action: "marked_exited",
+          reason: status.attention.reason
+        });
+        continue;
+      }
+      if (status.attention.state === "stale" && worker.pid && isPidAlive(worker.pid)) {
+        const hbMs = status.lastHeartbeatAt ? Date.parse(status.lastHeartbeatAt) : NaN;
+        const actMs = status.lastActivityAt ? Date.parse(status.lastActivityAt) : NaN;
+        const hbStale = !Number.isFinite(hbMs) || now - hbMs > STALE_RECONCILE_HEARTBEAT_MS;
+        const actStale = Number.isFinite(actMs) && now - actMs > STALE_MS;
+        if (hbStale && actStale) {
+          killWorkerProcess(worker.pid, "SIGTERM");
+          worker.status = "exited";
+          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+          worker.reconcileReason = `reconciled stale worker: ${status.attention.reason}`;
+          saveWorker(run.id, worker);
+          outcomes.push({
+            runId: run.id,
+            worker: name,
+            action: "killed_stale",
+            reason: status.attention.reason
+          });
+          continue;
+        }
+      }
+      outcomes.push({
+        runId: run.id,
+        worker: name,
+        action: "skipped",
+        reason: status.attention.reason
+      });
+    }
+  }
+  return { workers: outcomes, finalizedRuns: finalizeStaleRuns() };
+}
+
 // src/plan-progress-daemon-sync.ts
-import path14 from "node:path";
+import path16 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -2083,7 +2504,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path14.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path16.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -2137,7 +2558,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path15.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path17.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId) continue;
@@ -2172,7 +2593,7 @@ async function runPipelineTick(args) {
   const execute = args.execute !== false && args.execute !== "false";
   runStatus({ run: runId });
   const completedWorkers = await completeFinishedWorkers(runId, args);
-  const finalizedStaleRuns = finalizeStaleRuns();
+  const staleReconcile = reconcileStaleWorkers();
   const planProgressSync = await syncActiveWorkerPlanProgress(runId, args);
   const workspacePrefs = await fetchWorkspaceRuntimePreferences(agentOsId, args);
   const resourceGate = observeRunnerResourceGate({
@@ -2213,7 +2634,7 @@ async function runPipelineTick(args) {
     execute,
     resourceGate,
     completedWorkers,
-    finalizedStaleRuns,
+    staleReconcile,
     planProgressSync,
     operatorTick,
     sweep,
@@ -2431,6 +2852,7 @@ if (isCliEntry) {
 }
 export {
   DEFAULT_DISPATCH_LEASE_MS,
+  assessWorkerLanding,
   autoCompleteWorker,
   autoCompleteWorkerCli,
   buildDispatchTaskText,
@@ -2443,6 +2865,7 @@ export {
   dispatchRun,
   getHarnessPaths,
   isFinishedWorkerStatus,
+  isLandingBlockedWorkerStatus,
   listRuns,
   loadUserConfig,
   main,