@kynver-app/runtime 0.1.29 → 0.1.32

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/dispatch.ts
+import path12 from "node:path";
+
 // src/config.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir } from "node:os";
@@ -422,12 +425,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 path23 = input.diskPath?.trim() || "/";
+  const path25 = 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(path23);
+  const stats = statfsSync(path25);
   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;
@@ -447,7 +450,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path23,
+    path: path25,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -536,6 +539,14 @@ function runDirectory(id) {
 
 // src/heartbeat.ts
 import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+function isTerminalHeartbeatPhase(phase) {
+  return phase === "complete";
+}
+function terminalFinalResultFromHeartbeat(heartbeat) {
+  if (!isTerminalHeartbeatPhase(heartbeat.lastHeartbeatPhase)) return null;
+  const summary = heartbeat.lastHeartbeatSummary?.trim();
+  return summary || "completed";
+}
 function parseHeartbeat(file) {
   const result = {
     heartbeatCount: 0,
@@ -561,7 +572,27 @@ function parseHeartbeat(file) {
 
 // src/stream.ts
 import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
-function parseClaudeStream(file) {
+function eventTimestampIso(event) {
+  const tsMs = event.timestamp_ms;
+  return event.timestamp || event.ts || (tsMs ? new Date(tsMs).toISOString() : void 0);
+}
+function cursorToolNameFromCall(toolCall) {
+  if (!toolCall) return null;
+  for (const key of Object.keys(toolCall)) {
+    if (key.endsWith("ToolCall")) {
+      const stem = key.slice(0, -"ToolCall".length);
+      return stem.length ? stem : key;
+    }
+  }
+  return null;
+}
+function recordStreamResult(result, event) {
+  result.finalResult = event.result || event.subtype || event.terminal_reason || "completed";
+  if (event.is_error) {
+    result.error = String(event.result || event.api_error_status || "stream result error");
+  }
+}
+function parseHarnessStream(file) {
   const result = {
     firstEventAt: null,
     lastEventAt: null,
@@ -574,8 +605,7 @@ function parseClaudeStream(file) {
   for (const line of lines) {
     const event = safeJson(line);
     if (!event) continue;
-    const tsMs = event.timestamp_ms;
-    const ts = event.timestamp || event.ts || (tsMs ? new Date(tsMs).toISOString() : void 0);
+    const ts = eventTimestampIso(event);
     if (ts) {
       result.firstEventAt ||= ts;
       result.lastEventAt = ts;
@@ -591,13 +621,20 @@ function parseClaudeStream(file) {
         if (tool) result.currentTool = String(tool.name || result.currentTool);
       }
     }
+    if (event.type === "tool_call" && event.subtype === "started") {
+      const toolCall = event.tool_call && typeof event.tool_call === "object" && !Array.isArray(event.tool_call) ? event.tool_call : void 0;
+      const name = cursorToolNameFromCall(toolCall);
+      if (name) result.currentTool = name;
+    }
     if (event.type === "result") {
-      result.finalResult = event.result || event.subtype || event.terminal_reason || "completed";
-      if (event.is_error) result.error = String(event.result || event.api_error_status || "Claude result error");
+      recordStreamResult(result, event);
     }
   }
   return result;
 }
+function parseClaudeStream(file) {
+  return parseHarnessStream(file);
+}
 function summarizeEvent(event) {
   if (event.type === "system" && event.subtype) {
     return `[system:${event.subtype}] ${String(event.status || event.cwd || "")}`.trim();
@@ -628,6 +665,12 @@ function summarizeEvent(event) {
     const result = event.tool_use_result;
     return `[tool:result] stdout=${JSON.stringify(result.stdout || "")} stderr=${JSON.stringify(result.stderr || "")}`;
   }
+  if (event.type === "tool_call") {
+    const subtype = String(event.subtype || "");
+    const toolCall = event.tool_call && typeof event.tool_call === "object" && !Array.isArray(event.tool_call) ? event.tool_call : void 0;
+    const name = cursorToolNameFromCall(toolCall) ?? "tool";
+    return `[tool:${subtype}] ${name}`;
+  }
   if (event.type === "result") {
     return `[result] ${event.subtype || ""} ${oneLine(String(event.result || ""))}`.trim();
   }
@@ -965,8 +1008,9 @@ function computeAttention(input) {
   return { state: "ok", reason: "recent activity" };
 }
 function computeWorkerStatus(worker, options = {}) {
-  const parsed = parseClaudeStream(worker.stdoutPath);
+  const parsed = parseHarnessStream(worker.stdoutPath);
   const heartbeat = parseHeartbeat(worker.heartbeatPath);
+  const finalResult = parsed.finalResult ?? terminalFinalResultFromHeartbeat(heartbeat);
   const alive = isPidAlive(worker.pid);
   const stdoutBytes = fileSize(worker.stdoutPath);
   const stderrBytes = fileSize(worker.stderrPath);
@@ -983,11 +1027,11 @@ function computeWorkerStatus(worker, options = {}) {
     fileMtime(worker.stderrPath),
     fileMtime(worker.heartbeatPath)
   ]);
-  const error = parsed.error || (!alive && !parsed.finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0);
+  const error = parsed.error || (!alive && !finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0);
   const completionBlocker = typeof worker.completionBlocker === "string" && worker.completionBlocker.trim() ? worker.completionBlocker.trim() : null;
   const attention = computeAttention({
     alive,
-    finalResult: parsed.finalResult,
+    finalResult,
     firstEventAt: parsed.firstEventAt,
     stdoutBytes,
     heartbeatBytes,
@@ -999,7 +1043,7 @@ function computeWorkerStatus(worker, options = {}) {
     gitAncestry,
     completionBlocker
   });
-  const workerStatusLabel = completionBlocker || attention.state === "blocked" ? "blocked" : attention.state === "done" ? "done" : parsed.finalResult ? "exited" : alive ? "running" : "exited";
+  const workerStatusLabel = completionBlocker || attention.state === "blocked" ? "blocked" : attention.state === "done" ? "done" : finalResult ? "exited" : alive ? "running" : "exited";
   return {
     runId: worker.runId,
     worker: worker.name,
@@ -1022,7 +1066,7 @@ function computeWorkerStatus(worker, options = {}) {
     lastHeartbeatPhase: heartbeat.lastHeartbeatPhase,
     lastHeartbeatSummary: heartbeat.lastHeartbeatSummary,
     heartbeatBlocker: heartbeat.heartbeatBlocker,
-    finalResult: parsed.finalResult,
+    finalResult,
     error,
     changedFiles,
     gitAncestry
@@ -1218,6 +1262,12 @@ var FOREIGN_MODEL_RE = /^(?:gpt-|gpt5|o1|o3|o4|gemini-|grok-|composer|deepseek|l
 function looksLikeClaudeModel(model) {
   return /^claude[-_]/i.test(model) || /^(?:opus|sonnet|haiku)\b/i.test(model);
 }
+var CURSOR_MODEL_ALIASES = /* @__PURE__ */ new Set(["cursor"]);
+function normalizeCursorModelAlias(model) {
+  const key = model.trim().toLowerCase();
+  if (CURSOR_MODEL_ALIASES.has(key)) return "auto";
+  return null;
+}
 function preflightClaudeModel(model, defaultModel) {
   const requested = (model ?? "").trim();
   if (!requested) {
@@ -1250,6 +1300,16 @@ function preflightCursorModel(model, defaultModel) {
   if (!requested) {
     return { ok: true, model: defaultModel, normalized: false };
   }
+  const aliasLaunch = normalizeCursorModelAlias(requested);
+  if (aliasLaunch) {
+    return {
+      ok: true,
+      model: aliasLaunch,
+      normalized: true,
+      requested,
+      note: `normalized model "${requested}" \u2192 "${aliasLaunch}" (Cursor provider alias \u2014 use "auto" or a composer id, not "cursor")`
+    };
+  }
   if (looksLikeClaudeModel(requested)) {
     return {
       ok: false,
@@ -1311,6 +1371,7 @@ var claudeProvider = {
 
 // src/model-routing.ts
 var GLOBAL_DEFAULT_MODEL = "claude-sonnet-4-6";
+var CURSOR_DEFAULT_MODEL = "composer-2.5";
 function taskString2(task, key) {
   const v = task[key];
   return typeof v === "string" ? v.trim() : "";
@@ -1333,6 +1394,27 @@ function inferProviderFromModel(model) {
   }
   return "claude";
 }
+function normalizeProviderAliasModel(model, explicitProvider) {
+  const alias = model.trim().toLowerCase();
+  const provider = explicitProvider?.trim();
+  if (alias === "cursor") {
+    return {
+      model: CURSOR_DEFAULT_MODEL,
+      provider: "cursor",
+      rule: provider && provider !== "cursor" ? "explicit:model_provider_alias_overrode_provider" : "explicit:model_provider_alias",
+      requestedModel: model
+    };
+  }
+  if (alias === "claude" || alias === "anthropic") {
+    return {
+      model: CLAUDE_DEFAULT_MODEL,
+      provider: "claude",
+      rule: provider && provider !== "claude" ? "explicit:model_provider_alias_overrode_provider" : "explicit:model_provider_alias",
+      requestedModel: model
+    };
+  }
+  return null;
+}
 function isOpusLane(ref, title) {
   if (ref.includes("deep") && ref.includes("review")) return true;
   if (ref.includes("security")) return true;
@@ -1380,15 +1462,18 @@ function inferModelRoutingFromTask(task) {
       rule: "priority:low"
     };
   }
+  const model = resolveGlobalDefaultModel();
   return {
-    model: resolveGlobalDefaultModel(),
-    provider: "claude",
-    rule: "default:sonnet"
+    model,
+    provider: inferProviderFromModel(model),
+    rule: "default:global"
   };
 }
 function resolveWorkerLaunch(input) {
   if (input.explicitModel?.trim()) {
     const model2 = input.explicitModel.trim();
+    const providerAlias = normalizeProviderAliasModel(model2, input.explicitProvider);
+    if (providerAlias) return providerAlias;
     return {
       model: model2,
       provider: input.explicitProvider?.trim() || inferProviderFromModel(model2),
@@ -1428,20 +1513,89 @@ function readHarnessRetryLimits() {
   };
 }
 
+// src/lease-renewal.ts
+import path6 from "node:path";
+function workerRecord(runId, name) {
+  return readJson(
+    path6.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    void 0
+  );
+}
+async function renewActiveTaskLeases(runId, args) {
+  const run = loadRun(runId);
+  const agentOsId = String(args.agentOsId || "");
+  if (!agentOsId) {
+    return { renewed: [], failed: [], skipped: [] };
+  }
+  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 leaseDurationMs = Number(args.leaseMs) > 0 ? Math.floor(Number(args.leaseMs)) : DEFAULT_DISPATCH_LEASE_MS;
+  const leaseOwner = `kynver-harness:${runId}`;
+  const renewed = [];
+  const failed = [];
+  const skipped = [];
+  for (const name of Object.keys(run.workers || {})) {
+    const worker = workerRecord(runId, name);
+    if (!worker?.taskId || !worker.agentOsId) {
+      skipped.push(name);
+      continue;
+    }
+    if (!isPidAlive(worker.pid)) {
+      skipped.push(name);
+      continue;
+    }
+    const status = computeWorkerStatus(worker);
+    if (status.status === "done") {
+      skipped.push(name);
+      continue;
+    }
+    const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(worker.taskId)}/renew-lease`;
+    const res = await postJsonWithCredentialRefresh(
+      url,
+      secret,
+      { leaseOwner, leaseDurationMs },
+      { agentOsId, baseUrl: base }
+    );
+    if (res.ok) {
+      renewed.push(name);
+      continue;
+    }
+    const reason = res.response && typeof res.response === "object" && "reason" in res.response ? String(res.response.reason ?? `http ${res.status}`) : `http ${res.status}`;
+    failed.push({ worker: name, reason });
+  }
+  return { renewed, failed, skipped };
+}
+function hasLiveWorkerForTask(runId, taskId) {
+  const run = loadRun(runId);
+  for (const name of Object.keys(run.workers || {})) {
+    const worker = workerRecord(runId, name);
+    if (!worker || worker.taskId !== taskId) continue;
+    if (!isPidAlive(worker.pid)) continue;
+    const status = computeWorkerStatus(worker);
+    if (status.status === "done") continue;
+    return true;
+  }
+  return false;
+}
+
 // src/supervisor.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync3 } from "node:fs";
-import path10 from "node:path";
+import path11 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.",
+    "Plan progress: when planId is set, use `kynver plan progress` for in_progress|running|partial|blocked. Use `in_progress` for agent-loop current focus; use `running` only when an executor holds a lease. 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).",
+    "- Harness checkpoints only: `kynver plan progress --plan <planId> --row <rowKey> --role implementer --status in_progress|running|partial|blocked` (the by-id harness route rejects `done` and confirm events). Prefer `in_progress` at turn start for current focus; daemon sets `running` on dispatch.",
     "- 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>`.",
@@ -1465,13 +1619,17 @@ function buildPrompt(input) {
     `Progress heartbeat file: ${input.heartbeatPath}`,
     "After each major step, append one JSON line to the heartbeat file with fields: ts, phase, summary, changedFiles, blocker.",
     "Final response must include files changed, verification commands, and unresolved risks.",
-    "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, commit or open a PR; exiting with only dirty files and no final result routes to salvage review, not production review.",
-    "Long-running commands: prefer bounded verification (targeted tests/typecheck for touched paths). If a full build is required, note it in heartbeat phase `verify` so a silent exit is not mistaken for success.",
+    "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). 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.",
+    "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.",
+    "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.",
     "",
     ...progressLines,
     "",
     ...planArtifactLines,
     "",
+    ...input.personaMarkdown?.trim() ? [input.personaMarkdown.trim(), ""] : [],
+    ...input.instructionPolicyMarkdown?.trim() ? ["Operating rules (Lane A \u2014 from AgentOS memory policy):", input.instructionPolicyMarkdown.trim(), ""] : [],
     "Task:",
     input.task
   ].join("\n");
@@ -1480,11 +1638,11 @@ function buildPrompt(input) {
 // src/providers/cursor.ts
 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";
+import path8 from "node:path";
 
 // src/providers/cursor-windows.ts
 import { existsSync as existsSync7, readdirSync as readdirSync3 } from "node:fs";
-import path6 from "node:path";
+import path7 from "node:path";
 var CURSOR_VERSION_DIR = /^\d{4}\.\d{1,2}\.\d{1,2}-[a-f0-9]+$/i;
 function parseCursorVersionSortKey(versionName) {
   const datePart = versionName.split("-")[0];
@@ -1495,7 +1653,7 @@ function parseCursorVersionSortKey(versionName) {
   return Number(`${year}${month.padStart(2, "0")}${day.padStart(2, "0")}`);
 }
 function pickLatestCursorVersionDir(agentRoot) {
-  const versionsRoot = path6.join(agentRoot, "versions");
+  const versionsRoot = path7.join(agentRoot, "versions");
   if (!existsSync7(versionsRoot)) return null;
   let bestDir = null;
   let bestKey = -1;
@@ -1504,21 +1662,21 @@ function pickLatestCursorVersionDir(agentRoot) {
     const key = parseCursorVersionSortKey(entry.name);
     if (key == null || key <= bestKey) continue;
     bestKey = key;
-    bestDir = path6.join(versionsRoot, entry.name);
+    bestDir = path7.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");
+  const root = agentRoot?.trim() || path7.join(process.env.LOCALAPPDATA || "", "cursor-agent");
+  const directNode = path7.join(root, "node.exe");
+  const directIndex = path7.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");
+  const nodeExe = path7.join(versionDir, "node.exe");
+  const indexJs = path7.join(versionDir, "index.js");
   if (!existsSync7(nodeExe) || !existsSync7(indexJs)) return null;
   return { nodeExe, indexJs, versionDir };
 }
@@ -1537,13 +1695,13 @@ function bundledSpawnTarget(nodeExe, indexJs, versionDir) {
 function resolveCursorSpawn(agentBin) {
   if (process.platform === "win32") {
     const isCursorWrapper = /\.(cmd|bat)$/i.test(agentBin);
-    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync8(path7.join(path7.dirname(agentBin), "index.js"));
+    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync8(path8.join(path8.dirname(agentBin), "index.js"));
     const isDefaultShim = agentBin === "agent";
     if (isCursorWrapper || isBundledNode || isDefaultShim) {
-      const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path7.dirname(agentBin)) : isBundledNode ? {
+      const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path8.dirname(agentBin)) : isBundledNode ? {
         nodeExe: agentBin,
-        indexJs: path7.join(path7.dirname(agentBin), "index.js"),
-        versionDir: path7.dirname(agentBin)
+        indexJs: path8.join(path8.dirname(agentBin), "index.js"),
+        versionDir: path8.dirname(agentBin)
       } : resolveWindowsCursorBundled();
       if (bundled) {
         return bundledSpawnTarget(bundled.nodeExe, bundled.indexJs, bundled.versionDir);
@@ -1563,7 +1721,7 @@ function resolveAgentBin() {
       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");
+    const localAgent = path8.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
     if (existsSync8(localAgent)) return localAgent;
   }
   return "agent";
@@ -1573,7 +1731,7 @@ function cursorWorkerEnv(agentBin, spawnTarget) {
     ...process.env,
     CI: "1",
     NO_COLOR: "1",
-    ...spawnTarget.bundledVersionDir ? { CURSOR_INVOKED_AS: path7.basename(agentBin) || "agent.cmd" } : {}
+    ...spawnTarget.bundledVersionDir ? { CURSOR_INVOKED_AS: path8.basename(agentBin) || "agent.cmd" } : {}
   };
 }
 var cursorProvider = {
@@ -1647,11 +1805,360 @@ function resolveWorkerProvider(name) {
 // src/auto-complete.ts
 import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync9, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/worker-ops.ts
-import path8 from "node:path";
+import path9 from "node:path";
+
+// src/pr-handoff/pr-handoff-assess.ts
+var REVIEW_LANE_RULE = /^(lane:)?(review|deep_review|planning|landing)(:|$)/i;
+function trimOrNull3(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+function committedHead(ancestry) {
+  if (!ancestry?.checked) return null;
+  if (ancestry.headIsAncestorOfBase !== false) return null;
+  return trimOrNull3(ancestry.head);
+}
+function extractPrUrlFromText(value) {
+  if (value === void 0 || value === null) return null;
+  const text = typeof value === "string" ? value : typeof value === "object" && value !== null && "summary" in value ? String(value.summary ?? "") : JSON.stringify(value);
+  const m = text.match(
+    /https?:\/\/[^\s)>"]+\/(?:pull|pulls|merge_requests|pull-requests)\/\d+/i
+  );
+  return m ? trimOrNull3(m[0]) : null;
+}
+function hasWorkProduct(snapshot) {
+  if (snapshot.changedFiles.length > 0) return true;
+  if (trimOrNull3(snapshot.headCommit)) return true;
+  if (committedHead(snapshot.gitAncestry)) return true;
+  return false;
+}
+function assessPrHandoffRequirement(input) {
+  if (!input.dispatched) {
+    return { required: false, reason: "not_dispatched" };
+  }
+  const rule = trimOrNull3(input.routingRule) ?? "";
+  if (rule && REVIEW_LANE_RULE.test(rule)) {
+    return { required: false, reason: "review_lane" };
+  }
+  if (trimOrNull3(input.patchPath) || trimOrNull3(input.artifactBundlePath)) {
+    return { required: false, reason: "patch_or_bundle" };
+  }
+  const prUrl = trimOrNull3(input.prUrl) ?? trimOrNull3(input.snapshot.prUrl);
+  if (prUrl) {
+    return { required: false, reason: "already_has_pr" };
+  }
+  if (!hasWorkProduct(input.snapshot)) {
+    return { required: false, reason: "no_work_product" };
+  }
+  return { required: true, snapshot: input.snapshot };
+}
+function buildPrHandoffSnapshotFromStatus(status, extras) {
+  return {
+    changedFiles: status.changedFiles,
+    branch: status.branch,
+    worktreePath: status.worktreePath,
+    gitAncestry: status.gitAncestry,
+    finalResult: status.finalResult,
+    headCommit: trimOrNull3(extras?.headCommit) ?? committedHead(status.gitAncestry),
+    prUrl: trimOrNull3(extras?.prUrl) ?? null
+  };
+}
+
+// src/pr-handoff/pr-handoff-gh.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+function capture(bin, cwd, args) {
+  try {
+    const res = spawnSync2(bin, args, { cwd, encoding: "utf8" });
+    return {
+      status: res.status,
+      stdout: (res.stdout || "").trim(),
+      stderr: (res.stderr || "").trim(),
+      error: res.error ? res.error.message : null
+    };
+  } catch (error) {
+    return {
+      status: null,
+      stdout: "",
+      stderr: "",
+      error: error.message
+    };
+  }
+}
+var defaultPrHandoffExec = {
+  git: (cwd, args) => gitCapture(cwd, args),
+  gh: (cwd, args) => capture("gh", cwd, args)
+};
+function parseGithubRepo(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  const ssh = trimmed.match(/git@github\.com:([^/]+\/[^/.]+)(?:\.git)?/i);
+  if (ssh) return ssh[1];
+  const https = trimmed.match(/github\.com[/:]([^/]+\/[^/.]+?)(?:\.git)?/i);
+  if (https) return https[1];
+  return null;
+}
+function firstLine(text) {
+  return text.split("\n").map((l) => l.trim()).find(Boolean) ?? "";
+}
+function resolveGithubRepo(worktreePath, exec) {
+  const remote = exec.git(worktreePath, ["remote", "get-url", "origin"]);
+  if (remote.status !== 0) return null;
+  return parseGithubRepo(remote.stdout);
+}
+function resolveHeadCommit(worktreePath, exec) {
+  const head = exec.git(worktreePath, ["rev-parse", "HEAD"]);
+  if (head.status !== 0) return null;
+  return head.stdout.trim() || null;
+}
+function findOpenPrUrl(worktreePath, repo, branch, exec) {
+  const listed = exec.gh(worktreePath, [
+    "pr",
+    "list",
+    "--repo",
+    repo,
+    "--head",
+    branch,
+    "--state",
+    "open",
+    "--json",
+    "url",
+    "--limit",
+    "1"
+  ]);
+  if (listed.status !== 0) return null;
+  try {
+    const rows = JSON.parse(listed.stdout);
+    const url = rows[0]?.url?.trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+function commitAndPushBranch(input) {
+  const { worktreePath, branch, commitMessage, hasDirtyFiles, exec } = input;
+  if (hasDirtyFiles) {
+    const add = exec.git(worktreePath, ["add", "-A"]);
+    if (add.status !== 0) {
+      return {
+        ok: false,
+        committed: false,
+        pushed: false,
+        detail: add.stderr || add.stdout || add.error || "git add failed"
+      };
+    }
+    const commit = exec.git(worktreePath, ["commit", "-m", commitMessage]);
+    if (commit.status !== 0) {
+      return {
+        ok: false,
+        committed: false,
+        pushed: false,
+        detail: commit.stderr || commit.stdout || commit.error || "git commit failed"
+      };
+    }
+  }
+  const push = exec.git(worktreePath, ["push", "-u", "origin", branch]);
+  if (push.status !== 0) {
+    return {
+      ok: false,
+      committed: hasDirtyFiles,
+      pushed: false,
+      detail: push.stderr || push.stdout || push.error || "git push failed"
+    };
+  }
+  const headCommit = resolveHeadCommit(worktreePath, exec) ?? void 0;
+  return {
+    ok: true,
+    committed: hasDirtyFiles,
+    pushed: true,
+    headCommit
+  };
+}
+function createGithubPr(input) {
+  const existing = findOpenPrUrl(input.worktreePath, input.repo, input.branch, input.exec);
+  if (existing) {
+    return { ok: true, prUrl: existing, created: false };
+  }
+  const created = input.exec.gh(input.worktreePath, [
+    "pr",
+    "create",
+    "--repo",
+    input.repo,
+    "--base",
+    input.base,
+    "--head",
+    input.branch,
+    "--title",
+    input.title,
+    "--body",
+    input.body,
+    "--draft"
+  ]);
+  if (created.status !== 0) {
+    return {
+      ok: false,
+      detail: created.stderr || created.stdout || created.error || "gh pr create failed"
+    };
+  }
+  const url = extractPrUrlFromGhOutput(created.stdout) ?? findOpenPrUrl(input.worktreePath, input.repo, input.branch, input.exec);
+  if (!url) {
+    return { ok: false, detail: "gh pr create succeeded but no PR URL was parsed" };
+  }
+  return { ok: true, prUrl: url, created: true };
+}
+function extractPrUrlFromGhOutput(stdout) {
+  const line = firstLine(stdout);
+  const m = line.match(/https?:\/\/[^\s]+\/pull\/\d+/i);
+  return m ? m[0] : null;
+}
+
+// src/pr-handoff/pr-handoff.ts
+function ghAvailable(exec) {
+  const probe = exec.gh(process.cwd(), ["--version"]);
+  return probe.status === 0;
+}
+function defaultPrTitle(workerName, runId) {
+  return `AgentOS harness: ${workerName} (${runId})`;
+}
+function defaultPrBody(taskId, workerName, runId) {
+  return [
+    "Automated PR-ready handoff from the Kynver harness runtime.",
+    "",
+    taskId ? `AgentOS task: \`${taskId}\`` : "",
+    `Harness worker: \`${workerName}\` \xB7 run \`${runId}\``,
+    "",
+    "Opened by orchestrator completion enforcement so production review receives a reviewable artifact."
+  ].filter(Boolean).join("\n");
+}
+function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
+  const prUrlHint = input.prUrlHint ?? extractPrUrlFromText(input.status.finalResult) ?? null;
+  const snapshot = buildPrHandoffSnapshotFromStatus(input.status, {
+    prUrl: prUrlHint,
+    headCommit: null
+  });
+  const requirement = assessPrHandoffRequirement({
+    dispatched: input.worker.dispatched,
+    routingRule: input.worker.routingRule,
+    prUrl: prUrlHint,
+    snapshot
+  });
+  if (!requirement.required) {
+    return { ok: true, prUrl: prUrlHint ?? void 0 };
+  }
+  if (prUrlHint) {
+    return { ok: true, prUrl: prUrlHint };
+  }
+  if (!ghAvailable(exec)) {
+    const dirty = snapshot.changedFiles.length;
+    const detail = dirty ? `${dirty} uncommitted change(s) with no PR URL` : "committed branch with no PR URL";
+    return {
+      ok: false,
+      reason: `PR-ready handoff blocked: ${detail}`,
+      nextAction: "Install and authenticate GitHub CLI (`gh auth login`), then commit, push, and run `gh pr create` (or rerun `kynver worker complete` after the PR exists)."
+    };
+  }
+  const repo = resolveGithubRepo(snapshot.worktreePath, exec);
+  if (!repo) {
+    return {
+      ok: false,
+      reason: "PR-ready handoff blocked: could not resolve github.com origin for the worktree",
+      nextAction: "Ensure `origin` points at GitHub, push the branch, open a PR, and rerun `kynver worker complete`."
+    };
+  }
+  const existing = findOpenPrUrl(snapshot.worktreePath, repo, snapshot.branch, exec);
+  if (existing) {
+    return {
+      ok: true,
+      prUrl: existing,
+      headCommit: snapshot.headCommit ?? resolveHeadCommit(snapshot.worktreePath, exec) ?? void 0
+    };
+  }
+  const hasDirty = snapshot.changedFiles.length > 0;
+  let committed = false;
+  let pushed = false;
+  let headCommit = snapshot.headCommit ?? void 0;
+  const pushResult = commitAndPushBranch({
+    worktreePath: snapshot.worktreePath,
+    branch: snapshot.branch,
+    commitMessage: `chore(harness): PR-ready handoff for ${input.worker.name}`,
+    hasDirtyFiles: hasDirty,
+    exec
+  });
+  if (hasDirty && !pushResult.ok) {
+    return {
+      ok: false,
+      reason: `PR-ready handoff blocked: ${pushResult.detail ?? "git commit/push failed"}`,
+      nextAction: "Commit and push the branch, run `gh pr create`, then rerun `kynver worker complete`."
+    };
+  }
+  if (!hasDirty) {
+    const pushOnly = exec.git(snapshot.worktreePath, ["push", "-u", "origin", snapshot.branch]);
+    if (pushOnly.status !== 0 && !/already up to date/i.test(pushOnly.stderr || pushOnly.stdout)) {
+      return {
+        ok: false,
+        reason: `PR-ready handoff blocked: ${pushOnly.stderr || pushOnly.stdout || pushOnly.error || "git push failed"}`,
+        nextAction: "Push the branch to origin, run `gh pr create`, then rerun `kynver worker complete`."
+      };
+    }
+    pushed = pushOnly.status === 0;
+  } else {
+    committed = pushResult.committed;
+    pushed = pushResult.pushed;
+    if (!pushResult.ok) {
+      return {
+        ok: false,
+        reason: `PR-ready handoff blocked: ${pushResult.detail ?? "git push failed"}`,
+        nextAction: "Fix git auth or merge conflicts, push the branch, run `gh pr create`, then rerun `kynver worker complete`."
+      };
+    }
+  }
+  headCommit = pushResult.headCommit ?? headCommit ?? resolveHeadCommit(snapshot.worktreePath, exec) ?? void 0;
+  const base = input.run.base?.trim() || "main";
+  const pr = createGithubPr({
+    worktreePath: snapshot.worktreePath,
+    repo,
+    branch: snapshot.branch,
+    base: base.replace(/^origin\//, ""),
+    title: defaultPrTitle(input.worker.name, input.worker.runId),
+    body: defaultPrBody(input.worker.taskId, input.worker.name, input.worker.runId),
+    exec
+  });
+  if (!pr.ok || !pr.prUrl) {
+    const dirty = snapshot.changedFiles.length;
+    const detail = dirty ? `${dirty} uncommitted change(s) and no PR URL after handoff attempt` : "no PR URL after handoff attempt";
+    return {
+      ok: false,
+      reason: `PR-ready handoff blocked: ${detail}${pr.detail ? ` (${pr.detail})` : ""}`,
+      nextAction: "Run `gh pr create` on the worker branch (or fix `gh` auth), attach the PR URL to the task, then rerun `kynver worker complete`."
+    };
+  }
+  return {
+    ok: true,
+    prUrl: pr.prUrl,
+    headCommit: headCommit ?? void 0,
+    committed,
+    pushed,
+    created: pr.created
+  };
+}
+
+// src/completion-ack.ts
+function hasCompletionAck(worker) {
+  return Boolean(worker.completionReportedAt?.trim());
+}
+function persistCompletionAck(worker, runId, fields) {
+  worker.completionReportedAt = fields.completionReportedAt;
+  worker.completionOutcome = fields.completionOutcome;
+  if (fields.completionResponse !== void 0) {
+    worker.completionResponse = fields.completionResponse;
+  }
+  saveWorker(runId, worker);
+}
+
+// src/worker-ops.ts
 async function postCompletion(url, secret, body) {
   const res = await fetch(url, {
     method: "POST",
@@ -1673,6 +2180,42 @@ function completionErrorText(parsed) {
   }
   return void 0;
 }
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+function deriveLifecycleStage(input) {
+  if (input.completionBlocker) return `blocked:${input.completionBlocker}`;
+  if (input.completionOutcome) return input.completionOutcome;
+  if (input.completionReportedAt) return "completion_acknowledged";
+  if (input.finished) return "worker_finished";
+  return "in_progress";
+}
+function deriveNextAction(input) {
+  if (input.completionBlocker) {
+    return "Resolve completion blocker, then rerun `kynver worker complete`.";
+  }
+  if (input.completionOutcome === "review_scheduled" || input.completionOutcome === "review_already_scheduled") {
+    return "Await review lane and landing decision in Command Center.";
+  }
+  if (input.completionOutcome === "needs_attention") {
+    return "Inspect blocker/attention reason in Command Center and dispatch a repair task.";
+  }
+  if (input.finished && !input.completionReportedAt) {
+    return "Post completion acknowledgement to AgentOS (`kynver worker complete`).";
+  }
+  return null;
+}
+function deriveHandoffState(input) {
+  if (input.prUrl) return "pr_handoff";
+  if (input.headCommit) return "commit_handoff";
+  if (input.changedFiles.length > 0) return "dirty_worktree";
+  return "none";
+}
 function persistCompletionBlocker(worker, reason) {
   const current = worker.completionBlocker;
   if ((current ?? void 0) === (reason ?? void 0)) return;
@@ -1683,10 +2226,17 @@ function persistCompletionBlocker(worker, reason) {
 function workerStatusOptions(run) {
   return run ? { base: run.base, baseCommit: run.baseCommit } : {};
 }
+function applyPrHandoffToStatus(status, handoff) {
+  return {
+    ...status,
+    ...handoff.prUrl ? { prUrl: handoff.prUrl } : {},
+    ...handoff.headCommit ? { headCommit: handoff.headCommit } : {}
+  };
+}
 async function tryCompleteWorker(args) {
   const worker = loadWorker(String(args.run), String(args.name));
   const run = loadRun(worker.runId);
-  const status = computeWorkerStatus(worker, workerStatusOptions(run));
+  let 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) {
@@ -1695,6 +2245,34 @@ async function tryCompleteWorker(args) {
   if (!isFinishedWorkerStatus(status)) {
     return { ok: true, skipped: true, reason: "worker-not-finished" };
   }
+  const forceReplay = args.force === true || args.force === "true";
+  if (!forceReplay && hasCompletionAck(worker)) {
+    return {
+      ok: true,
+      skipped: true,
+      reason: "completion-already-acknowledged",
+      httpStatus: 200
+    };
+  }
+  if (worker.localOnly) {
+    return { ok: true, skipped: true, reason: "local-only-worker" };
+  }
+  const skipPrHandoff = args.skipPrHandoff === true || args.skipPrHandoff === "true";
+  if (!skipPrHandoff && worker.dispatched && taskId) {
+    const handoff = ensurePrReadyHandoff({ worker, run, status });
+    if (!handoff.ok) {
+      persistCompletionBlocker(worker, handoff.reason);
+      return {
+        ok: false,
+        reason: handoff.reason,
+        nextAction: handoff.nextAction,
+        completionBlocked: true
+      };
+    }
+    if (handoff.prUrl || handoff.headCommit) {
+      status = applyPrHandoffToStatus(status, handoff);
+    }
+  }
   const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
   const explicitSecret = args.secret ? String(args.secret) : void 0;
   let secret = await resolveCallbackSecretWithMint(explicitSecret, agentOsId, { baseUrl: base });
@@ -1707,7 +2285,13 @@ async function tryCompleteWorker(args) {
     taskId,
     startedAt: worker.startedAt,
     finishedAt: status.lastActivityAt || (/* @__PURE__ */ new Date()).toISOString(),
-    status
+    status,
+    workerInjection: {
+      instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
+      instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null,
+      personaSlug: worker.personaSlug ?? null,
+      personaEvidence: worker.personaEvidence ?? null
+    }
   };
   let result = await postCompletion(url, secret, body);
   if ((result.status === 401 || result.status === 403) && !explicitSecret) {
@@ -1719,7 +2303,19 @@ async function tryCompleteWorker(args) {
   }
   if (result.ok) {
     persistCompletionBlocker(worker, void 0);
-    return { ok: true, httpStatus: result.status, response: result.parsed };
+    const ack = {
+      completionReportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      completionOutcome: "acknowledged",
+      completionResponse: result.parsed
+    };
+    persistCompletionAck(worker, worker.runId, ack);
+    const prUrl = status.prUrl;
+    return {
+      ok: true,
+      httpStatus: result.status,
+      response: result.parsed,
+      ...prUrl ? { prHandoff: { prUrl } } : {}
+    };
   }
   const authRejected = result.status === 401 || result.status === 403;
   const detail = completionErrorText(result.parsed) ?? (authRejected ? "runner token unauthorized" : "non-2xx response");
@@ -1780,7 +2376,7 @@ function workerStatus(args) {
   const worker = loadWorker(String(args.run), String(args.name));
   const run = loadRun(worker.runId);
   const status = computeWorkerStatus(worker, workerStatusOptions(run));
-  writeJson(path8.join(worker.workerDir, "last-status.json"), status);
+  writeJson(path9.join(worker.workerDir, "last-status.json"), status);
   console.log(JSON.stringify(status, null, 2));
 }
 function buildRunBoard(runId) {
@@ -1788,7 +2384,7 @@ function buildRunBoard(runId) {
   const names = Object.keys(run.workers || {});
   const workers = names.map((name) => {
     const worker = readJson(
-      path8.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path9.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) {
@@ -1810,6 +2406,29 @@ function buildRunBoard(runId) {
     const completionBlocker = typeof rawBlocker === "string" && rawBlocker ? rawBlocker : void 0;
     const boardStatus = completionBlocker ? "blocked" : status.status;
     const boardAttention = completionBlocker ? "blocked" : status.attention.state;
+    const completionResponse = asRecord(worker.completionResponse);
+    const completionTask = asRecord(completionResponse?.task);
+    const completionOutcome = asString(completionResponse?.outcome);
+    const completionRouteStatus = asString(completionResponse?.status);
+    const completionWarnings = Array.isArray(completionResponse?.warnings) ? completionResponse.warnings.filter((w) => typeof w === "string" && w.trim().length > 0) : [];
+    const prUrl = asString(completionTask?.prUrl) ?? asString(completionResponse?.prUrl);
+    const lifecycleStage = deriveLifecycleStage({
+      finished: isFinishedWorkerStatus(status),
+      completionBlocker,
+      completionOutcome,
+      completionReportedAt: worker.completionReportedAt ?? null
+    });
+    const nextAction = deriveNextAction({
+      completionBlocker,
+      completionOutcome,
+      completionReportedAt: worker.completionReportedAt ?? null,
+      finished: isFinishedWorkerStatus(status)
+    });
+    const handoffState = deriveHandoffState({
+      changedFiles: status.changedFiles,
+      headCommit,
+      prUrl: prUrl ?? void 0
+    });
     return {
       worker: status.worker,
       status: boardStatus,
@@ -1829,12 +2448,39 @@ function buildRunBoard(runId) {
       changedFileCount: status.changedFiles.length,
       changedFiles: status.changedFiles,
       branch: status.branch,
+      taskId: worker.taskId ?? null,
+      planId: worker.planId ?? null,
+      instructionPolicyFingerprint: typeof worker.instructionPolicyFingerprint === "string" ? worker.instructionPolicyFingerprint : null,
+      instructionPolicyRuleCount: (() => {
+        const raw = worker.instructionPolicyEvidence;
+        if (!raw || typeof raw !== "object") return null;
+        const slugs = raw.ruleSlugs;
+        return Array.isArray(slugs) ? slugs.length : null;
+      })(),
+      leaseOwner: worker.leaseOwner ?? null,
       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,
+      prUrl,
+      handoffState,
       gitAncestry: status.gitAncestry,
       finalResult: status.finalResult,
+      lifecycleStage,
+      completionReportedAt: worker.completionReportedAt ?? null,
+      completionOutcome: worker.completionOutcome ?? null,
+      completionRouteStatus,
+      completionRouteOutcome: completionOutcome,
+      completionWarnings,
+      completionBlocker: completionBlocker ?? null,
+      checkpoint: {
+        phase: status.lastHeartbeatPhase,
+        summary: status.lastHeartbeatSummary,
+        blocker: status.heartbeatBlocker
+      },
+      lastCommandHint: status.currentTool ?? status.lastHeartbeatSummary,
+      failureReason: completionBlocker ?? status.error ?? null,
+      nextAction,
       ancestry: status.gitAncestry.relation,
       ancestryChecked: status.gitAncestry.checked
     };
@@ -1848,7 +2494,7 @@ function buildRunBoard(runId) {
     needsAttention: workers.filter((w) => w.attention && w.attention !== "ok" && w.attention !== "done").map((w) => w.worker),
     workers
   };
-  writeJson(path8.join(runDirectory(run.id), "last-board.json"), board);
+  writeJson(path9.join(runDirectory(run.id), "last-board.json"), board);
   return board;
 }
 async function publishHarnessBoardSnapshot(args, source) {
@@ -2015,12 +2661,12 @@ async function autoCompleteWorkerCli(raw) {
   }
 }
 function resolveDefaultCliPath() {
-  return path9.join(fileURLToPath(new URL(".", import.meta.url)), "cli.js");
+  return path10.join(fileURLToPath(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnCompletionSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath();
   if (!existsSync9(cliPath)) return void 0;
-  const logPath = path9.join(opts.workerDir, "auto-complete.log");
+  const logPath = path10.join(opts.workerDir, "auto-complete.log");
   let logFd;
   try {
     logFd = openSync3(logPath, "a");
@@ -2102,16 +2748,16 @@ function spawnWorkerProcess(run, opts) {
     launchModel = preflight.model;
   }
   const { worktreesDir } = getPaths();
-  const workerDir = path10.join(runDirectory(run.id), "workers", name);
+  const workerDir = path11.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
-  const worktreePath = path10.join(worktreesDir, run.id, name);
+  const worktreePath = path11.join(worktreesDir, run.id, name);
   const branch = opts.branch || `agent/${run.id}/${name}`;
   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 = path10.join(workerDir, "stdout.jsonl");
-  const stderrPath = path10.join(workerDir, "stderr.log");
-  const heartbeatPath = path10.join(workerDir, "heartbeat.jsonl");
+  const stdoutPath = path11.join(workerDir, "stdout.jsonl");
+  const stderrPath = path11.join(workerDir, "stderr.log");
+  const heartbeatPath = path11.join(workerDir, "heartbeat.jsonl");
   const prompt = buildPrompt({
     task: opts.task,
     ownedPaths: opts.ownedPaths || [],
@@ -2119,6 +2765,8 @@ function spawnWorkerProcess(run, opts) {
     heartbeatPath,
     planId: opts.planId,
     taskId: opts.taskId,
+    instructionPolicyMarkdown: opts.instructionPolicyMarkdown,
+    personaMarkdown: opts.personaMarkdown,
     model: launchModel
   });
   let started;
@@ -2158,14 +2806,19 @@ function spawnWorkerProcess(run, opts) {
     ...opts.agentOsId ? { agentOsId: String(opts.agentOsId) } : {},
     ...opts.taskId ? { taskId: String(opts.taskId) } : {},
     ...opts.planId ? { planId: String(opts.planId) } : {},
+    ...opts.instructionPolicyFingerprint ? { instructionPolicyFingerprint: String(opts.instructionPolicyFingerprint) } : {},
+    ...opts.instructionPolicyEvidence ? { instructionPolicyEvidence: opts.instructionPolicyEvidence } : {},
+    ...opts.personaSlug ? { personaSlug: String(opts.personaSlug) } : {},
+    ...opts.personaEvidence ? { personaEvidence: opts.personaEvidence } : {},
     ...opts.leaseOwner ? { leaseOwner: String(opts.leaseOwner) } : {},
     ...opts.dispatched ? { dispatched: true } : {},
+    ...!opts.agentOsId || !opts.taskId ? { localOnly: 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: path10.join(workerDir, "worker.json") } };
+  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path11.join(workerDir, "worker.json") } };
   run.status = "running";
   saveRun(run);
   if (worker.agentOsId && worker.taskId) {
@@ -2185,6 +2838,10 @@ function spawnWorkerProcess(run, opts) {
     if (!sidecarSpawned) {
       const reason = "completion sidecar failed to spawn (CLI not found or spawn error)";
       worker.completionBlocker = reason;
+      worker.completionSidecarSpawnFailedAt = (/* @__PURE__ */ new Date()).toISOString();
+      saveWorker(run.id, worker);
+    } else if (sidecarSpawned.pid) {
+      worker.completionSidecarPid = sidecarSpawned.pid;
       saveWorker(run.id, worker);
     }
   }
@@ -2202,6 +2859,14 @@ async function startWorker(args) {
     console.error("missing --task or --task-file");
     process.exit(1);
   }
+  const boardLinked = Boolean(args.agentOsId && args.taskId);
+  const explicitLocalOnly = args.localOnly === true || args.localOnly === "true";
+  if (!boardLinked && !explicitLocalOnly && (args.agentOsId || args.taskId)) {
+    console.error(
+      "worker start: board-linked workers require both --agent-os-id and --task-id (or pass --local-only for direct runs)"
+    );
+    process.exit(1);
+  }
   const wait = args.wait === true || args.wait === "true";
   let worker;
   try {
@@ -2249,6 +2914,32 @@ async function startWorker(args) {
 
 // src/dispatch.ts
 var DEFAULT_DISPATCH_LEASE_MS = 60 * 60 * 1e3;
+function readHarnessWorkerContext(decision) {
+  const raw = decision.harnessWorkerContext;
+  if (!raw || typeof raw !== "object") return null;
+  const ctx = raw;
+  const markdown = typeof ctx.instructionPolicyMarkdown === "string" ? ctx.instructionPolicyMarkdown : null;
+  const fingerprint = typeof ctx.instructionPolicyFingerprint === "string" ? ctx.instructionPolicyFingerprint : null;
+  const evidence = ctx.instructionPolicyEvidence && typeof ctx.instructionPolicyEvidence === "object" ? ctx.instructionPolicyEvidence : null;
+  const personaMarkdown = typeof ctx.personaMarkdown === "string" ? ctx.personaMarkdown : null;
+  const personaSlug = typeof ctx.personaEvidence === "object" && ctx.personaEvidence && typeof ctx.personaEvidence.injectedPersonaSlug === "string" ? ctx.personaEvidence.injectedPersonaSlug : null;
+  const personaEvidence = ctx.personaEvidence && typeof ctx.personaEvidence === "object" ? ctx.personaEvidence : null;
+  const personaInjectionReady = ctx.personaInjectionReady === true;
+  return {
+    instructionPolicyMarkdown: markdown,
+    instructionPolicyFingerprint: fingerprint,
+    instructionPolicyEvidence: evidence,
+    personaMarkdown,
+    personaSlug,
+    personaEvidence,
+    personaInjectionReady
+  };
+}
+function normalizePersonaSlug(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim().toLowerCase();
+  return trimmed.length ? trimmed : null;
+}
 function buildDispatchTaskText(task, agentOsId) {
   return [
     `[AgentOS task ${task.id}] ${task.title}`,
@@ -2273,6 +2964,20 @@ async function dispatchRun(args) {
     const runnerResourceGate = observeRunnerResourceGate({ runId: run.id });
     const requestedStarts = Number(args.maxStarts) > 0 ? Math.floor(Number(args.maxStarts)) : 1;
     const cappedStarts = dryRun ? requestedStarts : Math.min(requestedStarts, runnerResourceGate.slotsAvailable);
+    const activeHarnessWorkers = [];
+    for (const name of Object.keys(run.workers || {})) {
+      const worker = readJson(
+        path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        void 0
+      );
+      if (!worker?.taskId || !isPidAlive(worker.pid)) continue;
+      activeHarnessWorkers.push({
+        runId: run.id,
+        workerName: name,
+        taskId: worker.taskId,
+        pid: worker.pid
+      });
+    }
     const dispatchUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/dispatch-next`;
     const body = {
       agentOsId,
@@ -2282,6 +2987,8 @@ async function dispatchRun(args) {
       leaseDurationMs: Number(args.leaseMs) > 0 ? Math.floor(Number(args.leaseMs)) : DEFAULT_DISPATCH_LEASE_MS,
       runnerDiskGate,
       runnerResourceGate,
+      activeHarnessWorkers,
+      harnessBoardSnapshot: buildRunBoard(run.id),
       ...args.lane ? { lane: String(args.lane) } : {},
       executor: args.executor ? String(args.executor) : "harness",
       ...args.diskPath ? { diskPath: String(args.diskPath) } : {}
@@ -2341,6 +3048,25 @@ async function dispatchRun(args) {
     const outcomes = [];
     for (const decision of result.started) {
       const task = decision.task;
+      const harnessContext = readHarnessWorkerContext(decision);
+      const taskId = String(task.id);
+      const expectedPersona = normalizePersonaSlug(task.personaSlug);
+      if (expectedPersona && (!harnessContext?.personaInjectionReady || !harnessContext.personaMarkdown)) {
+        outcomes.push({
+          taskId,
+          started: false,
+          error: `persona_injection_required: missing anchored context-envelope persona block for "${expectedPersona}"`
+        });
+        continue;
+      }
+      if (hasLiveWorkerForTask(run.id, taskId)) {
+        outcomes.push({
+          taskId,
+          started: false,
+          error: "duplicate_dispatch_prevented: live local worker already owns this task"
+        });
+        continue;
+      }
       const attempt = Number(task.attempt) || 1;
       if (attempt > retryLimits.maxTaskAttempts) {
         outcomes.push({
@@ -2368,6 +3094,12 @@ async function dispatchRun(args) {
           agentOsId,
           taskId: String(task.id),
           planId,
+          instructionPolicyMarkdown: harnessContext?.instructionPolicyMarkdown ?? null,
+          instructionPolicyFingerprint: harnessContext?.instructionPolicyFingerprint ?? null,
+          instructionPolicyEvidence: harnessContext?.instructionPolicyEvidence ?? null,
+          personaMarkdown: harnessContext?.personaMarkdown ?? null,
+          personaSlug: harnessContext?.personaSlug ?? expectedPersona,
+          personaEvidence: harnessContext?.personaEvidence ?? null,
           leaseOwner,
           dispatched: true
         });
@@ -2379,8 +3111,22 @@ async function dispatchRun(args) {
           branch: worker.branch,
           model: worker.model,
           provider: routing.provider,
-          routingRule: routing.rule
+          routingRule: routing.rule,
+          instructionPolicyFingerprint: harnessContext?.instructionPolicyFingerprint ?? null,
+          instructionPolicyRuleCount: Array.isArray(harnessContext?.instructionPolicyEvidence?.ruleSlugs) ? harnessContext.instructionPolicyEvidence.ruleSlugs.length : null,
+          personaSlug: harnessContext?.personaSlug ?? expectedPersona,
+          personaOperatingRuleCount: harnessContext?.personaEvidence?.operatingRuleCount ?? null
         });
+        if (harnessContext?.instructionPolicyFingerprint) {
+          console.error(
+            `[dispatch] task ${taskId}: Lane A instruction policy injected fingerprint=${harnessContext.instructionPolicyFingerprint}`
+          );
+        }
+        if (harnessContext?.personaSlug) {
+          console.error(
+            `[dispatch] task ${taskId}: persona context injected slug=${harnessContext.personaSlug}`
+          );
+        }
       } catch (error) {
         const releaseUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(String(task.id))}/release`;
         let release;
@@ -2434,7 +3180,7 @@ function redactHarness(text, secret) {
 }
 
 // src/validate.ts
-import path11 from "node:path";
+import path13 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) {
@@ -2448,15 +3194,15 @@ function validateWorkerName(name) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path11.resolve(repo);
+  const resolved = path13.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 = path11.resolve(repoRoot, owned);
-    const rel = path11.relative(repoRoot, resolved);
-    if (rel.startsWith("..") || path11.isAbsolute(rel)) {
+    const resolved = path13.resolve(repoRoot, owned);
+    const rel = path13.relative(repoRoot, resolved);
+    if (rel.startsWith("..") || path13.isAbsolute(rel)) {
       throw new Error(`owned path escapes repo: ${owned}`);
     }
     return resolved;
@@ -2469,7 +3215,7 @@ function validateTailLines(lines) {
 
 // src/worktree.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync4 } from "node:fs";
-import path12 from "node:path";
+import path14 from "node:path";
 function createRun(args) {
   const repo = validateRepo(required(String(args.repo || ""), "--repo"));
   ensureGitRepo(repo);
@@ -2489,12 +3235,12 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path12.join(dir, "run.json"), run);
+  writeJson(path14.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(path12.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
+  const rows = listRunIds(runsDir).map((id) => readJson(path14.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
     id: run.id,
     name: run.name,
     status: run.status,
@@ -2509,7 +3255,7 @@ function failExists(message) {
 }
 
 // src/sweep.ts
-import path13 from "node:path";
+import path15 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -2522,7 +3268,7 @@ async function sweepRun(args) {
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path13.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path15.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
@@ -2569,13 +3315,13 @@ import { mkdirSync as mkdirSync5, realpathSync } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/pipeline-tick.ts
-import path22 from "node:path";
+import path24 from "node:path";
 
 // src/stale-reconcile.ts
-import path15 from "node:path";
+import path17 from "node:path";
 
 // src/finalize.ts
-import path14 from "node:path";
+import path16 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set(["running", "dispatching", "pending", "queued"]);
 function terminalStatusFor(run) {
   const names = Object.keys(run.workers || {});
@@ -2586,7 +3332,7 @@ function terminalStatusFor(run) {
   let anyLandingBlocked = false;
   for (const name of names) {
     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) continue;
@@ -2638,7 +3384,7 @@ function reconcileStaleWorkers() {
   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 workerPath = path17.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker || worker.status !== "running") {
         outcomes.push({
@@ -2651,7 +3397,21 @@ function reconcileStaleWorkers() {
       }
       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" });
+        if (worker.status === "running") {
+          const nextStatus = status.attention.state === "blocked" ? "blocked" : status.attention.state === "done" || status.status === "done" ? "done" : "exited";
+          worker.status = nextStatus;
+          worker.reconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+          worker.reconcileReason = "synced finished worker record after terminal stdout/heartbeat";
+          saveWorker(run.id, worker);
+          outcomes.push({
+            runId: run.id,
+            worker: name,
+            action: "marked_exited",
+            reason: worker.reconcileReason
+          });
+        } else {
+          outcomes.push({ runId: run.id, worker: name, action: "skipped", reason: "final result present" });
+        }
         continue;
       }
       if (!status.alive) {
@@ -2700,7 +3460,7 @@ function reconcileStaleWorkers() {
 }
 
 // src/plan-progress-daemon-sync.ts
-import path16 from "node:path";
+import path18 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -2724,7 +3484,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path16.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path18.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -2773,7 +3533,7 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 }
 
 // src/cleanup.ts
-import path21 from "node:path";
+import path23 from "node:path";
 
 // src/cleanup-types.ts
 var DEFAULT_NODE_MODULES_AGE_MS = 6 * 60 * 60 * 1e3;
@@ -2845,11 +3605,11 @@ function skipNodeModulesRemoval(input) {
 
 // src/cleanup-execute.ts
 import { existsSync as existsSync13, rmSync } from "node:fs";
-import path18 from "node:path";
+import path20 from "node:path";
 
 // src/cleanup-dir-size.ts
 import { existsSync as existsSync12, readdirSync as readdirSync4, statSync as statSync2 } from "node:fs";
-import path17 from "node:path";
+import path19 from "node:path";
 function directorySizeBytes(root, maxEntries = 5e4) {
   if (!existsSync12(root)) return 0;
   let total = 0;
@@ -2865,7 +3625,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path17.join(current, name);
+      const full = path19.join(current, name);
       let st;
       try {
         st = statSync2(full);
@@ -2949,20 +3709,20 @@ function removeWorktree(candidate, execute) {
   }
 }
 function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path18.resolve(targetPath);
-  const nm = resolved.endsWith(`${path18.sep}node_modules`) ? resolved : null;
+  const resolved = path20.resolve(targetPath);
+  const nm = resolved.endsWith(`${path20.sep}node_modules`) ? resolved : null;
   if (!nm) return "path_outside_harness";
-  const rel = path18.relative(worktreesDir, nm);
-  if (rel.startsWith("..") || path18.isAbsolute(rel)) return "path_outside_harness";
-  const parts = rel.split(path18.sep);
+  const rel = path20.relative(worktreesDir, nm);
+  if (rel.startsWith("..") || path20.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path20.sep);
   if (parts.length < 3 || parts[parts.length - 1] !== "node_modules") return "path_outside_harness";
-  if (!resolved.startsWith(path18.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path20.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 
 // src/cleanup-scan.ts
 import { existsSync as existsSync14, readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
-import path19 from "node:path";
+import path21 from "node:path";
 function pathAgeMs(target, now) {
   try {
     const mtime = statSync3(target).mtimeMs;
@@ -2972,17 +3732,17 @@ function pathAgeMs(target, now) {
   }
 }
 function isPathInside(child, parent) {
-  const rel = path19.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path19.isAbsolute(rel);
+  const rel = path21.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path21.isAbsolute(rel);
 }
 function scanNodeModulesCandidates(opts) {
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
     if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
-    const nm = path19.join(entry.worktreePath, "node_modules");
+    const nm = path21.join(entry.worktreePath, "node_modules");
     if (!existsSync14(nm)) continue;
-    const resolved = path19.resolve(nm);
+    const resolved = path21.resolve(nm);
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     candidates.push({
@@ -2998,13 +3758,13 @@ function scanNodeModulesCandidates(opts) {
   if (!opts.includeOrphans || !existsSync14(opts.worktreesDir)) return candidates;
   for (const runEntry of readdirSync5(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path19.join(opts.worktreesDir, runEntry.name);
+    const runPath = path21.join(opts.worktreesDir, runEntry.name);
     for (const workerEntry of readdirSync5(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path19.join(runPath, workerEntry.name);
-      const nm = path19.join(worktreePath, "node_modules");
+      const worktreePath = path21.join(runPath, workerEntry.name);
+      const nm = path21.join(worktreePath, "node_modules");
       if (!existsSync14(nm)) continue;
-      const resolved = path19.resolve(nm);
+      const resolved = path21.resolve(nm);
       if (seen.has(resolved)) continue;
       if (!isPathInside(resolved, opts.harnessRoot)) continue;
       seen.add(resolved);
@@ -3044,17 +3804,17 @@ function scanWorktreeCandidates(opts) {
 }
 
 // src/cleanup-worktree-index.ts
-import path20 from "node:path";
+import path22 from "node:path";
 function buildWorktreeIndex() {
   const index = /* @__PURE__ */ new Map();
   for (const run of listRunRecords()) {
     for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path20.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path22.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker?.worktreePath) continue;
       const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
-      index.set(path20.resolve(worker.worktreePath), {
-        worktreePath: path20.resolve(worker.worktreePath),
+      index.set(path22.resolve(worker.worktreePath), {
+        worktreePath: path22.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -3068,8 +3828,8 @@ function buildWorktreeIndex() {
 
 // src/cleanup.ts
 function resolveOptions(options = {}) {
-  const harnessRoot = options.harnessRoot ? path21.resolve(options.harnessRoot) : resolveHarnessRoot();
-  const { worktreesDir } = options.harnessRoot ? { worktreesDir: path21.join(harnessRoot, "worktrees") } : getHarnessPaths();
+  const harnessRoot = options.harnessRoot ? path23.resolve(options.harnessRoot) : resolveHarnessRoot();
+  const { worktreesDir } = options.harnessRoot ? { worktreesDir: path23.join(harnessRoot, "worktrees") } : getHarnessPaths();
   const execute = options.execute === true;
   const nodeModulesAgeMs = options.nodeModulesAgeMs ?? DEFAULT_NODE_MODULES_AGE_MS;
   const worktreesAgeMs = options.worktreesAgeMs ?? 0;
@@ -3113,7 +3873,7 @@ function runHarnessCleanup(options = {}) {
       actions.push({ ...candidate, executed: false, skipped: true, skipReason: pathSkip });
       continue;
     }
-    const worktreePath = path21.resolve(candidate.path, "..");
+    const worktreePath = path23.resolve(candidate.path, "..");
     const indexed = index.get(worktreePath) ?? null;
     const guardReason = skipNodeModulesRemoval({
       indexed,
@@ -3129,7 +3889,7 @@ function runHarnessCleanup(options = {}) {
     actions.push(removeNodeModules(candidate, resolved.execute));
   }
   for (const candidate of scanWorktreeCandidates(scanOpts)) {
-    const indexed = index.get(path21.resolve(candidate.path)) ?? null;
+    const indexed = index.get(path23.resolve(candidate.path)) ?? null;
     const guardReason = skipWorktreeRemoval({
       indexed,
       includeOrphans: resolved.includeOrphans,
@@ -3198,10 +3958,14 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path22.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path24.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
-    if (!worker?.taskId) continue;
+    if (!worker?.taskId || worker.localOnly) continue;
+    if (hasCompletionAck(worker)) {
+      outcomes.push({ worker: name, ok: true, taskId: worker.taskId ?? null, skipped: true });
+      continue;
+    }
     const status = computeWorkerStatus(worker);
     if (!isFinishedWorkerStatus(status)) continue;
     const exitedSalvage = assessExitedWorkerSalvage({
@@ -3245,6 +4009,7 @@ async function runPipelineTick(args) {
     configuredMaxWorkersOverride: workspacePrefs?.maxConcurrentWorkers
   });
   const operatorTick = await postOperatorTick(agentOsId, runId, resourceGate, args);
+  const leaseRenewal = await renewActiveTaskLeases(runId, args);
   const completedWorkers = await completeFinishedWorkers(runId, args);
   const staleReconcile = reconcileStaleWorkers();
   const harnessCleanup = isPipelineCleanupEnabled() ? runPipelineHarnessCleanup(runId) : void 0;
@@ -3281,6 +4046,7 @@ async function runPipelineTick(args) {
     agentOsId,
     execute,
     resourceGate,
+    leaseRenewal,
     completedWorkers,
     staleReconcile,
     harnessCleanup,
@@ -3524,6 +4290,7 @@ if (isCliEntry) {
 export {
   DEFAULT_DISPATCH_LEASE_MS,
   assessExitedWorkerSalvage,
+  assessPrHandoffRequirement,
   assessWorkerLanding,
   autoCompleteWorker,
   autoCompleteWorkerCli,
@@ -3535,17 +4302,23 @@ export {
   createRun,
   deriveRunStatus,
   dispatchRun,
+  ensurePrReadyHandoff,
+  extractPrUrlFromText,
   getHarnessPaths,
   isFinishedWorkerStatus,
   isLandingBlockedWorkerStatus,
+  isTerminalHeartbeatPhase,
   listRuns,
   loadUserConfig,
   main,
+  normalizeCursorModelAlias,
   observeRunnerDiskGate,
   parseArgs,
   parseClaudeStream,
+  parseHarnessStream,
   parseHeartbeat,
   postJson,
+  preflightCursorModel,
   redactHarness,
   resolveBaseUrl,
   resolveCallbackSecret,
@@ -3561,6 +4334,7 @@ export {
   summarizeEvent,
   sweepRun,
   tailWorker,
+  terminalFinalResultFromHeartbeat,
   usage,
   validateOwnedPaths,
   validateRepo,