@kynver-app/runtime 0.1.108 → 0.1.112

package/dist/landing/cli-auth.d.ts

@@ -3,5 +3,9 @@ export interface EnsureGitHubCliAuthResult {
     configured: boolean;
     reason: string;
 }
-/** Mirror of server ready-pr-landing.cli-auth — resolve gh token from env or local CLI. */
+/**
+ * Intentional duplicate of `src/modules/agent-os/ready-pr-landing/ready-pr-landing.cli-auth.ts`.
+ * The runtime package cannot import `@/src` server modules (standalone esbuild bundle), so gh
+ * token resolution is mirrored here. Keep both copies in sync when auth probe logic changes.
+ */
 export declare function ensureGitHubTokenFromCliAuth(): EnsureGitHubCliAuthResult;

package/dist/landing/land-pr.d.ts

@@ -14,6 +14,14 @@ export interface ExecuteLandPrMergeInput {
     skipNotReady?: boolean;
     exec?: PrHandoffExec;
 }
+/** Parse `owner/repo` from a GitHub PR URL, e.g. https://github.com/acme/app/pull/42 -> "acme/app". Returns null on non-match. */
+export declare function repoFromPrUrl(prUrl: string): string | null;
+/** Pure predicate form of the runtime verification-evidence gate (for tests). */
+export declare function runtimeVerificationEvidenceSufficient(input: {
+    title?: string | null;
+    body?: string | null;
+    vercelCheckSuccess?: boolean;
+}): boolean;
 /**
  * Daemon-local PR merge — live readiness, squash merge, branch delete, worktree cleanup.
  */

package/dist/server/cleanup.js

@@ -21,6 +21,10 @@ function fail(message) {
   console.error(message);
   process.exit(1);
 }
+function hiddenSpawnOptions(opts) {
+  if (process.platform !== "win32") return opts;
+  return { windowsHide: true, ...opts };
+}
 function safeJson(line) {
   try {
     return JSON.parse(line);
@@ -126,7 +130,11 @@ var FORBIDDEN_KEY_SET = new Set(FORBIDDEN_WORKER_ENV_KEYS);
 
 // src/git.ts
 function git(cwd, args, options = {}) {
-  const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+  const res = spawnSync(
+    "git",
+    args,
+    hiddenSpawnOptions({ cwd, encoding: "utf8" })
+  );
   if (res.status !== 0 && !options.allowFailure) {
     const message = `git ${args.join(" ")} failed: ${res.stderr || res.stdout}`;
     if (options.throwError) throw new Error(message);
@@ -139,7 +147,11 @@ function gitStatusShort(worktreePath) {
 }
 function gitCapture(cwd, args) {
   try {
-    const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+    const res = spawnSync(
+      "git",
+      args,
+      hiddenSpawnOptions({ cwd, encoding: "utf8" })
+    );
     return {
       status: res.status,
       stdout: res.stdout || "",
@@ -1735,6 +1747,32 @@ function materialWorktreeChanges(changedFiles) {
   });
 }
 
+// src/cleanup-worktree-salvage.ts
+function prUrlFromFinalResult(finalResult) {
+  if (typeof finalResult === "string") {
+    const match = finalResult.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/i);
+    return match?.[0] ?? null;
+  }
+  if (finalResult && typeof finalResult === "object") {
+    const obj = finalResult;
+    for (const key of ["prUrl", "pr_url", "pullRequestUrl"]) {
+      const value = obj[key];
+      if (typeof value === "string" && value.trim()) return value.trim();
+    }
+  }
+  return null;
+}
+function isPrOrUnmergedWork(status) {
+  const relation = status.gitAncestry?.relation;
+  if (relation === "merged" || relation === "synced") {
+    return materialWorktreeChanges(status.changedFiles).length > 0;
+  }
+  if (prUrlFromFinalResult(status.finalResult)) return true;
+  if (relation === "ahead" || relation === "diverged") return true;
+  if (status.changedFiles.length > 0 && status.finalResult) return true;
+  return false;
+}
+
 // src/cleanup-index-status.ts
 function indexedWorktreeStatus(entry) {
   if (!entry.status) {
@@ -1745,11 +1783,71 @@ function indexedWorktreeStatus(entry) {
   }
   return entry.status;
 }
-function indexedWorktreeHasMaterialChanges(entry) {
+function indexedWorktreeHasMaterialChanges(entry, gitStatusCache) {
   if (entry.status) {
     return materialWorktreeChanges(entry.status.changedFiles).length > 0;
   }
-  return materialWorktreeChanges(gitStatusShort(entry.worktreePath)).length > 0;
+  const porcelain = gitStatusCache ? gitStatusCache.porcelain(entry.worktreePath) : gitStatusShort(entry.worktreePath);
+  return materialWorktreeChanges(porcelain).length > 0;
+}
+function finalResultFromWorkerJson(entry) {
+  const snapshot = entry.worker.completionSnapshot?.finalResult;
+  if (snapshot !== void 0 && snapshot !== null) return snapshot;
+  if (entry.worker.taskPrUrl) {
+    return { prUrl: entry.worker.taskPrUrl };
+  }
+  return null;
+}
+function resolveWorktreeGuardStatus(entry, ctx) {
+  if (entry.status) return entry.status;
+  const worker = entry.worker;
+  const completionAcknowledged = typeof worker.completionReportedAt === "string" && worker.completionReportedAt.trim().length > 0;
+  const workerJsonTerminal = Boolean(worker.status && ["done", "exited", "blocked", "failed", "abandoned"].includes(worker.status)) || completionAcknowledged;
+  const finalResult = finalResultFromWorkerJson(entry);
+  if (workerJsonTerminal && !isPidAlive(worker.pid)) {
+    const changedFiles = ctx?.gitStatusCache ? ctx.gitStatusCache.porcelain(entry.worktreePath) : gitStatusShort(entry.worktreePath);
+    const baseLabel = entry.run.baseCommit?.trim() || entry.run.base?.trim() || "origin/main";
+    const ahead = ctx?.gitRevCache?.countAheadOfMain(entry.worktreePath, baseLabel);
+    const gitAncestry = ahead === 0 ? {
+      checked: true,
+      base: baseLabel,
+      relation: "synced"
+    } : computeGitAncestry(entry.worktreePath, {
+      base: entry.run.base,
+      baseCommit: entry.run.baseCommit
+    });
+    const status = {
+      runId: entry.runId,
+      worker: entry.workerName,
+      pid: worker.pid,
+      alive: false,
+      status: worker.status ?? (completionAcknowledged ? "done" : "exited"),
+      attention: { state: completionAcknowledged ? "done" : "stale" },
+      branch: worker.branch,
+      worktreePath: entry.worktreePath,
+      ownedPaths: worker.ownedPaths,
+      stdoutBytes: 0,
+      stderrBytes: 0,
+      heartbeatBytes: 0,
+      firstEventAt: null,
+      lastEventAt: null,
+      lastActivityAt: worker.completionReportedAt ?? null,
+      currentTool: null,
+      heartbeatCount: 0,
+      lastHeartbeatAt: null,
+      lastHeartbeatPhase: null,
+      lastHeartbeatSummary: null,
+      heartbeatBlocker: null,
+      changedFiles,
+      gitAncestry,
+      finalResult,
+      completionBlocker: typeof worker.completionBlocker === "string" ? worker.completionBlocker.trim() || null : null,
+      prUrl: worker.repairTargetPrUrl ?? worker.taskPrUrl ?? prUrlFromFinalResult(finalResult)
+    };
+    entry.status = status;
+    return status;
+  }
+  return indexedWorktreeStatus(entry);
 }
 
 // src/finalize.ts
@@ -1810,32 +1908,6 @@ function finalizeStaleRuns() {
   return finalized;
 }
 
-// src/cleanup-worktree-salvage.ts
-function prUrlFromFinalResult(finalResult) {
-  if (typeof finalResult === "string") {
-    const match = finalResult.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/i);
-    return match?.[0] ?? null;
-  }
-  if (finalResult && typeof finalResult === "object") {
-    const obj = finalResult;
-    for (const key of ["prUrl", "pr_url", "pullRequestUrl"]) {
-      const value = obj[key];
-      if (typeof value === "string" && value.trim()) return value.trim();
-    }
-  }
-  return null;
-}
-function isPrOrUnmergedWork(status) {
-  const relation = status.gitAncestry?.relation;
-  if (relation === "merged" || relation === "synced") {
-    return materialWorktreeChanges(status.changedFiles).length > 0;
-  }
-  if (prUrlFromFinalResult(status.finalResult)) return true;
-  if (relation === "ahead" || relation === "diverged") return true;
-  if (status.changedFiles.length > 0 && status.finalResult) return true;
-  return false;
-}
-
 // src/cleanup-completion-blocker.ts
 function completionBlockerBlocksWorktreeRemoval(indexed, status) {
   const blocker = typeof indexed.worker.completionBlocker === "string" ? indexed.worker.completionBlocker.trim() : "";
@@ -1856,13 +1928,28 @@ function completionBlockerBlocksWorktreeRemoval(indexed, status) {
 }
 
 // src/cleanup-run-liveness.ts
+var TERMINAL_WORKER_JSON_STATUSES = /* @__PURE__ */ new Set([
+  "done",
+  "exited",
+  "blocked",
+  "failed",
+  "abandoned"
+]);
 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;
+  if (typeof indexed.worker.completionReportedAt === "string" && indexed.worker.completionReportedAt.trim().length > 0) {
+    return false;
+  }
+  const workerStatus = indexed.worker.status;
+  if (workerStatus && TERMINAL_WORKER_JSON_STATUSES.has(workerStatus)) return false;
+  if (!indexed.worker.pid) {
+    if (workerStatus !== "running") return false;
+    return indexedWorktreeStatus(indexed).alive;
+  }
   return false;
 }
 function isRunStaleActive(indexed, ctx) {
@@ -1871,6 +1958,10 @@ function isRunStaleActive(indexed, ctx) {
 }
 function runBlocksWorktreeRemoval(indexed, ctx) {
   if (isWorkerProcessLive(indexed)) return true;
+  const workerStatus = indexed.worker.status;
+  if (workerStatus && TERMINAL_WORKER_JSON_STATUSES.has(workerStatus) && !indexed.worker.completionBlocker) {
+    return false;
+  }
   const status = indexedWorktreeStatus(indexed);
   if (completionBlockerBlocksWorktreeRemoval(indexed, status)) return true;
   if (isFinishedWorkerStatus(status)) return false;
@@ -1889,7 +1980,7 @@ function effectiveWorktreeAgeMs(input) {
   if (input.liveness && isRunStaleActive(indexed, input.liveness)) {
     return terminalWorktreesAgeMs;
   }
-  if (input.liveness && isFinishedWorkerStatus(indexedWorktreeStatus(indexed)) && !isWorkerProcessLive(indexed)) {
+  if (input.liveness && isFinishedWorkerStatus(resolveWorktreeGuardStatus(indexed, input.liveness)) && !isWorkerProcessLive(indexed)) {
     return terminalWorktreesAgeMs;
   }
   return worktreesAgeMs;
@@ -1903,8 +1994,13 @@ function skipWorktreeRemoval(input) {
   const ageThresholdMs = effectiveWorktreeAgeMs(input);
   if (worktreesAgeMs <= 0 && !includeOrphans && ageThresholdMs <= 0) return "worktrees_disabled";
   if (ageThresholdMs > 0 && ageMs < ageThresholdMs) return "below_age_threshold";
-  const status = indexedWorktreeStatus(indexed);
   if (isWorkerProcessLive(indexed)) return "active_worker";
+  if (indexedWorktreeHasMaterialChanges(indexed, input.liveness?.gitStatusCache)) {
+    return "dirty_worktree";
+  }
+  const ahead = input.liveness?.gitRevCache?.countAheadOfMain(input.worktreePath);
+  if (ahead !== null && ahead !== void 0 && ahead > 0) return "pr_or_unmerged_commits";
+  const status = resolveWorktreeGuardStatus(indexed, input.liveness);
   if (completionBlockerBlocksWorktreeRemoval(indexed, status)) return "completion_blocked";
   if (runBlocksWorktreeRemoval(indexed, input.liveness)) return "run_still_active";
   if (!isFinishedWorkerStatus(status)) return "run_still_active";
@@ -1935,7 +2031,9 @@ function skipDependencyCacheRemoval(input) {
   if (!diskPressure && ageMs < nodeModulesAgeMs) return "below_age_threshold";
   if (activeWorktreePaths.has(path8.resolve(worktreePath))) return "active_worker";
   if (indexed && isWorkerProcessLive(indexed)) return "active_worker";
-  if (indexed && indexedWorktreeHasMaterialChanges(indexed)) return "dirty_worktree";
+  if (indexed && indexedWorktreeHasMaterialChanges(indexed, input.gitStatusCache)) {
+    return "dirty_worktree";
+  }
   return null;
 }
 function skipBuildCacheRemoval(input) {
@@ -3119,6 +3217,37 @@ function emitCleanupProgress(phase, detail) {
   console.error(`[kynver cleanup] ${phase}${suffix}`);
 }
 
+// src/cleanup-git-rev-cache.ts
+var CleanupGitRevCache = class {
+  aheadOfMain = /* @__PURE__ */ new Map();
+  countAheadOfMain(worktreePath, base = "origin/main") {
+    const key = `${worktreePath}\0${base}`;
+    if (this.aheadOfMain.has(key)) return this.aheadOfMain.get(key) ?? null;
+    const result = gitCapture(worktreePath, ["rev-list", "--count", `${base}..HEAD`]);
+    if (result.status !== 0) {
+      this.aheadOfMain.set(key, null);
+      return null;
+    }
+    const count = Number(result.stdout.trim());
+    const parsed = Number.isFinite(count) ? count : null;
+    this.aheadOfMain.set(key, parsed);
+    return parsed;
+  }
+};
+
+// src/cleanup-git-status-cache.ts
+var CleanupGitStatusCache = class {
+  cache = /* @__PURE__ */ new Map();
+  porcelain(worktreePath) {
+    const resolved = worktreePath;
+    const cached = this.cache.get(resolved);
+    if (cached !== void 0) return cached;
+    const lines = gitStatusShort(resolved);
+    this.cache.set(resolved, lines);
+    return lines;
+  }
+};
+
 // src/cleanup-run-terminal-cache.ts
 var CleanupRunTerminalCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -3236,7 +3365,11 @@ function runHarnessCleanup(options = {}) {
   emitCleanupProgress("index", "building worktree index");
   const index = mergeWorktreeIndexes(paths.scanRoots);
   emitCleanupProgress("index", `${index.size} indexed worktree(s)`);
-  const liveness = { runTerminalCache: new CleanupRunTerminalCache() };
+  const liveness = {
+    runTerminalCache: new CleanupRunTerminalCache(),
+    gitStatusCache: new CleanupGitStatusCache(),
+    gitRevCache: new CleanupGitRevCache()
+  };
   const skips = [];
   const actions = [];
   const processedPaths = /* @__PURE__ */ new Set();
@@ -3256,8 +3389,15 @@ function runHarnessCleanup(options = {}) {
       index,
       now: paths.now
     };
-    for (const raw of scanDependencyCacheCandidates(scanOpts)) {
+    const dependencyCandidates = scanDependencyCacheCandidates(scanOpts);
+    emitCleanupProgress("dependency", `${dependencyCandidates.length} cache candidate(s) at ${harnessRoot}`);
+    let dependencyProcessed = 0;
+    for (const raw of dependencyCandidates) {
       if (atSweepCap()) break;
+      dependencyProcessed += 1;
+      if (dependencyProcessed % 50 === 0) {
+        emitCleanupProgress("dependency", `${dependencyProcessed}/${dependencyCandidates.length} evaluated`);
+      }
       const resolved = path23.resolve(raw.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
@@ -3277,7 +3417,8 @@ function runHarnessCleanup(options = {}) {
         ageMs: candidate.ageMs,
         worktreePath,
         activeWorktreePaths: activeGuards.activeWorktreePaths,
-        diskPressure: retention.diskPressure
+        diskPressure: retention.diskPressure,
+        gitStatusCache: liveness.gitStatusCache
       });
       if (guardReason) {
         recordSkip(skips, candidate.path, guardReason);
@@ -3312,7 +3453,8 @@ function runHarnessCleanup(options = {}) {
         ageMs: candidate.ageMs,
         worktreePath,
         activeWorktreePaths: activeGuards.activeWorktreePaths,
-        diskPressure: retention.diskPressure
+        diskPressure: retention.diskPressure,
+        gitStatusCache: liveness.gitStatusCache
       });
       if (guardReason) {
         recordSkip(skips, candidate.path, guardReason);
@@ -3332,8 +3474,13 @@ function runHarnessCleanup(options = {}) {
     ];
     emitCleanupProgress("worktrees", `${worktreeCandidates.length} candidate(s) at ${harnessRoot}`);
     const worktreeSeen = /* @__PURE__ */ new Set();
+    let worktreeProcessed = 0;
     for (const raw of worktreeCandidates) {
       if (atSweepCap()) break;
+      worktreeProcessed += 1;
+      if (worktreeProcessed % 50 === 0) {
+        emitCleanupProgress("worktrees", `${worktreeProcessed}/${worktreeCandidates.length} evaluated`);
+      }
       const resolved = path23.resolve(raw.path);
       if (worktreeSeen.has(resolved)) continue;
       worktreeSeen.add(resolved);