@kynver-app/runtime 0.1.103 → 0.1.105

package/dist/cleanup-completion-blocker.d.ts

@@ -0,0 +1,10 @@
+import type { IndexedWorktree } from "./cleanup-worktree-index.js";
+import type { RawHarnessWorkerStatus } from "./status.js";
+/**
+ * Whether a persisted `completionBlocker` should still block whole-worktree removal.
+ *
+ * Dead workers with landed/clean work may keep replay metadata on disk after the
+ * board advanced externally — those blockers are stale for GC and must not pin
+ * worktrees indefinitely.
+ */
+export declare function completionBlockerBlocksWorktreeRemoval(indexed: IndexedWorktree, status?: RawHarnessWorkerStatus): boolean;

package/dist/cleanup-guards.d.ts

@@ -1,13 +1,8 @@
 import type { CleanupSkipReason, WorktreeRemovalGuardHook } from "./cleanup-types.js";
 import type { IndexedWorktree } from "./cleanup-worktree-index.js";
 import type { CleanupRunLivenessContext } from "./cleanup-run-liveness.js";
-import type { GitAncestry } from "./git.js";
-import type { RawHarnessWorkerStatus } from "./status.js";
 export { materialWorktreeChanges } from "./cleanup-guards-helpers.js";
-/** True when git ancestry shows the worker branch is fully landed on the run base. */
-export declare function isLandedGitAncestry(ancestry: GitAncestry | null | undefined): boolean;
-/** Blocks whole-worktree removal when commits are not landed or tree is dirty. */
-export declare function isPrOrUnmergedWork(status: RawHarnessWorkerStatus): boolean;
+export { isLandedGitAncestry, isPrOrUnmergedWork } from "./cleanup-worktree-salvage.js";
 export interface WorktreeGuardInput {
     indexed: IndexedWorktree | null;
     /** Resolved worktree directory (required for overlay guards on orphans). */

package/dist/cleanup-worktree-salvage.d.ts

@@ -0,0 +1,7 @@
+import type { GitAncestry } from "./git.js";
+import type { RawHarnessWorkerStatus } from "./status.js";
+export declare function prUrlFromFinalResult(finalResult: unknown): string | null;
+/** True when git ancestry shows the worker branch is fully landed on the run base. */
+export declare function isLandedGitAncestry(ancestry: GitAncestry | null | undefined): boolean;
+/** Blocks whole-worktree removal when commits are not landed or tree is dirty. */
+export declare function isPrOrUnmergedWork(status: RawHarnessWorkerStatus): boolean;

package/dist/cli.js

@@ -1783,7 +1783,7 @@ var NO_START_MS = 18e4;
 var STALE_MS = 6e5;
 function computeAttention(input) {
   const now = Date.now();
-  if (input.completionBlocker) {
+  if (input.completionBlocker && !isSkippedTerminalCompletionBlocker(input.completionBlocker)) {
     return { state: "blocked", reason: input.completionBlocker };
   }
   if (input.finalResult) {
@@ -1821,6 +1821,9 @@ function computeAttention(input) {
     return { state: "done", reason: "final result recorded" };
   }
   if (!input.alive) {
+    if (isAbandonedEmptyWorker(input)) {
+      return { state: "done", reason: "empty abandoned worker record" };
+    }
     const classified = classifyExitFailure(input.error);
     if (classified) return { state: "blocked", reason: classified.reason };
     const salvage = assessExitedWorkerSalvage({
@@ -1855,6 +1858,19 @@ function computeAttention(input) {
   }
   return { state: "ok", reason: "recent activity" };
 }
+function isSkippedTerminalCompletionBlocker(reason) {
+  const text = reason?.trim();
+  if (!text) return false;
+  return /completion acknowledged but board not advanced/i.test(text) && /task already terminal/i.test(text);
+}
+function isAbandonedEmptyWorker(input) {
+  if (input.finalResult) return false;
+  if (input.taskId || input.agentOsId) return false;
+  if (input.stdoutBytes > 0 || (input.stderrBytes ?? 0) > 0 || input.heartbeatBytes > 0) return false;
+  if (input.error?.trim()) return false;
+  if ((input.changedFiles ?? []).some((line) => line.trim())) return false;
+  return /empty worker dir|marked abandoned/i.test(input.reconcileReason ?? "");
+}
 function hasMergedTargetPrReconciliation(value) {
   let record = null;
   if (typeof value === "string") record = extractEmbeddedWorkerFinalResultRecord(value);
@@ -1899,6 +1915,7 @@ function computeWorkerStatus(worker, options = {}) {
   ]);
   const error = parsed.error || (!alive && !finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0);
   const completionBlocker = typeof worker.completionBlocker === "string" && worker.completionBlocker.trim() ? worker.completionBlocker.trim() : null;
+  const effectiveCompletionBlocker = isSkippedTerminalCompletionBlocker(completionBlocker) ? null : completionBlocker;
   const landingContract = worker.repairTargetPrUrl ? {
     landingOnly: false,
     targetPrUrls: [worker.repairTargetPrUrl],
@@ -1910,6 +1927,7 @@ function computeWorkerStatus(worker, options = {}) {
     finalResult,
     firstEventAt: parsed.firstEventAt,
     stdoutBytes,
+    stderrBytes,
     heartbeatBytes,
     lastActivityAt,
     heartbeatBlocker: heartbeat.heartbeatBlocker,
@@ -1917,12 +1935,15 @@ function computeWorkerStatus(worker, options = {}) {
     error,
     changedFiles,
     gitAncestry,
-    completionBlocker,
+    completionBlocker: effectiveCompletionBlocker,
     landingContract,
     prUrl: worker.repairTargetPrUrl ?? worker.taskPrUrl ?? null,
-    localOnly: worker.localOnly === true
+    localOnly: worker.localOnly === true,
+    taskId: worker.taskId ?? null,
+    agentOsId: worker.agentOsId ?? null,
+    reconcileReason: worker.reconcileReason ?? null
   });
-  const workerStatusLabel = completionBlocker || attention.state === "blocked" ? "blocked" : completionAcknowledged || attention.state === "done" ? "done" : finalResult ? "exited" : alive ? "running" : "exited";
+  const workerStatusLabel = effectiveCompletionBlocker || attention.state === "blocked" ? "blocked" : completionAcknowledged || attention.state === "done" ? "done" : finalResult ? "exited" : alive ? "running" : "exited";
   return {
     runId: worker.runId,
     worker: worker.name,
@@ -2839,6 +2860,9 @@ function enforceCursorWorkerProvider(input) {
   if (taskAllowsClaudeWorker(task)) {
     return routing;
   }
+  if (routing.rule === "explicit:cli" && isClaudeFamilyProvider(routing.provider)) {
+    return routing;
+  }
   if (!isClaudeFamilyProvider(routing.provider)) {
     return routing;
   }
@@ -3872,7 +3896,7 @@ function resolveWorkerLaunch(input) {
   if (!input.task || Object.keys(input.task).length === 0) {
     return afterCursorPolicy;
   }
-  if (afterCursorPolicy.rule === "explicit:model_provider_alias" || afterCursorPolicy.rule === "explicit:model_provider_alias_overrode_provider") {
+  if (afterCursorPolicy.rule === "explicit:model_provider_alias" || afterCursorPolicy.rule === "explicit:model_provider_alias_overrode_provider" || afterCursorPolicy.rule === "explicit:cli") {
     return afterCursorPolicy;
   }
   if (isClaudeFamilyProvider(afterCursorPolicy.provider) && (input.explicitProviderIsOperatorOverride || taskAllowsClaudeWorker(input.task))) {
@@ -4486,6 +4510,7 @@ function asString(value) {
 var ADVANCED_OUTCOMES = /* @__PURE__ */ new Set([
   "review_scheduled",
   "review_already_scheduled",
+  "skipped_terminal_task",
   "closed",
   "dispatched",
   "dispatch_already_done"
@@ -4833,6 +4858,36 @@ function defaultPrBody(taskId, workerName, runId) {
     "Opened by orchestrator completion enforcement so production review receives a reviewable artifact."
   ].filter(Boolean).join("\n");
 }
+function commitDirtyToExistingPr(input) {
+  if (input.snapshot.changedFiles.length === 0) {
+    return {
+      ok: true,
+      prUrl: input.prUrl,
+      headCommit: input.snapshot.headCommit ?? resolveHeadCommit(input.snapshot.worktreePath, input.exec) ?? void 0
+    };
+  }
+  const pushResult = commitAndPushBranch({
+    worktreePath: input.snapshot.worktreePath,
+    branch: input.snapshot.branch,
+    commitMessage: input.commitMessage,
+    hasDirtyFiles: true,
+    exec: input.exec
+  });
+  if (!pushResult.ok) {
+    return {
+      ok: false,
+      reason: `PR-ready handoff blocked: ${pushResult.detail ?? "git commit/push failed"}`,
+      nextAction: "Commit and push the dirty worker changes to the existing PR branch, then rerun `kynver worker complete`."
+    };
+  }
+  return {
+    ok: true,
+    prUrl: input.prUrl,
+    headCommit: pushResult.headCommit ?? input.snapshot.headCommit ?? void 0,
+    committed: pushResult.committed,
+    pushed: pushResult.pushed
+  };
+}
 function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
   const prUrlHint = input.prUrlHint ?? extractPrUrlFromText(input.status.finalResult) ?? null;
   const snapshot = buildPrHandoffSnapshotFromStatus(input.status, {
@@ -4856,10 +4911,23 @@ function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
     snapshot
   });
   if (!requirement.required) {
-    return { ok: true, prUrl: prUrlHint ?? void 0 };
+    if (prUrlHint) {
+      return commitDirtyToExistingPr({
+        snapshot,
+        prUrl: prUrlHint,
+        commitMessage: `chore(harness): update PR handoff for ${input.worker.name}`,
+        exec
+      });
+    }
+    return { ok: true };
   }
   if (prUrlHint) {
-    return { ok: true, prUrl: prUrlHint };
+    return commitDirtyToExistingPr({
+      snapshot,
+      prUrl: prUrlHint,
+      commitMessage: `chore(harness): update PR handoff for ${input.worker.name}`,
+      exec
+    });
   }
   if (!ghAvailable(exec)) {
     const dirty = snapshot.changedFiles.length;
@@ -4922,11 +4990,12 @@ function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
   }
   const existing = findOpenPrUrl(snapshot.worktreePath, repo, snapshot.branch, exec);
   if (existing) {
-    return {
-      ok: true,
+    return commitDirtyToExistingPr({
+      snapshot,
       prUrl: existing,
-      headCommit: snapshot.headCommit ?? resolveHeadCommit(snapshot.worktreePath, exec) ?? void 0
-    };
+      commitMessage: `chore(harness): update PR handoff for ${input.worker.name}`,
+      exec
+    });
   }
   const hasDirty = snapshot.changedFiles.length > 0;
   let committed = false;
@@ -5322,6 +5391,11 @@ function deriveNextAction(input) {
   }
   return null;
 }
+function isSkippedTerminalCompletionBlocker2(reason) {
+  const text = reason?.trim();
+  if (!text) return false;
+  return /completion acknowledged but board not advanced/i.test(text) && /task already terminal/i.test(text);
+}
 function deriveHandoffState(input) {
   if (input.prUrl) return "pr_handoff";
   if (input.headCommit) return "commit_handoff";
@@ -5378,6 +5452,23 @@ async function tryCompleteWorker(args) {
   if (!forceReplay && shouldReplayHarnessCompletion(worker)) {
     clearCompletionBlockerForReplay(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 = computeWorkerStatus(worker, workerStatusOptions(run));
+      status = applyPrHandoffToStatus(status, handoff);
+    }
+  }
   const headCommit = status.gitAncestry.headIsAncestorOfBase === false && status.gitAncestry.head ? status.gitAncestry.head : status.headCommit;
   if (worker.dispatched) {
     const handoff = assessWorktreeCompletionHandoff({
@@ -5398,22 +5489,6 @@ async function tryCompleteWorker(args) {
       };
     }
   }
-  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 });
@@ -5619,7 +5694,8 @@ function buildWorkerBoardEntry(input) {
     headCommit
   });
   const rawBlocker = worker.completionBlocker;
-  const completionBlocker = typeof rawBlocker === "string" && rawBlocker ? rawBlocker : void 0;
+  const rawCompletionBlocker = typeof rawBlocker === "string" && rawBlocker ? rawBlocker : void 0;
+  const completionBlocker = isSkippedTerminalCompletionBlocker2(rawCompletionBlocker) ? void 0 : rawCompletionBlocker;
   const boardStatus = completionBlocker ? "blocked" : status.status;
   const boardAttention = completionBlocker ? "blocked" : status.attention.state;
   const completionResponse = asRecord3(worker.completionResponse);
@@ -5704,7 +5780,8 @@ function buildWorkerBoardEntry(input) {
 }
 function isMetadataTerminalDone(worker) {
   const status = typeof worker.status === "string" ? worker.status : "";
-  const completionBlocker = typeof worker.completionBlocker === "string" && worker.completionBlocker.trim().length > 0;
+  const rawCompletionBlocker = typeof worker.completionBlocker === "string" && worker.completionBlocker.trim().length > 0 ? worker.completionBlocker : void 0;
+  const completionBlocker = rawCompletionBlocker && !isSkippedTerminalCompletionBlocker2(rawCompletionBlocker);
   if (completionBlocker) return false;
   if (typeof worker.completionReportedAt === "string" && worker.completionReportedAt.trim()) return true;
   if (worker.completionOutcome === "acknowledged") return true;
@@ -9364,30 +9441,7 @@ function indexedWorktreeHasMaterialChanges(entry) {
   return materialWorktreeChanges2(gitStatusShort(entry.worktreePath)).length > 0;
 }
 
-// src/cleanup-run-liveness.ts
-function deriveRunTerminal(indexed, ctx) {
-  if (ctx) return ctx.runTerminalCache.derive(indexed.run);
-  return deriveTerminalRunStatus(indexed.run);
-}
-function isWorkerProcessLive(indexed) {
-  if (isPidAlive(indexed.worker.pid)) return true;
-  if (!indexed.worker.pid) return indexedWorktreeStatus(indexed).alive;
-  return false;
-}
-function isRunStaleActive(indexed, ctx) {
-  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
-  return deriveRunTerminal(indexed, ctx) !== null;
-}
-function runBlocksWorktreeRemoval(indexed, ctx) {
-  if (isWorkerProcessLive(indexed)) return true;
-  if (indexed.worker.completionBlocker) return true;
-  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
-  if (isRunStaleActive(indexed, ctx)) return false;
-  if (!isFinishedWorkerStatus(indexedWorktreeStatus(indexed))) return true;
-  return deriveRunTerminal(indexed, ctx) === null;
-}
-
-// src/cleanup-guards.ts
+// src/cleanup-worktree-salvage.ts
 function prUrlFromFinalResult(finalResult) {
   if (typeof finalResult === "string") {
     const match = finalResult.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/i);
@@ -9412,12 +9466,63 @@ function isPrOrUnmergedWork(status) {
   if (status.changedFiles.length > 0 && status.finalResult) return true;
   return false;
 }
+
+// src/cleanup-completion-blocker.ts
+function completionBlockerBlocksWorktreeRemoval(indexed, status) {
+  const blocker = typeof indexed.worker.completionBlocker === "string" ? indexed.worker.completionBlocker.trim() : "";
+  if (!blocker) return false;
+  if (isWorkerProcessLive(indexed)) return true;
+  const resolved = status ?? indexedWorktreeStatus(indexed);
+  if (!isFinishedWorkerStatus(resolved)) return true;
+  if (isPrOrUnmergedWork(resolved)) return true;
+  if (materialWorktreeChanges2(resolved.changedFiles).length > 0) return true;
+  const landing = assessWorkerLanding({
+    finalResult: resolved.finalResult,
+    changedFiles: resolved.changedFiles,
+    gitAncestry: resolved.gitAncestry,
+    prUrl: prUrlFromFinalResult(resolved.finalResult)
+  });
+  if (landing.blocked) return true;
+  return false;
+}
+
+// src/cleanup-run-liveness.ts
+function deriveRunTerminal(indexed, ctx) {
+  if (ctx) return ctx.runTerminalCache.derive(indexed.run);
+  return deriveTerminalRunStatus(indexed.run);
+}
+function isWorkerProcessLive(indexed) {
+  if (isPidAlive(indexed.worker.pid)) return true;
+  if (!indexed.worker.pid) return indexedWorktreeStatus(indexed).alive;
+  return false;
+}
+function isRunStaleActive(indexed, ctx) {
+  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
+  return deriveRunTerminal(indexed, ctx) !== null;
+}
+function runBlocksWorktreeRemoval(indexed, ctx) {
+  if (isWorkerProcessLive(indexed)) return true;
+  const status = indexedWorktreeStatus(indexed);
+  if (completionBlockerBlocksWorktreeRemoval(indexed, status)) return true;
+  if (isFinishedWorkerStatus(status)) return false;
+  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
+  if (isRunStaleActive(indexed, ctx)) return false;
+  return deriveRunTerminal(indexed, ctx) === null;
+}
+
+// src/cleanup-guards.ts
 function effectiveWorktreeAgeMs(input) {
   const { indexed, includeOrphans, worktreesAgeMs, terminalWorktreesAgeMs } = input;
   if (!indexed) return includeOrphans ? terminalWorktreesAgeMs : worktreesAgeMs;
   if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) {
     return terminalWorktreesAgeMs;
   }
+  if (input.liveness && isRunStaleActive(indexed, input.liveness)) {
+    return terminalWorktreesAgeMs;
+  }
+  if (input.liveness && isFinishedWorkerStatus(indexedWorktreeStatus(indexed)) && !isWorkerProcessLive(indexed)) {
+    return terminalWorktreesAgeMs;
+  }
   return worktreesAgeMs;
 }
 function skipWorktreeRemoval(input) {
@@ -9431,7 +9536,7 @@ function skipWorktreeRemoval(input) {
   if (ageThresholdMs > 0 && ageMs < ageThresholdMs) return "below_age_threshold";
   const status = indexedWorktreeStatus(indexed);
   if (isWorkerProcessLive(indexed)) return "active_worker";
-  if (indexed.worker.completionBlocker) return "completion_blocked";
+  if (completionBlockerBlocksWorktreeRemoval(indexed, status)) return "completion_blocked";
   if (runBlocksWorktreeRemoval(indexed, input.liveness)) return "run_still_active";
   if (!isFinishedWorkerStatus(status)) return "run_still_active";
   if (isPrOrUnmergedWork(status)) return "pr_or_unmerged_commits";
@@ -9587,7 +9692,9 @@ function skipRunDirectoryRemoval(input) {
   }
   if (!runDirectoryIsEmpty(runPath)) return "run_still_active";
   const run = loadRunStatus(harnessRoot, runId);
-  if (run && !TERMINAL_RUN_STATUSES.has(run.status)) return "run_still_active";
+  if (run && !TERMINAL_RUN_STATUSES.has(run.status)) {
+    if (!deriveTerminalRunStatus(run)) return "run_still_active";
+  }
   if (runDirectoriesAgeMs > 0 && ageMs < runDirectoriesAgeMs) return "below_age_threshold";
   return null;
 }
@@ -10677,14 +10784,14 @@ function runHarnessCleanup(options = {}) {
   const paths = resolvePaths(options);
   emitCleanupProgress("scan", `${paths.scanRoots.length} harness root(s)`);
   const activeGuards = collectActiveWorktreeGuards(paths.scanRoots, paths.now);
-  emitCleanupProgress("index", "building worktree index");
-  const index = mergeWorktreeIndexes(paths.scanRoots);
-  emitCleanupProgress("index", `${index.size} indexed worktree(s)`);
-  const liveness = { runTerminalCache: new CleanupRunTerminalCache() };
   const finalizedRuns = retention.finalizeStaleRuns ? finalizeStaleRuns().map((f) => ({ runId: f.runId, from: f.from, to: f.to })) : [];
   if (finalizedRuns.length > 0) {
     emitCleanupProgress("finalize", `${finalizedRuns.length} stale run(s) marked terminal`);
   }
+  emitCleanupProgress("index", "building worktree index");
+  const index = mergeWorktreeIndexes(paths.scanRoots);
+  emitCleanupProgress("index", `${index.size} indexed worktree(s)`);
+  const liveness = { runTerminalCache: new CleanupRunTerminalCache() };
   const skips = [];
   const actions = [];
   const processedPaths = /* @__PURE__ */ new Set();