@kynver-app/runtime 0.1.108 → 0.1.116

package/dist/server/cleanup.js

@@ -1,18 +1,7 @@
-// src/cleanup.ts
-import path23 from "node:path";
-
-// src/paths.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import path6 from "node:path";
-
-// src/config.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2, totalmem } from "node:os";
-import path5 from "node:path";
-
-// src/git.ts
-import { spawnSync } from "node:child_process";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 
 // src/util.ts
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
@@ -21,6 +10,10 @@ function fail(message) {
   console.error(message);
   process.exit(1);
 }
+function hiddenSpawnOptions(opts) {
+  if (process.platform !== "win32") return opts;
+  return { windowsHide: true, ...opts };
+}
 function safeJson(line) {
   try {
     return JSON.parse(line);
@@ -88,45 +81,61 @@ function latestIso(values) {
 function secsAgo(ms) {
   return Math.max(0, Math.round((Date.now() - ms) / 1e3));
 }
+var init_util = __esm({
+  "src/util.ts"() {
+    "use strict";
+  }
+});
 
 // src/worker-env.ts
-var FORBIDDEN_WORKER_ENV_KEYS = [
-  "ANTHROPIC_API_KEY",
-  "ANALYST_API_KEY",
-  "RECRUITER_API_KEY",
-  "AUTH_SECRET",
-  "NEXTAUTH_SECRET",
-  "DATABASE_URL",
-  "PRODUCTION_DATABASE_URL",
-  "KYNVER_PRODUCTION_DATABASE_URL",
-  "REDIS_URL",
-  "GOOGLE_CLIENT_SECRET",
-  "GITHUB_CLIENT_SECRET",
-  "KYNVER_API_KEY",
-  "KYNVER_SERVICE_SECRET",
-  "KYNVER_RUNTIME_SECRET",
-  "KYNVER_CRON_SECRET",
-  "OPENCLAW_CRON_SECRET",
-  "QSTASH_TOKEN",
-  "QSTASH_CURRENT_SIGNING_KEY",
-  "QSTASH_NEXT_SIGNING_KEY",
-  "TOOL_SECRETS_KEK",
-  "TOOL_EXECUTOR_DISPATCH_SECRET",
-  "CLOUDFLARE_API_TOKEN",
-  "STRIPE_SECRET_KEY",
-  "STRIPE_WEBHOOK_SECRET",
-  "STRIPE_IDENTITY_WEBHOOK_SECRET",
-  "VOYAGE_API_KEY",
-  "PERPLEXITY_API_KEY",
-  "FRED_API_KEY",
-  "FMP_API_KEY",
-  "CURSOR_API_KEY"
-];
-var FORBIDDEN_KEY_SET = new Set(FORBIDDEN_WORKER_ENV_KEYS);
+var FORBIDDEN_WORKER_ENV_KEYS, FORBIDDEN_KEY_SET;
+var init_worker_env = __esm({
+  "src/worker-env.ts"() {
+    "use strict";
+    FORBIDDEN_WORKER_ENV_KEYS = [
+      "ANTHROPIC_API_KEY",
+      "ANALYST_API_KEY",
+      "RECRUITER_API_KEY",
+      "AUTH_SECRET",
+      "NEXTAUTH_SECRET",
+      "DATABASE_URL",
+      "PRODUCTION_DATABASE_URL",
+      "KYNVER_PRODUCTION_DATABASE_URL",
+      "REDIS_URL",
+      "GOOGLE_CLIENT_SECRET",
+      "GITHUB_CLIENT_SECRET",
+      "KYNVER_API_KEY",
+      "KYNVER_SERVICE_SECRET",
+      "KYNVER_RUNTIME_SECRET",
+      "KYNVER_CRON_SECRET",
+      "OPENCLAW_CRON_SECRET",
+      "QSTASH_TOKEN",
+      "QSTASH_CURRENT_SIGNING_KEY",
+      "QSTASH_NEXT_SIGNING_KEY",
+      "TOOL_SECRETS_KEK",
+      "TOOL_EXECUTOR_DISPATCH_SECRET",
+      "CLOUDFLARE_API_TOKEN",
+      "STRIPE_SECRET_KEY",
+      "STRIPE_WEBHOOK_SECRET",
+      "STRIPE_IDENTITY_WEBHOOK_SECRET",
+      "VOYAGE_API_KEY",
+      "PERPLEXITY_API_KEY",
+      "FRED_API_KEY",
+      "FMP_API_KEY",
+      "CURSOR_API_KEY"
+    ];
+    FORBIDDEN_KEY_SET = new Set(FORBIDDEN_WORKER_ENV_KEYS);
+  }
+});
 
 // src/git.ts
+import { spawnSync } from "node:child_process";
 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 +148,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 || "",
@@ -237,6 +250,13 @@ function unknownAncestry(base, error, head = null) {
     error
   };
 }
+var init_git = __esm({
+  "src/git.ts"() {
+    "use strict";
+    init_util();
+    init_worker_env();
+  }
+});
 
 // src/path-values.ts
 import { homedir } from "node:os";
@@ -251,15 +271,37 @@ function expandHomePath(value) {
 function resolveUserPath(value) {
   return path2.resolve(expandHomePath(value));
 }
+var init_path_values = __esm({
+  "src/path-values.ts"() {
+    "use strict";
+  }
+});
 
-// src/disk-gate.ts
-import { statfsSync as statfsSync2 } from "node:fs";
+// src/default-repo-discovery.ts
+var init_default_repo_discovery = __esm({
+  "src/default-repo-discovery.ts"() {
+    "use strict";
+    init_git();
+    init_path_values();
+  }
+});
+
+// src/box-identity.ts
+var init_box_identity = __esm({
+  "src/box-identity.ts"() {
+    "use strict";
+  }
+});
+
+// src/bounded-build/meminfo.ts
+var init_meminfo = __esm({
+  "src/bounded-build/meminfo.ts"() {
+    "use strict";
+  }
+});
 
 // src/wsl-host.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, statfsSync } from "node:fs";
-var DEFAULT_WSL_HOST_WARN_FREE_BYTES = 25 * 1024 * 1024 * 1024;
-var DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES = 12 * 1024 * 1024 * 1024;
-var DEFAULT_WSL_HOST_MOUNT = "/mnt/c";
 function isWslHost() {
   if (process.platform !== "linux") return false;
   for (const probe of ["/proc/sys/kernel/osrelease", "/proc/version"]) {
@@ -322,12 +364,18 @@ function observeWslHostDisk(options = {}) {
 function summarizeWslRecoverySteps() {
   return "Recovery: 1) free Windows C: (empty Recycle Bin / Storage Sense / clear %TEMP%); 2) shut down WSL (`wsl --shutdown`) then compact the VHDX (`Optimize-VHD` or `diskpart compact vdisk`); 3) clear local node_modules / .next / harness worktrees before restarting workers. Full runbook: docs/runbooks/wsl-disk-pressure.md.";
 }
+var DEFAULT_WSL_HOST_WARN_FREE_BYTES, DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES, DEFAULT_WSL_HOST_MOUNT;
+var init_wsl_host = __esm({
+  "src/wsl-host.ts"() {
+    "use strict";
+    DEFAULT_WSL_HOST_WARN_FREE_BYTES = 25 * 1024 * 1024 * 1024;
+    DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES = 12 * 1024 * 1024 * 1024;
+    DEFAULT_WSL_HOST_MOUNT = "/mnt/c";
+  }
+});
 
 // src/disk-gate.ts
-var DEFAULT_WARN_FREE_BYTES = 30 * 1024 * 1024 * 1024;
-var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
-var DEFAULT_MAX_USED_PERCENT = 80;
-var DEFAULT_HARD_MAX_USED_PERCENT = 90;
+import { statfsSync as statfsSync2 } from "node:fs";
 function observeRunnerDiskGate(input = {}) {
   const path24 = input.diskPath?.trim() || "/";
   const warnBelowBytes = input.diskFreeWarnBytes ?? DEFAULT_WARN_FREE_BYTES;
@@ -369,6 +417,17 @@ function observeRunnerDiskGate(input = {}) {
     wslHost
   };
 }
+var DEFAULT_WARN_FREE_BYTES, DEFAULT_CRITICAL_FREE_BYTES, DEFAULT_MAX_USED_PERCENT, DEFAULT_HARD_MAX_USED_PERCENT;
+var init_disk_gate = __esm({
+  "src/disk-gate.ts"() {
+    "use strict";
+    init_wsl_host();
+    DEFAULT_WARN_FREE_BYTES = 30 * 1024 * 1024 * 1024;
+    DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
+    DEFAULT_MAX_USED_PERCENT = 80;
+    DEFAULT_HARD_MAX_USED_PERCENT = 90;
+  }
+});
 
 // src/run-store.ts
 import { existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
@@ -416,6 +475,13 @@ function runDirectory(id) {
 function runDirectoryAt(harnessRoot, id) {
   return runDir(harnessRunsDir(harnessRoot), safeSlug(id));
 }
+var init_run_store = __esm({
+  "src/run-store.ts"() {
+    "use strict";
+    init_paths();
+    init_util();
+  }
+});
 
 // src/run-worker-index.ts
 import { existsSync as existsSync4, readdirSync as readdirSync3 } from "node:fs";
@@ -433,9 +499,13 @@ function listRunWorkerNames(run) {
   }
   return [...names];
 }
-
-// src/heartbeat.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+var init_run_worker_index = __esm({
+  "src/run-worker-index.ts"() {
+    "use strict";
+    init_run_store();
+    init_util();
+  }
+});
 
 // src/heartbeat-final-result.ts
 function tryParseJsonObject(text) {
@@ -486,9 +556,14 @@ function terminalFinalResultFromHeartbeatRow(row) {
   if (embedded) return embedded;
   return summary;
 }
+var init_heartbeat_final_result = __esm({
+  "src/heartbeat-final-result.ts"() {
+    "use strict";
+  }
+});
 
 // src/heartbeat.ts
-var HEARTBEAT_FUTURE_SKEW_MS = 6e4;
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
 function isTerminalHeartbeatPhase(phase) {
   return phase === "complete";
 }
@@ -551,29 +626,17 @@ function parseHeartbeat(file) {
   }
   return result;
 }
-
-// src/stream.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
+var HEARTBEAT_FUTURE_SKEW_MS;
+var init_heartbeat = __esm({
+  "src/heartbeat.ts"() {
+    "use strict";
+    init_heartbeat_final_result();
+    init_util();
+    HEARTBEAT_FUTURE_SKEW_MS = 6e4;
+  }
+});
 
 // src/repo-search.ts
-var RG_BINARIES = /* @__PURE__ */ new Set(["rg", "ripgrep", "grep"]);
-var RG_OPTS_WITH_VALUE = /* @__PURE__ */ new Set([
-  "-e",
-  "--regexp",
-  "-f",
-  "--file",
-  "-m",
-  "--max-count",
-  "-A",
-  "--after-context",
-  "-B",
-  "--before-context",
-  "-C",
-  "--context",
-  "-g",
-  "--glob",
-  "--iglob"
-]);
 function binaryName(token) {
   if (!token) return null;
   const base = token.split("/").pop() ?? token;
@@ -772,11 +835,32 @@ function diagnoseRepoSearchFailure(input) {
   }
   return null;
 }
+var RG_BINARIES, RG_OPTS_WITH_VALUE;
+var init_repo_search = __esm({
+  "src/repo-search.ts"() {
+    "use strict";
+    RG_BINARIES = /* @__PURE__ */ new Set(["rg", "ripgrep", "grep"]);
+    RG_OPTS_WITH_VALUE = /* @__PURE__ */ new Set([
+      "-e",
+      "--regexp",
+      "-f",
+      "--file",
+      "-m",
+      "--max-count",
+      "-A",
+      "--after-context",
+      "-B",
+      "--before-context",
+      "-C",
+      "--context",
+      "-g",
+      "--glob",
+      "--iglob"
+    ]);
+  }
+});
 
 // src/shell-command-outcome.ts
-var NPM_AUDIT_RE = /\bnpm\s+audit\b/i;
-var RG_CMD_RE = /\b(rg|ripgrep)\b/i;
-var RG_REAL_ERROR_RE = /\b(error|invalid|unknown|panic|not found)\b/i;
 function tidy(text, max = 200) {
   const one = text.replace(/\s+/g, " ").trim();
   return one.length > max ? `${one.slice(0, max - 1)}\u2026` : one;
@@ -980,8 +1064,19 @@ function classifyShellCommandOutcome(input) {
     summary: `command failed (exit ${input.exitCode}): ${tail}`
   };
 }
+var NPM_AUDIT_RE, RG_CMD_RE, RG_REAL_ERROR_RE;
+var init_shell_command_outcome = __esm({
+  "src/shell-command-outcome.ts"() {
+    "use strict";
+    init_repo_search();
+    NPM_AUDIT_RE = /\bnpm\s+audit\b/i;
+    RG_CMD_RE = /\b(rg|ripgrep)\b/i;
+    RG_REAL_ERROR_RE = /\b(error|invalid|unknown|panic|not found)\b/i;
+  }
+});
 
 // src/stream.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
 function eventTimestampIso(event) {
   const tsMs = event.timestamp_ms;
   return event.timestamp || event.ts || (tsMs ? new Date(tsMs).toISOString() : void 0);
@@ -1082,38 +1177,15 @@ function parseHarnessStream(file) {
   }
   return result;
 }
+var init_stream = __esm({
+  "src/stream.ts"() {
+    "use strict";
+    init_shell_command_outcome();
+    init_util();
+  }
+});
 
 // src/exit-classify.ts
-var FAILURE_PATTERNS = [
-  {
-    test: /\b(?:invalid|unknown|unsupported|unrecognized)\b[^.\n]*\bmodel\b/i,
-    label: "provider rejected the requested model"
-  },
-  {
-    test: /\bmodel\b[^.\n]*\b(?:not\s+(?:found|supported|available|recognized|valid)|is\s+not\s+valid|does\s+not\s+exist)/i,
-    label: "provider rejected the requested model"
-  },
-  {
-    test: /\b(?:did you mean|available models|choose (?:a|one of)|supported models)\b/i,
-    label: "provider rejected the requested model"
-  },
-  {
-    test: /model preflight failed/i,
-    label: "model/provider preflight failed"
-  },
-  {
-    test: /\b(?:command not found|ENOENT|is the .*CLI on PATH|executable not found|no such file or directory)\b/i,
-    label: "provider CLI is missing or not on PATH"
-  },
-  {
-    test: /\bfailed to spawn\b/i,
-    label: "provider failed to spawn the worker process"
-  },
-  {
-    test: /\b(?:not logged in|unauthorized|authentication (?:failed|required)|invalid api key|missing api key|401)\b/i,
-    label: "provider authentication failed"
-  }
-];
 function tidy2(errorText, max = 240) {
   const oneLine2 = errorText.replace(/\s+/g, " ").trim();
   return oneLine2.length > max ? `${oneLine2.slice(0, max - 1)}\u2026` : oneLine2;
@@ -1128,6 +1200,42 @@ function classifyExitFailure(errorText) {
   }
   return null;
 }
+var FAILURE_PATTERNS;
+var init_exit_classify = __esm({
+  "src/exit-classify.ts"() {
+    "use strict";
+    FAILURE_PATTERNS = [
+      {
+        test: /\b(?:invalid|unknown|unsupported|unrecognized)\b[^.\n]*\bmodel\b/i,
+        label: "provider rejected the requested model"
+      },
+      {
+        test: /\bmodel\b[^.\n]*\b(?:not\s+(?:found|supported|available|recognized|valid)|is\s+not\s+valid|does\s+not\s+exist)/i,
+        label: "provider rejected the requested model"
+      },
+      {
+        test: /\b(?:did you mean|available models|choose (?:a|one of)|supported models)\b/i,
+        label: "provider rejected the requested model"
+      },
+      {
+        test: /model preflight failed/i,
+        label: "model/provider preflight failed"
+      },
+      {
+        test: /\b(?:command not found|ENOENT|is the .*CLI on PATH|executable not found|no such file or directory)\b/i,
+        label: "provider CLI is missing or not on PATH"
+      },
+      {
+        test: /\bfailed to spawn\b/i,
+        label: "provider failed to spawn the worker process"
+      },
+      {
+        test: /\b(?:not logged in|unauthorized|authentication (?:failed|required)|invalid api key|missing api key|401)\b/i,
+        label: "provider authentication failed"
+      }
+    ];
+  }
+});
 
 // src/exited-salvage.ts
 function trimOrNull(value) {
@@ -1186,6 +1294,11 @@ function assessExitedWorkerSalvage(input) {
     attentionReason: buildAttentionReason(kind, uncommittedCount, headCommit)
   };
 }
+var init_exited_salvage = __esm({
+  "src/exited-salvage.ts"() {
+    "use strict";
+  }
+});
 
 // src/landing-gate.ts
 function trimOrNull2(value) {
@@ -1231,6 +1344,11 @@ function landingAttentionReason(verdict) {
   if (!verdict.blocked) return void 0;
   return verdict.detail ?? verdict.reason ?? "dirty_worktree_no_pr";
 }
+var init_landing_gate = __esm({
+  "src/landing-gate.ts"() {
+    "use strict";
+  }
+});
 
 // src/worker-final-result-embed.ts
 function tryParseJsonObject2(text) {
@@ -1280,6 +1398,11 @@ function extractEmbeddedWorkerFinalResultRecord(value) {
   }
   return best;
 }
+var init_worker_final_result_embed = __esm({
+  "src/worker-final-result-embed.ts"() {
+    "use strict";
+  }
+});
 
 // src/landing-contract-gate.ts
 function trimOrNull3(value) {
@@ -1439,10 +1562,14 @@ function landingContractAttentionReason(verdict) {
   if (!verdict.blocked) return void 0;
   return verdict.detail ?? verdict.reason;
 }
+var init_landing_contract_gate = __esm({
+  "src/landing-contract-gate.ts"() {
+    "use strict";
+    init_worker_final_result_embed();
+  }
+});
 
 // src/status.ts
-var NO_START_MS = 18e4;
-var STALE_MS = 6e5;
 function computeAttention(input) {
   const now = Date.now();
   if (input.completionBlocker && !isSkippedTerminalCompletionBlocker(input.completionBlocker)) {
@@ -1634,7 +1761,15 @@ function computeWorkerStatus(worker, options = {}) {
     changedFiles,
     gitAncestry,
     instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
-    instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null
+    instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null,
+    model: worker.model ?? worker.orchestrationAudit?.model ?? null,
+    provider: worker.orchestrationAudit?.provider ?? null,
+    boxKind: worker.boxKind ?? null,
+    boxId: worker.boxId ?? null,
+    runtimeId: worker.runtimeId ?? null,
+    personaSlug: worker.personaSlug ?? null,
+    dispatched: worker.dispatched ?? null,
+    localOnly: worker.localOnly ?? null
   };
 }
 function isFinishedWorkerStatus(status) {
@@ -1647,15 +1782,63 @@ function isLandingBlockedWorkerStatus(status) {
   if (!status.finalResult) return false;
   return status.attention.state === "needs_attention" || status.attention.state === "blocked";
 }
+var NO_START_MS, STALE_MS;
+var init_status = __esm({
+  "src/status.ts"() {
+    "use strict";
+    init_heartbeat();
+    init_stream();
+    init_exit_classify();
+    init_exited_salvage();
+    init_git();
+    init_landing_gate();
+    init_landing_contract_gate();
+    init_worker_final_result_embed();
+    init_util();
+    NO_START_MS = 18e4;
+    STALE_MS = 6e5;
+  }
+});
+
+// src/harness-worker-active.ts
+var init_harness_worker_active = __esm({
+  "src/harness-worker-active.ts"() {
+    "use strict";
+    init_status();
+  }
+});
 
 // src/resource-gate.ts
-var DEFAULT_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
-var DEFAULT_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
+var DEFAULT_PER_WORKER_MEM_BYTES, DEFAULT_MEM_RESERVE_BYTES;
+var init_resource_gate = __esm({
+  "src/resource-gate.ts"() {
+    "use strict";
+    init_meminfo();
+    init_config();
+    init_box_identity();
+    init_worker_cap_source();
+    init_disk_gate();
+    init_run_store();
+    init_run_worker_index();
+    init_harness_worker_active();
+    init_util();
+    DEFAULT_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
+    DEFAULT_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
+  }
+});
+
+// src/worker-cap-source.ts
+var init_worker_cap_source = __esm({
+  "src/worker-cap-source.ts"() {
+    "use strict";
+    init_resource_gate();
+  }
+});
 
 // src/config.ts
-var CONFIG_DIR = path5.join(homedir2(), ".kynver");
-var CONFIG_FILE = path5.join(CONFIG_DIR, "config.json");
-var CREDENTIALS_FILE = path5.join(CONFIG_DIR, "credentials");
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2, totalmem } from "node:os";
+import path5 from "node:path";
 function loadUserConfig() {
   if (!existsSync7(CONFIG_FILE)) return {};
   try {
@@ -1664,12 +1847,28 @@ function loadUserConfig() {
     return {};
   }
 }
-var SETUP_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
-var SETUP_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
+var CONFIG_DIR, CONFIG_FILE, CREDENTIALS_FILE, SETUP_PER_WORKER_MEM_BYTES, SETUP_MEM_RESERVE_BYTES;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_default_repo_discovery();
+    init_path_values();
+    init_util();
+    init_box_identity();
+    init_worker_cap_source();
+    init_disk_gate();
+    CONFIG_DIR = path5.join(homedir2(), ".kynver");
+    CONFIG_FILE = path5.join(CONFIG_DIR, "config.json");
+    CREDENTIALS_FILE = path5.join(CONFIG_DIR, "credentials");
+    SETUP_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
+    SETUP_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
+  }
+});
 
 // src/paths.ts
-var LEGACY_ROOT = path6.join(homedir3(), ".openclaw", "harness");
-var HARNESS_LAYOUT_DIR_NAMES = /* @__PURE__ */ new Set(["runs", "worktrees"]);
+import { existsSync as existsSync8 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import path6 from "node:path";
 function normalizeHarnessRoot(root) {
   let resolved = path6.resolve(resolveUserPath(root.trim()));
   while (HARNESS_LAYOUT_DIR_NAMES.has(path6.basename(resolved))) {
@@ -1704,10 +1903,30 @@ function getHarnessPaths() {
 function runDir(runsDir, id) {
   return path6.join(runsDir, safeSlug(id));
 }
+var LEGACY_ROOT, HARNESS_LAYOUT_DIR_NAMES;
+var init_paths = __esm({
+  "src/paths.ts"() {
+    "use strict";
+    init_config();
+    init_path_values();
+    init_util();
+    LEGACY_ROOT = path6.join(homedir3(), ".openclaw", "harness");
+    HARNESS_LAYOUT_DIR_NAMES = /* @__PURE__ */ new Set(["runs", "worktrees"]);
+  }
+});
+
+// src/cleanup.ts
+init_paths();
+import path23 from "node:path";
 
 // src/cleanup-guards.ts
+init_landing_gate();
 import path8 from "node:path";
 
+// src/cleanup-index-status.ts
+init_git();
+init_status();
+
 // src/cleanup-build-cache-paths.ts
 var HARNESS_BUILD_CACHE_RELATIVE_PATHS = [
   ".next",
@@ -1735,7 +1954,34 @@ 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
+init_util();
 function indexedWorktreeStatus(entry) {
   if (!entry.status) {
     entry.status = computeWorkerStatus(entry.worker, {
@@ -1745,14 +1991,81 @@ 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/cleanup-guards.ts
+init_status();
+
 // src/finalize.ts
+init_run_store();
+init_run_worker_index();
+init_status();
+init_util();
 import path7 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set([
   "running",
@@ -1810,33 +2123,12 @@ 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-run-liveness.ts
+init_status();
 
 // src/cleanup-completion-blocker.ts
+init_landing_gate();
+init_status();
 function completionBlockerBlocksWorktreeRemoval(indexed, status) {
   const blocker = typeof indexed.worker.completionBlocker === "string" ? indexed.worker.completionBlocker.trim() : "";
   if (!blocker) return false;
@@ -1856,13 +2148,29 @@ function completionBlockerBlocksWorktreeRemoval(indexed, status) {
 }
 
 // src/cleanup-run-liveness.ts
+init_util();
+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 +2179,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 +2201,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 +2215,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 +2252,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) {
@@ -1983,6 +2302,8 @@ import { existsSync as existsSync11, readdirSync as readdirSync6, statSync as st
 import path12 from "node:path";
 
 // src/cleanup-active-worktrees.ts
+init_run_store();
+init_paths();
 import { existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
 import path11 from "node:path";
 
@@ -1990,7 +2311,19 @@ import path11 from "node:path";
 import { existsSync as existsSync9, readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
 import path10 from "node:path";
 
+// src/default-repo.ts
+init_config();
+init_default_repo_discovery();
+init_path_values();
+
+// src/run-metadata-retention.ts
+init_heartbeat();
+init_paths();
+init_run_store();
+
 // src/worker-metadata-paths.ts
+init_paths();
+init_util();
 import path9 from "node:path";
 var NESTED_RUNS = `${path9.sep}runs${path9.sep}runs${path9.sep}`;
 function workerArtifactPaths(workerDir) {
@@ -2004,6 +2337,7 @@ function workerArtifactPaths(workerDir) {
 }
 
 // src/run-metadata-retention.ts
+init_util();
 var RUN_METADATA_ACTIVE_SIGNAL_MS = 15 * 60 * 1e3;
 function isHarnessRunMetadataPath(targetPath, harnessRoot) {
   const resolved = path10.resolve(targetPath);
@@ -2075,6 +2409,7 @@ function collectFilesystemLiveRunKeys(harnessRoot, now = Date.now()) {
 }
 
 // src/cleanup-active-worktrees.ts
+init_util();
 function workerHasRecentHarnessActivity(worker, now) {
   const paths = [worker.heartbeatPath, worker.stdoutPath, worker.stderrPath];
   for (const target of paths) {
@@ -2123,6 +2458,7 @@ function isWorktreeOnLiveRun(worktreePath, harnessRoot, runId, liveRunKeys) {
 }
 
 // src/cleanup-run-directory.ts
+init_util();
 function pathAgeMs(target, now) {
   try {
     const mtime = statSync5(target).mtimeMs;
@@ -2185,6 +2521,7 @@ function scanStaleRunDirectoryCandidates(opts) {
 }
 
 // src/cleanup-execute.ts
+init_git();
 import { existsSync as existsSync14, rmSync as rmSync2 } from "node:fs";
 
 // src/cleanup-dir-size.ts
@@ -2240,6 +2577,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
 
 // src/cleanup-remove-path.ts
 import { existsSync as existsSync13, rmSync } from "node:fs";
+init_paths();
 
 // src/cleanup-path-ownership.ts
 import { lstatSync, readdirSync as readdirSync8 } from "node:fs";
@@ -2748,6 +3086,7 @@ function scanDependencyCacheCandidates(opts) {
 }
 
 // src/cleanup-duplicate-worktrees.ts
+init_git();
 import { existsSync as existsSync17, statSync as statSync9 } from "node:fs";
 import path18 from "node:path";
 function pathAgeMs4(target, now) {
@@ -2840,6 +3179,8 @@ function scanDuplicateWorktreeCandidates(opts) {
 }
 
 // src/cleanup-worktree-index.ts
+init_run_store();
+init_util();
 import path19 from "node:path";
 function buildWorktreeIndexAt(harnessRoot) {
   const index = /* @__PURE__ */ new Map();
@@ -2910,6 +3251,7 @@ function resolveHarnessRetention(options = {}) {
 }
 
 // src/cleanup-orphan-safety.ts
+init_git();
 import { existsSync as existsSync18, statSync as statSync10 } from "node:fs";
 import path20 from "node:path";
 var DEFAULT_HEARTBEAT_FRESH_MS = 30 * 60 * 1e3;
@@ -2962,6 +3304,7 @@ function assessOrphanWorktreeSafety(input) {
 }
 
 // src/harness-storage-snapshot.ts
+init_paths();
 import { existsSync as existsSync19, readdirSync as readdirSync11, statSync as statSync11 } from "node:fs";
 import path21 from "node:path";
 function harnessStorageSnapshot(opts = {}) {
@@ -3036,6 +3379,7 @@ function harnessStorageSnapshot(opts = {}) {
 }
 
 // src/cleanup-harness-roots.ts
+init_paths();
 import { existsSync as existsSync20 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import path22 from "node:path";
@@ -3071,6 +3415,7 @@ function resolveHarnessScanRoots(options = {}) {
 }
 
 // src/cleanup-disk-pressure.ts
+init_disk_gate();
 function envFlag2(name) {
   const v = process.env[name];
   return v === "1" || v === "true" || v === "yes";
@@ -3119,6 +3464,39 @@ function emitCleanupProgress(phase, detail) {
   console.error(`[kynver cleanup] ${phase}${suffix}`);
 }
 
+// src/cleanup-git-rev-cache.ts
+init_git();
+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
+init_git();
+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 +3614,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 +3638,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 +3666,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 +3702,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 +3723,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);