@kynver-app/runtime 0.1.49 → 0.1.51

package/dist/index.js

@@ -35,43 +35,25 @@ function handleCliVersionFlag(argv, moduleUrl = import.meta.url, binName) {
 }
 
 // src/dispatch.ts
-import path17 from "node:path";
+import path18 from "node:path";
 
 // src/config.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import path4 from "node:path";
+
+// src/default-repo-discovery.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import path3 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
-// src/path-values.ts
-import { homedir } from "node:os";
-import path from "node:path";
-function expandHomePath(value) {
-  if (value === "~") return homedir();
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path.join(homedir(), value.slice(2));
-  }
-  return value;
-}
-function resolveUserPath(value) {
-  return path.resolve(expandHomePath(value));
-}
-function redactHomePath(value) {
-  const expanded = expandHomePath(value);
-  const resolved = path.resolve(expanded);
-  const home = path.resolve(homedir());
-  if (resolved === home) return "~";
-  if (resolved.startsWith(`${home}${path.sep}`)) {
-    return `~/${path.relative(home, resolved).split(path.sep).join("/")}`;
-  }
-  return resolved.replace(/^\/home\/[^/]+(?=\/|$)/, "~").replace(/^\/Users\/[^/]+(?=\/|$)/, "~");
-}
-function displayUserPath(value) {
-  return redactHomePath(value);
-}
+// src/git.ts
+import { spawnSync } from "node:child_process";
 
 // src/util.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync, statSync, writeFileSync } from "node:fs";
-import path2 from "node:path";
+import path from "node:path";
 function fail(message) {
   console.error(message);
   process.exit(1);
@@ -100,7 +82,7 @@ function readJson(file, fallback) {
   }
 }
 function writeJson(file, value) {
-  mkdirSync(path2.dirname(file), { recursive: true });
+  mkdirSync(path.dirname(file), { recursive: true });
   writeFileSync(file, `${JSON.stringify(value, null, 2)}
 `);
 }
@@ -136,7 +118,7 @@ function tailFile(file, lines) {
   return data.split("\n").slice(-lines).join("\n");
 }
 function readMaybeFile(file) {
-  return file ? readFileSync2(path2.resolve(file), "utf8") : "";
+  return file ? readFileSync2(path.resolve(file), "utf8") : "";
 }
 function listRunIds(runsDir) {
   if (!existsSync2(runsDir)) return [];
@@ -178,14 +160,280 @@ function secsAgo(ms) {
   return Math.max(0, Math.round((Date.now() - ms) / 1e3));
 }
 
+// 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",
+  "REDIS_URL",
+  "GOOGLE_CLIENT_SECRET",
+  "GITHUB_CLIENT_SECRET",
+  "KYNVER_API_KEY",
+  "KYNVER_SERVICE_SECRET",
+  "KYNVER_RUNTIME_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_SUFFIXES = ["_SECRET", "_API_KEY"];
+function isForbiddenWorkerEnvKey(key) {
+  if (FORBIDDEN_KEY_SET.has(key)) return true;
+  return FORBIDDEN_SUFFIXES.some((suffix) => key.endsWith(suffix));
+}
+function listForbiddenWorkerEnvKeys(env) {
+  return Object.keys(env).filter(isForbiddenWorkerEnvKey).sort();
+}
+function scrubWorkerEnv(env) {
+  const next = { ...env };
+  for (const key of Object.keys(next)) {
+    if (isForbiddenWorkerEnvKey(key)) delete next[key];
+  }
+  return next;
+}
+function auditWorkerEnv(env) {
+  const forbiddenPresent = listForbiddenWorkerEnvKeys(env);
+  return { forbiddenPresent, safe: forbiddenPresent.length === 0 };
+}
+function scrubClaudeEnv(env) {
+  return scrubWorkerEnv(env);
+}
+
+// src/git.ts
+function git(cwd, args, options = {}) {
+  const res = spawnSync("git", args, { 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);
+    fail(message);
+  }
+  return res.stdout || "";
+}
+function ensureGitRepo(repo) {
+  git(repo, ["rev-parse", "--show-toplevel"]);
+}
+function gitStatusShort(worktreePath) {
+  return git(worktreePath, ["status", "--short"], { allowFailure: true }).split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function gitCapture(cwd, args) {
+  try {
+    const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+    return {
+      status: res.status,
+      stdout: res.stdout || "",
+      stderr: res.stderr || "",
+      error: res.error ? res.error.message : null
+    };
+  } catch (error) {
+    return {
+      status: null,
+      stdout: "",
+      stderr: "",
+      error: error.message
+    };
+  }
+}
+function gitIsAncestor(cwd, ancestor, descendant) {
+  const res = gitCapture(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
+  if (res.status === 0) return { isAncestor: true, error: null };
+  if (res.status === 1) return { isAncestor: false, error: null };
+  return { isAncestor: null, error: res.error || res.stderr || res.stdout || `git exited ${res.status}` };
+}
+function computeGitAncestry(worktreePath, baseOrOptions = "origin/main") {
+  const options = typeof baseOrOptions === "string" ? { base: baseOrOptions } : baseOrOptions;
+  const baseLabel = options.baseCommit?.trim() || options.base?.trim() || "origin/main";
+  const pinnedBaseCommit = options.baseCommit?.trim() || null;
+  if (!worktreePath) {
+    return unknownAncestry(baseLabel, "missing worktree path");
+  }
+  const head = gitCapture(worktreePath, ["rev-parse", "HEAD"]);
+  if (head.status !== 0) {
+    return unknownAncestry(baseLabel, head.error || head.stderr || head.stdout || "failed to resolve HEAD");
+  }
+  let baseSha;
+  if (pinnedBaseCommit) {
+    baseSha = pinnedBaseCommit;
+  } else {
+    const baseHead = gitCapture(worktreePath, ["rev-parse", baseLabel]);
+    if (baseHead.status !== 0) {
+      return unknownAncestry(
+        baseLabel,
+        baseHead.error || baseHead.stderr || baseHead.stdout || `failed to resolve ${baseLabel}`,
+        head.stdout.trim()
+      );
+    }
+    baseSha = baseHead.stdout.trim();
+  }
+  const headSha = head.stdout.trim();
+  if (headSha === baseSha) {
+    return {
+      checked: true,
+      base: baseLabel,
+      head: headSha,
+      baseHead: baseSha,
+      baseIsAncestorOfHead: true,
+      headIsAncestorOfBase: true,
+      relation: "synced"
+    };
+  }
+  const baseIsAncestorOfHead = gitIsAncestor(worktreePath, baseSha, headSha);
+  const headIsAncestorOfBase = gitIsAncestor(worktreePath, headSha, baseSha);
+  const error = baseIsAncestorOfHead.error || headIsAncestorOfBase.error || void 0;
+  if (baseIsAncestorOfHead.isAncestor == null || headIsAncestorOfBase.isAncestor == null) {
+    return {
+      checked: false,
+      base: baseLabel,
+      head: headSha,
+      baseHead: baseSha,
+      baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
+      headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
+      relation: "unknown",
+      ...error ? { error } : {}
+    };
+  }
+  const relation = baseIsAncestorOfHead.isAncestor ? "ahead" : headIsAncestorOfBase.isAncestor ? "merged" : "diverged";
+  return {
+    checked: true,
+    base: baseLabel,
+    head: headSha,
+    baseHead: baseSha,
+    baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
+    headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
+    relation,
+    ...error ? { error } : {}
+  };
+}
+function unknownAncestry(base, error, head = null) {
+  return {
+    checked: false,
+    base,
+    head,
+    baseHead: null,
+    baseIsAncestorOfHead: null,
+    headIsAncestorOfBase: null,
+    relation: "unknown",
+    error
+  };
+}
+
+// src/path-values.ts
+import { homedir } from "node:os";
+import path2 from "node:path";
+function expandHomePath(value) {
+  if (value === "~") return homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path2.join(homedir(), value.slice(2));
+  }
+  return value;
+}
+function resolveUserPath(value) {
+  return path2.resolve(expandHomePath(value));
+}
+function redactHomePath(value) {
+  const expanded = expandHomePath(value);
+  const resolved = path2.resolve(expanded);
+  const home = path2.resolve(homedir());
+  if (resolved === home) return "~";
+  if (resolved.startsWith(`${home}${path2.sep}`)) {
+    return `~/${path2.relative(home, resolved).split(path2.sep).join("/")}`;
+  }
+  return resolved.replace(/^\/home\/[^/]+(?=\/|$)/, "~").replace(/^\/Users\/[^/]+(?=\/|$)/, "~");
+}
+function displayUserPath(value) {
+  return redactHomePath(value);
+}
+
+// src/default-repo-discovery.ts
+var WELL_KNOWN_REPO_DIRS = ["Kynver", "repos/Kynver", "code/Kynver", "projects/Kynver"];
+function readPackageName(repoRoot) {
+  const pkgPath = path3.join(repoRoot, "package.json");
+  if (!existsSync3(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+    return typeof pkg.name === "string" ? pkg.name.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function isKynverMonorepoRoot(repoRoot) {
+  return readPackageName(repoRoot) === "kynver";
+}
+function gitRepoRoot(startDir) {
+  const resolvedStart = path3.resolve(startDir);
+  if (!existsSync3(resolvedStart)) return null;
+  const probe = gitCapture(resolvedStart, ["rev-parse", "--show-toplevel"]);
+  if (probe.status !== 0) return null;
+  const root = probe.stdout.trim();
+  return root.length ? path3.resolve(root) : null;
+}
+function resolveRuntimePackageRoot(moduleUrl = import.meta.url) {
+  let dir = path3.dirname(fileURLToPath2(moduleUrl));
+  for (let depth = 0; depth < 8; depth += 1) {
+    const pkgPath = path3.join(dir, "package.json");
+    if (existsSync3(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+        if (pkg.name === "@kynver-app/runtime") return dir;
+      } catch {
+      }
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function pushCandidate(seen, out, repo, source) {
+  if (!repo) return;
+  const resolved = path3.resolve(repo);
+  if (seen.has(resolved)) return;
+  if (!isKynverMonorepoRoot(resolved)) return;
+  seen.add(resolved);
+  out.push({ repo: resolved, source });
+}
+function discoverDefaultRepoCandidates(opts) {
+  const cwd = opts?.cwd ?? process.cwd();
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  pushCandidate(seen, candidates, gitRepoRoot(cwd), "cwd_git");
+  const runtimePkgRoot = resolveRuntimePackageRoot(opts?.runtimeModuleUrl ?? import.meta.url);
+  if (runtimePkgRoot) {
+    pushCandidate(seen, candidates, gitRepoRoot(runtimePkgRoot), "runtime_checkout");
+  }
+  const home = homedir2();
+  for (const rel of WELL_KNOWN_REPO_DIRS) {
+    pushCandidate(seen, candidates, resolveUserPath(path3.join(home, rel)), "well_known_path");
+  }
+  return candidates;
+}
+function discoverDefaultRepo(opts) {
+  return discoverDefaultRepoCandidates(opts)[0] ?? null;
+}
+
 // src/config.ts
-var CONFIG_DIR = path3.join(homedir2(), ".kynver");
-var CONFIG_FILE = path3.join(CONFIG_DIR, "config.json");
-var CREDENTIALS_FILE = path3.join(CONFIG_DIR, "credentials");
+var CONFIG_DIR = path4.join(homedir3(), ".kynver");
+var CONFIG_FILE = path4.join(CONFIG_DIR, "config.json");
+var CREDENTIALS_FILE = path4.join(CONFIG_DIR, "credentials");
 function loadUserConfig() {
-  if (!existsSync3(CONFIG_FILE)) return {};
+  if (!existsSync4(CONFIG_FILE)) return {};
   try {
-    return JSON.parse(readFileSync3(CONFIG_FILE, "utf8"));
+    return JSON.parse(readFileSync4(CONFIG_FILE, "utf8"));
   } catch {
     return {};
   }
@@ -209,7 +457,8 @@ function inferSetupFields(existing, args) {
   const creds = loadCredentialsFile();
   const apiBaseUrl = (typeof args.apiBaseUrl === "string" ? args.apiBaseUrl : void 0) || existing.apiBaseUrl?.trim() || process.env.KYNVER_API_URL?.trim() || process.env.OPENCLAW_CRON_FIRE_BASE_URL?.trim();
   const agentOsId = (typeof args.agentOsId === "string" ? args.agentOsId : void 0) || existing.agentOsId?.trim() || process.env.KYNVER_AGENT_OS_ID?.trim() || (creds.runnerToken?.trim().startsWith("krc1.") ? creds.runnerTokenAgentOsId?.trim() : void 0);
-  const defaultRepo = (typeof args.repo === "string" ? args.repo : void 0) || existing.defaultRepo?.trim() || process.env.KYNVER_DEFAULT_REPO?.trim() || process.env.KYNVER_HARNESS_REPO?.trim();
+  const explicitRepo = typeof args.repo === "string" ? args.repo : args.discoverRepo === true || args.discoverRepo === "true" ? discoverDefaultRepo()?.repo : void 0;
+  const defaultRepo = explicitRepo || existing.defaultRepo?.trim() || process.env.KYNVER_DEFAULT_REPO?.trim() || process.env.KYNVER_HARNESS_REPO?.trim() || discoverDefaultRepo()?.repo;
   const harnessRoot = (typeof args.harnessRoot === "string" ? args.harnessRoot : void 0) || existing.harnessRoot?.trim() || process.env.KYNVER_HARNESS_ROOT?.trim() || process.env.OPUS_HARNESS_ROOT?.trim();
   return {
     ...apiBaseUrl ? { apiBaseUrl: trimTrailingSlash(apiBaseUrl) } : {},
@@ -220,9 +469,9 @@ function inferSetupFields(existing, args) {
   };
 }
 function loadCredentialsFile() {
-  if (!existsSync3(CREDENTIALS_FILE)) return {};
+  if (!existsSync4(CREDENTIALS_FILE)) return {};
   try {
-    return JSON.parse(readFileSync3(CREDENTIALS_FILE, "utf8"));
+    return JSON.parse(readFileSync4(CREDENTIALS_FILE, "utf8"));
   } catch {
     return {};
   }
@@ -508,12 +757,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 path38 = input.diskPath?.trim() || "/";
+  const path40 = 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(path38);
+  const stats = statfsSync(path40);
   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;
@@ -533,7 +782,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path38,
+    path: path40,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -549,7 +798,7 @@ function observeRunnerDiskGate(input = {}) {
 import os2 from "node:os";
 
 // src/bounded-build/meminfo.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 import os from "node:os";
 function readMemAvailableBytes(meminfoText) {
   if (meminfoText !== void 0) {
@@ -559,7 +808,7 @@ function readMemAvailableBytes(meminfoText) {
   }
   if (process.platform === "linux") {
     try {
-      const meminfo = readFileSync4("/proc/meminfo", "utf8");
+      const meminfo = readFileSync5("/proc/meminfo", "utf8");
       const match = meminfo.match(/^MemAvailable:\s+(\d+)\s*kB/m);
       if (match) return Number(match[1]) * 1024;
     } catch {
@@ -569,37 +818,37 @@ function readMemAvailableBytes(meminfoText) {
 }
 
 // src/resource-gate.ts
-import path6 from "node:path";
+import path7 from "node:path";
 
 // src/run-store.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
-import path5 from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "node:fs";
+import path6 from "node:path";
 
 // src/paths.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import path4 from "node:path";
-var LEGACY_ROOT = path4.join(homedir3(), ".openclaw", "harness");
+import { existsSync as existsSync5 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import path5 from "node:path";
+var LEGACY_ROOT = path5.join(homedir4(), ".openclaw", "harness");
 function resolveHarnessRoot() {
   const env = process.env.KYNVER_HARNESS_ROOT || process.env.OPUS_HARNESS_ROOT;
   if (env) return resolveUserPath(env);
   const configured = loadUserConfig().harnessRoot?.trim();
   if (configured) return resolveUserPath(configured);
-  const kynverRoot = path4.join(homedir3(), ".kynver", "harness");
-  if (existsSync4(kynverRoot)) return kynverRoot;
-  if (existsSync4(LEGACY_ROOT)) return LEGACY_ROOT;
+  const kynverRoot = path5.join(homedir4(), ".kynver", "harness");
+  if (existsSync5(kynverRoot)) return kynverRoot;
+  if (existsSync5(LEGACY_ROOT)) return LEGACY_ROOT;
   return kynverRoot;
 }
 function getHarnessPaths() {
   const harnessRoot = resolveHarnessRoot();
   return {
     harnessRoot,
-    runsDir: path4.join(harnessRoot, "runs"),
-    worktreesDir: path4.join(harnessRoot, "worktrees")
+    runsDir: path5.join(harnessRoot, "runs"),
+    worktreesDir: path5.join(harnessRoot, "worktrees")
   };
 }
 function runDir(runsDir, id) {
-  return path4.join(runsDir, safeSlug(id));
+  return path5.join(runsDir, safeSlug(id));
 }
 
 // src/run-store.ts
@@ -608,16 +857,16 @@ function getPaths() {
 }
 function loadRun(id) {
   const { runsDir } = getPaths();
-  return readJson(path5.join(runDir(runsDir, safeSlug(id)), "run.json"));
+  return readJson(path6.join(runDir(runsDir, safeSlug(id)), "run.json"));
 }
 function listRunRecords() {
   const { runsDir } = getPaths();
-  if (!existsSync5(runsDir)) return [];
+  if (!existsSync6(runsDir)) return [];
   const runs = [];
   for (const entry of readdirSync2(runsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const run = readJson(
-      path5.join(runsDir, entry.name, "run.json"),
+      path6.join(runsDir, entry.name, "run.json"),
       void 0
     );
     if (run?.id) runs.push(run);
@@ -627,16 +876,16 @@ function listRunRecords() {
 function loadWorker(runId, name) {
   const { runsDir } = getPaths();
   return readJson(
-    path5.join(runDir(runsDir, safeSlug(runId)), "workers", safeSlug(name), "worker.json")
+    path6.join(runDir(runsDir, safeSlug(runId)), "workers", safeSlug(name), "worker.json")
   );
 }
 function saveRun(run) {
   const { runsDir } = getPaths();
-  writeJson(path5.join(runDir(runsDir, run.id), "run.json"), run);
+  writeJson(path6.join(runDir(runsDir, run.id), "run.json"), run);
 }
 function saveWorker(runId, worker) {
   const { runsDir } = getPaths();
-  writeJson(path5.join(runDir(runsDir, runId), "workers", worker.name, "worker.json"), worker);
+  writeJson(path6.join(runDir(runsDir, runId), "workers", worker.name, "worker.json"), worker);
 }
 function runDirectory(id) {
   const { runsDir } = getPaths();
@@ -644,7 +893,7 @@ function runDirectory(id) {
 }
 
 // src/heartbeat.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 var HEARTBEAT_FUTURE_SKEW_MS = 6e4;
 function isTerminalHeartbeatPhase(phase) {
   return phase === "complete";
@@ -663,10 +912,10 @@ function parseHeartbeat(file) {
     heartbeatBlocker: null,
     timestampAnomalies: []
   };
-  if (!existsSync6(file)) return result;
+  if (!existsSync7(file)) return result;
   const maxFutureMs = Date.now() + HEARTBEAT_FUTURE_SKEW_MS;
   const clampedTo = new Date(maxFutureMs).toISOString();
-  const lines = readFileSync5(file, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync6(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const entry = safeJson(line);
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
@@ -693,7 +942,7 @@ function parseHeartbeat(file) {
 }
 
 // src/stream.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
 
 // src/shell-command-outcome.ts
 var NPM_AUDIT_RE = /\bnpm\s+audit\b/i;
@@ -897,8 +1146,8 @@ function parseHarnessStream(file) {
     error: null,
     lastShellOutcome: null
   };
-  if (!existsSync7(file)) return result;
-  const lines = readFileSync6(file, "utf8").split("\n").filter(Boolean);
+  if (!existsSync8(file)) return result;
+  const lines = readFileSync7(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const event = safeJson(line);
     if (!event) continue;
@@ -1069,221 +1318,46 @@ function hasFinalResult(value) {
   return true;
 }
 function committedHeadFromAncestry(ancestry) {
-  if (!ancestry?.checked) return null;
-  if (ancestry.headIsAncestorOfBase !== false) return null;
-  return trimOrNull(ancestry.head);
-}
-function buildAttentionReason(kind, uncommittedCount, headCommit) {
-  const parts = ["exited_with_changes_salvage"];
-  if (kind === "uncommitted" || kind === "both") {
-    parts.push(
-      `${uncommittedCount} uncommitted change${uncommittedCount === 1 ? "" : "s"} with no final result`
-    );
-  }
-  if ((kind === "committed_ahead" || kind === "both") && headCommit) {
-    const sha = headCommit.length > 12 ? headCommit.slice(0, 12) : headCommit;
-    parts.push(`commit ${sha} ahead of base with no final result`);
-  }
-  parts.push("review worktree \u2014 commit, open a PR, or run a salvage worker before discarding");
-  return parts.join(": ");
-}
-function assessExitedWorkerSalvage(input) {
-  if (input.alive || hasFinalResult(input.finalResult)) return null;
-  const uncommittedCount = (input.changedFiles ?? []).filter((line) => line.trim()).length;
-  const headCommit = trimOrNull(input.headCommit) ?? committedHeadFromAncestry(input.gitAncestry);
-  const hasUncommitted = uncommittedCount > 0;
-  const hasCommittedAhead = Boolean(headCommit);
-  if (!hasUncommitted && !hasCommittedAhead) {
-    return {
-      kind: "none",
-      salvageable: false,
-      uncommittedCount: 0,
-      headCommit: null,
-      attentionReason: "process exited without a final result"
-    };
-  }
-  const kind = hasUncommitted && hasCommittedAhead ? "both" : hasUncommitted ? "uncommitted" : "committed_ahead";
-  return {
-    kind,
-    salvageable: true,
-    uncommittedCount,
-    headCommit,
-    attentionReason: buildAttentionReason(kind, uncommittedCount, headCommit)
-  };
-}
-
-// src/git.ts
-import { spawnSync } from "node:child_process";
-
-// 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",
-  "REDIS_URL",
-  "GOOGLE_CLIENT_SECRET",
-  "GITHUB_CLIENT_SECRET",
-  "KYNVER_API_KEY",
-  "KYNVER_SERVICE_SECRET",
-  "KYNVER_RUNTIME_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_SUFFIXES = ["_SECRET", "_API_KEY"];
-function isForbiddenWorkerEnvKey(key) {
-  if (FORBIDDEN_KEY_SET.has(key)) return true;
-  return FORBIDDEN_SUFFIXES.some((suffix) => key.endsWith(suffix));
-}
-function listForbiddenWorkerEnvKeys(env) {
-  return Object.keys(env).filter(isForbiddenWorkerEnvKey).sort();
-}
-function scrubWorkerEnv(env) {
-  const next = { ...env };
-  for (const key of Object.keys(next)) {
-    if (isForbiddenWorkerEnvKey(key)) delete next[key];
-  }
-  return next;
-}
-function auditWorkerEnv(env) {
-  const forbiddenPresent = listForbiddenWorkerEnvKeys(env);
-  return { forbiddenPresent, safe: forbiddenPresent.length === 0 };
-}
-function scrubClaudeEnv(env) {
-  return scrubWorkerEnv(env);
-}
-
-// src/git.ts
-function git(cwd, args, options = {}) {
-  const res = spawnSync("git", args, { 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);
-    fail(message);
-  }
-  return res.stdout || "";
-}
-function ensureGitRepo(repo) {
-  git(repo, ["rev-parse", "--show-toplevel"]);
-}
-function gitStatusShort(worktreePath) {
-  return git(worktreePath, ["status", "--short"], { allowFailure: true }).split("\n").map((line) => line.trim()).filter(Boolean);
-}
-function gitCapture(cwd, args) {
-  try {
-    const res = spawnSync("git", args, { cwd, encoding: "utf8" });
-    return {
-      status: res.status,
-      stdout: res.stdout || "",
-      stderr: res.stderr || "",
-      error: res.error ? res.error.message : null
-    };
-  } catch (error) {
-    return {
-      status: null,
-      stdout: "",
-      stderr: "",
-      error: error.message
-    };
-  }
-}
-function gitIsAncestor(cwd, ancestor, descendant) {
-  const res = gitCapture(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
-  if (res.status === 0) return { isAncestor: true, error: null };
-  if (res.status === 1) return { isAncestor: false, error: null };
-  return { isAncestor: null, error: res.error || res.stderr || res.stdout || `git exited ${res.status}` };
-}
-function computeGitAncestry(worktreePath, baseOrOptions = "origin/main") {
-  const options = typeof baseOrOptions === "string" ? { base: baseOrOptions } : baseOrOptions;
-  const baseLabel = options.baseCommit?.trim() || options.base?.trim() || "origin/main";
-  const pinnedBaseCommit = options.baseCommit?.trim() || null;
-  if (!worktreePath) {
-    return unknownAncestry(baseLabel, "missing worktree path");
-  }
-  const head = gitCapture(worktreePath, ["rev-parse", "HEAD"]);
-  if (head.status !== 0) {
-    return unknownAncestry(baseLabel, head.error || head.stderr || head.stdout || "failed to resolve HEAD");
-  }
-  let baseSha;
-  if (pinnedBaseCommit) {
-    baseSha = pinnedBaseCommit;
-  } else {
-    const baseHead = gitCapture(worktreePath, ["rev-parse", baseLabel]);
-    if (baseHead.status !== 0) {
-      return unknownAncestry(
-        baseLabel,
-        baseHead.error || baseHead.stderr || baseHead.stdout || `failed to resolve ${baseLabel}`,
-        head.stdout.trim()
-      );
-    }
-    baseSha = baseHead.stdout.trim();
+  if (!ancestry?.checked) return null;
+  if (ancestry.headIsAncestorOfBase !== false) return null;
+  return trimOrNull(ancestry.head);
+}
+function buildAttentionReason(kind, uncommittedCount, headCommit) {
+  const parts = ["exited_with_changes_salvage"];
+  if (kind === "uncommitted" || kind === "both") {
+    parts.push(
+      `${uncommittedCount} uncommitted change${uncommittedCount === 1 ? "" : "s"} with no final result`
+    );
   }
-  const headSha = head.stdout.trim();
-  if (headSha === baseSha) {
-    return {
-      checked: true,
-      base: baseLabel,
-      head: headSha,
-      baseHead: baseSha,
-      baseIsAncestorOfHead: true,
-      headIsAncestorOfBase: true,
-      relation: "synced"
-    };
+  if ((kind === "committed_ahead" || kind === "both") && headCommit) {
+    const sha = headCommit.length > 12 ? headCommit.slice(0, 12) : headCommit;
+    parts.push(`commit ${sha} ahead of base with no final result`);
   }
-  const baseIsAncestorOfHead = gitIsAncestor(worktreePath, baseSha, headSha);
-  const headIsAncestorOfBase = gitIsAncestor(worktreePath, headSha, baseSha);
-  const error = baseIsAncestorOfHead.error || headIsAncestorOfBase.error || void 0;
-  if (baseIsAncestorOfHead.isAncestor == null || headIsAncestorOfBase.isAncestor == null) {
+  parts.push("review worktree \u2014 commit, open a PR, or run a salvage worker before discarding");
+  return parts.join(": ");
+}
+function assessExitedWorkerSalvage(input) {
+  if (input.alive || hasFinalResult(input.finalResult)) return null;
+  const uncommittedCount = (input.changedFiles ?? []).filter((line) => line.trim()).length;
+  const headCommit = trimOrNull(input.headCommit) ?? committedHeadFromAncestry(input.gitAncestry);
+  const hasUncommitted = uncommittedCount > 0;
+  const hasCommittedAhead = Boolean(headCommit);
+  if (!hasUncommitted && !hasCommittedAhead) {
     return {
-      checked: false,
-      base: baseLabel,
-      head: headSha,
-      baseHead: baseSha,
-      baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
-      headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
-      relation: "unknown",
-      ...error ? { error } : {}
+      kind: "none",
+      salvageable: false,
+      uncommittedCount: 0,
+      headCommit: null,
+      attentionReason: "process exited without a final result"
     };
   }
-  const relation = baseIsAncestorOfHead.isAncestor ? "ahead" : headIsAncestorOfBase.isAncestor ? "merged" : "diverged";
-  return {
-    checked: true,
-    base: baseLabel,
-    head: headSha,
-    baseHead: baseSha,
-    baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
-    headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
-    relation,
-    ...error ? { error } : {}
-  };
-}
-function unknownAncestry(base, error, head = null) {
+  const kind = hasUncommitted && hasCommittedAhead ? "both" : hasUncommitted ? "uncommitted" : "committed_ahead";
   return {
-    checked: false,
-    base,
-    head,
-    baseHead: null,
-    baseIsAncestorOfHead: null,
-    headIsAncestorOfBase: null,
-    relation: "unknown",
-    error
+    kind,
+    salvageable: true,
+    uncommittedCount,
+    headCommit,
+    attentionReason: buildAttentionReason(kind, uncommittedCount, headCommit)
   };
 }
 
@@ -1645,7 +1719,7 @@ function countActiveWorkersForRun(run) {
   let active = 0;
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path6.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path7.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker || !isActiveHarnessWorker(worker)) continue;
@@ -2030,10 +2104,10 @@ function readHarnessRetryLimits() {
 }
 
 // src/lease-renewal.ts
-import path7 from "node:path";
+import path8 from "node:path";
 function workerRecord(runId, name) {
   return readJson(
-    path7.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path8.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -2099,8 +2173,8 @@ function hasLiveWorkerForTask(runId, taskId) {
 }
 
 // src/supervisor.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync3 } from "node:fs";
-import path13 from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync3 } from "node:fs";
+import path14 from "node:path";
 
 // src/prompt.ts
 function buildPrompt(input) {
@@ -2169,13 +2243,13 @@ function buildPrompt(input) {
 }
 
 // src/providers/cursor.ts
-import { closeSync as closeSync2, existsSync as existsSync9, openSync as openSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync10, openSync as openSync2 } from "node:fs";
 import { spawn as spawn2 } from "node:child_process";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/providers/cursor-windows.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync3 } from "node:fs";
+import path9 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];
@@ -2186,8 +2260,8 @@ function parseCursorVersionSortKey(versionName) {
   return Number(`${year}${month.padStart(2, "0")}${day.padStart(2, "0")}`);
 }
 function pickLatestCursorVersionDir(agentRoot) {
-  const versionsRoot = path8.join(agentRoot, "versions");
-  if (!existsSync8(versionsRoot)) return null;
+  const versionsRoot = path9.join(agentRoot, "versions");
+  if (!existsSync9(versionsRoot)) return null;
   let bestDir = null;
   let bestKey = -1;
   for (const entry of readdirSync3(versionsRoot, { withFileTypes: true })) {
@@ -2195,22 +2269,22 @@ function pickLatestCursorVersionDir(agentRoot) {
     const key = parseCursorVersionSortKey(entry.name);
     if (key == null || key <= bestKey) continue;
     bestKey = key;
-    bestDir = path8.join(versionsRoot, entry.name);
+    bestDir = path9.join(versionsRoot, entry.name);
   }
   return bestDir;
 }
 function resolveWindowsCursorBundled(agentRoot) {
-  const root = agentRoot?.trim() || path8.join(process.env.LOCALAPPDATA || "", "cursor-agent");
-  const directNode = path8.join(root, "node.exe");
-  const directIndex = path8.join(root, "index.js");
-  if (existsSync8(directNode) && existsSync8(directIndex)) {
+  const root = agentRoot?.trim() || path9.join(process.env.LOCALAPPDATA || "", "cursor-agent");
+  const directNode = path9.join(root, "node.exe");
+  const directIndex = path9.join(root, "index.js");
+  if (existsSync9(directNode) && existsSync9(directIndex)) {
     return { nodeExe: directNode, indexJs: directIndex, versionDir: root };
   }
   const versionDir = pickLatestCursorVersionDir(root);
   if (!versionDir) return null;
-  const nodeExe = path8.join(versionDir, "node.exe");
-  const indexJs = path8.join(versionDir, "index.js");
-  if (!existsSync8(nodeExe) || !existsSync8(indexJs)) return null;
+  const nodeExe = path9.join(versionDir, "node.exe");
+  const indexJs = path9.join(versionDir, "index.js");
+  if (!existsSync9(nodeExe) || !existsSync9(indexJs)) return null;
   return { nodeExe, indexJs, versionDir };
 }
 
@@ -2228,13 +2302,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) && existsSync9(path9.join(path9.dirname(agentBin), "index.js"));
+    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync10(path10.join(path10.dirname(agentBin), "index.js"));
     const isDefaultShim = agentBin === "agent";
     if (isCursorWrapper || isBundledNode || isDefaultShim) {
-      const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path9.dirname(agentBin)) : isBundledNode ? {
+      const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path10.dirname(agentBin)) : isBundledNode ? {
         nodeExe: agentBin,
-        indexJs: path9.join(path9.dirname(agentBin), "index.js"),
-        versionDir: path9.dirname(agentBin)
+        indexJs: path10.join(path10.dirname(agentBin), "index.js"),
+        versionDir: path10.dirname(agentBin)
       } : resolveWindowsCursorBundled();
       if (bundled) {
         return bundledSpawnTarget(bundled.nodeExe, bundled.indexJs, bundled.versionDir);
@@ -2254,8 +2328,8 @@ function resolveAgentBin() {
       process.env.KYNVER_CURSOR_AGENT_ROOT?.trim() || void 0
     );
     if (bundled) return bundled.nodeExe;
-    const localAgent = path9.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
-    if (existsSync9(localAgent)) return localAgent;
+    const localAgent = path10.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
+    if (existsSync10(localAgent)) return localAgent;
   }
   return "agent";
 }
@@ -2264,7 +2338,7 @@ function cursorWorkerEnv(agentBin, spawnTarget) {
     ...process.env,
     CI: "1",
     NO_COLOR: "1",
-    ...spawnTarget.bundledVersionDir ? { CURSOR_INVOKED_AS: path9.basename(agentBin) || "agent.cmd" } : {}
+    ...spawnTarget.bundledVersionDir ? { CURSOR_INVOKED_AS: path10.basename(agentBin) || "agent.cmd" } : {}
   });
 }
 var cursorProvider = {
@@ -2338,9 +2412,9 @@ function resolveWorkerProvider(name) {
 
 // src/auto-complete.ts
 import { spawn as spawn3 } from "node:child_process";
-import { existsSync as existsSync10, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
-import path12 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { existsSync as existsSync11, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
+import path13 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/completion-ack.ts
 function hasCompletionAck(worker) {
@@ -2356,7 +2430,7 @@ function persistCompletionAck(worker, runId, fields) {
 }
 
 // src/worker-ops.ts
-import path11 from "node:path";
+import path12 from "node:path";
 
 // src/completion-response.ts
 function asRecord(value) {
@@ -2838,7 +2912,7 @@ function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
 }
 
 // src/worker-lifecycle.ts
-import path10 from "node:path";
+import path11 from "node:path";
 var TASK_LEFT_RUNNING = /* @__PURE__ */ new Set([
   "awaiting_review",
   "blocked",
@@ -2894,7 +2968,7 @@ function syncCompletionAcknowledgedFromOperatorTick(runId, operatorTick) {
   const synced = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path10.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path11.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || isCompletionAcknowledged(worker)) continue;
@@ -3152,7 +3226,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(path11.join(worker.workerDir, "last-status.json"), status);
+  writeJson(path12.join(worker.workerDir, "last-status.json"), status);
   console.log(JSON.stringify(status, null, 2));
 }
 function buildRunBoard(runId) {
@@ -3160,7 +3234,7 @@ function buildRunBoard(runId) {
   const names = Object.keys(run.workers || {});
   const workers = names.map((name) => {
     const worker = readJson(
-      path11.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) {
@@ -3271,7 +3345,7 @@ function buildRunBoard(runId) {
     needsAttention: workers.filter((w) => w.attention && w.attention !== "ok" && w.attention !== "done").map((w) => w.worker),
     workers
   };
-  writeJson(path11.join(runDirectory(run.id), "last-board.json"), board);
+  writeJson(path12.join(runDirectory(run.id), "last-board.json"), board);
   return board;
 }
 async function publishHarnessBoardSnapshot(args, source) {
@@ -3460,12 +3534,12 @@ async function autoCompleteWorkerCli(raw) {
   }
 }
 function resolveDefaultCliPath() {
-  return path12.join(fileURLToPath2(new URL(".", import.meta.url)), "cli.js");
+  return path13.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnCompletionSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath();
-  if (!existsSync10(cliPath)) return void 0;
-  const logPath = path12.join(opts.workerDir, "auto-complete.log");
+  if (!existsSync11(cliPath)) return void 0;
+  const logPath = path13.join(opts.workerDir, "auto-complete.log");
   let logFd;
   try {
     logFd = openSync3(logPath, "a");
@@ -3547,16 +3621,16 @@ function spawnWorkerProcess(run, opts) {
     launchModel = preflight.model;
   }
   const { worktreesDir } = getPaths();
-  const workerDir = path13.join(runDirectory(run.id), "workers", name);
+  const workerDir = path14.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
-  const worktreePath = path13.join(worktreesDir, run.id, name);
+  const worktreePath = path14.join(worktreesDir, run.id, name);
   const branch = opts.branch || `agent/${run.id}/${name}`;
-  if (existsSync11(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
+  if (existsSync12(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 = path13.join(workerDir, "stdout.jsonl");
-  const stderrPath = path13.join(workerDir, "stderr.log");
-  const heartbeatPath = path13.join(workerDir, "heartbeat.jsonl");
+  const stdoutPath = path14.join(workerDir, "stdout.jsonl");
+  const stderrPath = path14.join(workerDir, "stderr.log");
+  const heartbeatPath = path14.join(workerDir, "heartbeat.jsonl");
   const prompt = buildPrompt({
     task: opts.task,
     ownedPaths: opts.ownedPaths || [],
@@ -3621,7 +3695,7 @@ function spawnWorkerProcess(run, opts) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveWorker(run.id, worker);
-  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path13.join(workerDir, "worker.json") } };
+  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path14.join(workerDir, "worker.json") } };
   run.status = "running";
   saveRun(run);
   if (worker.agentOsId && worker.taskId) {
@@ -3913,18 +3987,18 @@ function buildPlanPersistIdempotencyKey(input) {
 
 // src/plan-persist/paths.ts
 import { mkdirSync as mkdirSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import path14 from "node:path";
+import { homedir as homedir5 } from "node:os";
+import path15 from "node:path";
 function resolveKynverStateRoot() {
   const env = process.env.KYNVER_STATE_ROOT;
-  if (env) return path14.resolve(env);
-  return path14.join(homedir4(), ".kynver", "state");
+  if (env) return path15.resolve(env);
+  return path15.join(homedir5(), ".kynver", "state");
 }
 function planOutboxDir() {
-  return path14.join(resolveKynverStateRoot(), "plan-outbox");
+  return path15.join(resolveKynverStateRoot(), "plan-outbox");
 }
 function planOutboxArchiveDir() {
-  return path14.join(resolveKynverStateRoot(), "plan-outbox-archive");
+  return path15.join(resolveKynverStateRoot(), "plan-outbox-archive");
 }
 function ensurePlanOutboxDirs() {
   const outboxDir = planOutboxDir();
@@ -3935,20 +4009,20 @@ function ensurePlanOutboxDirs() {
 }
 function isTmpOnlyPath(filePath) {
   if (filePath.startsWith("/tmp/") || filePath.startsWith("/var/folders/")) return true;
-  const resolved = path14.resolve(filePath);
-  return resolved.startsWith("/tmp/") || resolved.startsWith(path14.join("/var", "folders"));
+  const resolved = path15.resolve(filePath);
+  return resolved.startsWith("/tmp/") || resolved.startsWith(path15.join("/var", "folders"));
 }
 
 // src/plan-persist/outbox-store.ts
 import {
-  existsSync as existsSync13,
-  readFileSync as readFileSync7,
+  existsSync as existsSync14,
+  readFileSync as readFileSync8,
   renameSync,
   readdirSync as readdirSync4,
   writeFileSync as writeFileSync3,
   unlinkSync
 } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 import { randomUUID } from "node:crypto";
 var DEFAULT_MAX_RETRIES = 12;
 function listOutboxItems() {
@@ -3956,7 +4030,7 @@ function listOutboxItems() {
   const files = readdirSync4(outboxDir).filter((f) => f.endsWith(".json"));
   const items = [];
   for (const file of files) {
-    const item = readOutboxItem(path15.join(outboxDir, file));
+    const item = readOutboxItem(path16.join(outboxDir, file));
     if (item && item.queueStatus === "queued") items.push(item);
   }
   return items.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
@@ -3968,25 +4042,25 @@ function findOutboxByIdempotencyKey(key) {
   return null;
 }
 function readOutboxItem(jsonPath) {
-  if (!existsSync13(jsonPath)) return null;
+  if (!existsSync14(jsonPath)) return null;
   try {
-    return JSON.parse(readFileSync7(jsonPath, "utf8"));
+    return JSON.parse(readFileSync8(jsonPath, "utf8"));
   } catch {
     return null;
   }
 }
 function readOutboxBody(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
-  const bodyFile = path15.join(outboxDir, item.bodyPath);
-  return readFileSync7(bodyFile, "utf8");
+  const bodyFile = path16.join(outboxDir, item.bodyPath);
+  return readFileSync8(bodyFile, "utf8");
 }
 function writeOutboxItem(input, opts) {
   const { outboxDir } = ensurePlanOutboxDirs();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const id = opts.existing?.id ?? randomUUID();
   const bodyPath = opts.existing?.bodyPath ?? `${id}.body.md`;
-  const jsonPath = path15.join(outboxDir, `${id}.json`);
-  const bodyFile = path15.join(outboxDir, bodyPath);
+  const jsonPath = path16.join(outboxDir, `${id}.json`);
+  const bodyFile = path16.join(outboxDir, bodyPath);
   if (!opts.existing) {
     writeFileSync3(bodyFile, input.body, "utf8");
   }
@@ -4022,24 +4096,24 @@ function writeOutboxItem(input, opts) {
 }
 function saveOutboxItem(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
-  const jsonPath = path15.join(outboxDir, `${item.id}.json`);
+  const jsonPath = path16.join(outboxDir, `${item.id}.json`);
   writeFileSync3(jsonPath, `${JSON.stringify(item, null, 2)}
 `, { mode: 384 });
 }
 function archiveOutboxItem(item) {
   const { outboxDir, archiveDir } = ensurePlanOutboxDirs();
-  const jsonSrc = path15.join(outboxDir, `${item.id}.json`);
-  const bodySrc = path15.join(outboxDir, item.bodyPath);
-  const jsonDst = path15.join(archiveDir, `${item.id}.json`);
-  const bodyDst = path15.join(archiveDir, item.bodyPath);
-  if (existsSync13(jsonSrc)) renameSync(jsonSrc, jsonDst);
-  if (existsSync13(bodySrc)) renameSync(bodySrc, bodyDst);
+  const jsonSrc = path16.join(outboxDir, `${item.id}.json`);
+  const bodySrc = path16.join(outboxDir, item.bodyPath);
+  const jsonDst = path16.join(archiveDir, `${item.id}.json`);
+  const bodyDst = path16.join(archiveDir, item.bodyPath);
+  if (existsSync14(jsonSrc)) renameSync(jsonSrc, jsonDst);
+  if (existsSync14(bodySrc)) renameSync(bodySrc, bodyDst);
 }
 function outboxItemPaths(item) {
   const { outboxDir } = ensurePlanOutboxDirs();
   return {
-    jsonPath: path15.join(outboxDir, `${item.id}.json`),
-    bodyPath: path15.join(outboxDir, item.bodyPath)
+    jsonPath: path16.join(outboxDir, `${item.id}.json`),
+    bodyPath: path16.join(outboxDir, item.bodyPath)
   };
 }
 function outboxInputFromItem(item, body) {
@@ -4225,7 +4299,7 @@ function markOutboxFailed(item, message) {
 }
 
 // src/plan-persist/drain.ts
-import path16 from "node:path";
+import path17 from "node:path";
 async function drainPlanOutbox(opts = {}, deps = {}) {
   const items = listOutboxItems().filter(
     (item) => opts.outboxId ? item.id === opts.outboxId : true
@@ -4259,7 +4333,7 @@ async function drainPlanOutbox(opts = {}, deps = {}) {
   return result;
 }
 function loadOutboxById(outboxId) {
-  const jsonPath = path16.join(planOutboxDir(), `${outboxId}.json`);
+  const jsonPath = path17.join(planOutboxDir(), `${outboxId}.json`);
   return readOutboxItem(jsonPath);
 }
 
@@ -4359,7 +4433,7 @@ async function dispatchRun(args) {
     const activeHarnessWorkers = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path17.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path18.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker?.taskId || !isPidAlive(worker.pid)) continue;
@@ -4584,7 +4658,7 @@ function redactHarness(text, secret) {
 }
 
 // src/validate.ts
-import path18 from "node:path";
+import path19 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) {
@@ -4598,15 +4672,15 @@ function validateWorkerName(name) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path18.resolve(repo);
+  const resolved = path19.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 = path18.resolve(repoRoot, owned);
-    const rel = path18.relative(repoRoot, resolved);
-    if (rel.startsWith("..") || path18.isAbsolute(rel)) {
+    const resolved = path19.resolve(repoRoot, owned);
+    const rel = path19.relative(repoRoot, resolved);
+    if (rel.startsWith("..") || path19.isAbsolute(rel)) {
       throw new Error(`owned path escapes repo: ${owned}`);
     }
     return resolved;
@@ -4618,14 +4692,93 @@ function validateTailLines(lines) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5 } from "node:fs";
-import path19 from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5 } from "node:fs";
+import path21 from "node:path";
+
+// src/default-repo.ts
+import path20 from "node:path";
+function expandConfiguredRepo(value) {
+  return path20.resolve(resolveUserPath(value.trim()));
+}
+function fromConfigured(value, source, persistedInConfig) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  return {
+    repo: expandConfiguredRepo(trimmed),
+    source,
+    persistedInConfig
+  };
+}
+function resolveDefaultRepo(opts = {}) {
+  const env = opts.env ?? process.env;
+  const config = opts.config ?? loadUserConfig();
+  const fromConfig = fromConfigured(config.defaultRepo, "config", true);
+  if (fromConfig) return fromConfig;
+  const fromDefaultEnv = fromConfigured(env.KYNVER_DEFAULT_REPO, "env_default_repo", false);
+  if (fromDefaultEnv) return fromDefaultEnv;
+  const fromHarnessEnv = fromConfigured(env.KYNVER_HARNESS_REPO, "env_harness_repo", false);
+  if (fromHarnessEnv) return fromHarnessEnv;
+  const discovered = discoverDefaultRepo({
+    cwd: opts.cwd,
+    runtimeModuleUrl: opts.runtimeModuleUrl
+  });
+  if (!discovered) return null;
+  return {
+    repo: discovered.repo,
+    source: discovered.source,
+    persistedInConfig: false
+  };
+}
+function persistDefaultRepo(repo, existing) {
+  const config = {
+    ...existing ?? loadUserConfig(),
+    defaultRepo: redactHomePath(path20.resolve(repo))
+  };
+  saveUserConfig(config);
+  return config;
+}
+function remediateDefaultRepo(opts) {
+  const existing = opts?.config ?? loadUserConfig();
+  const resolved = resolveDefaultRepo({ ...opts, config: existing });
+  if (!resolved) {
+    return {
+      ok: false,
+      reason: "No Kynver git checkout found. Clone the repo, cd into it, then run `kynver setup --repo /path/to/Kynver` (or export KYNVER_DEFAULT_REPO)."
+    };
+  }
+  if (resolved.persistedInConfig) {
+    return { ok: true, resolved, config: existing };
+  }
+  const config = persistDefaultRepo(resolved.repo, existing);
+  return {
+    ok: true,
+    resolved: { ...resolved, persistedInConfig: true, source: "config" },
+    config
+  };
+}
+function formatResolvedDefaultRepo(resolved) {
+  return {
+    defaultRepo: displayUserPath(resolved.repo),
+    source: resolved.source,
+    persistedInConfig: resolved.persistedInConfig
+  };
+}
+
+// src/worktree.ts
+function resolveCreateRunRepo(args) {
+  const explicit = typeof args.repo === "string" ? args.repo.trim() : "";
+  if (explicit) return explicit;
+  const resolved = resolveDefaultRepo();
+  if (resolved) return resolved.repo;
+  required("", "--repo (or set defaultRepo via `kynver setup` / KYNVER_DEFAULT_REPO)");
+  return "";
+}
 function createRun(args) {
-  const repo = validateRepo(required(String(args.repo || ""), "--repo"));
+  const repo = validateRepo(resolveCreateRunRepo(args));
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync14(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync15(dir)) failExists(`run already exists: ${id}`);
   mkdirSync5(dir, { recursive: true });
   const base = String(args.base || "origin/main");
   const baseCommit = git(repo, ["rev-parse", base]).trim();
@@ -4639,12 +4792,12 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path19.join(dir, "run.json"), run);
+  writeJson(path21.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(path19.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
+  const rows = listRunIds(runsDir).map((id) => readJson(path21.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
     id: run.id,
     name: run.name,
     status: run.status,
@@ -4659,7 +4812,7 @@ function failExists(message) {
 }
 
 // src/sweep.ts
-import path20 from "node:path";
+import path22 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -4672,7 +4825,7 @@ async function sweepRun(args) {
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path20.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path22.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
@@ -4716,10 +4869,10 @@ async function sweepRun(args) {
 
 // src/cli.ts
 import { mkdirSync as mkdirSync7, realpathSync } from "node:fs";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/pipeline-tick.ts
-import path30 from "node:path";
+import path32 from "node:path";
 
 // src/pipeline-dispatch.ts
 var RESERVED_REVIEW_STARTS = 1;
@@ -4773,12 +4926,19 @@ async function runPipelineDispatch(args, slots) {
 }
 
 // src/stale-reconcile.ts
-import path22 from "node:path";
+import path24 from "node:path";
 
 // src/finalize.ts
-import path21 from "node:path";
-var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set(["running", "dispatching", "pending", "queued"]);
-function terminalStatusFor(run) {
+import path23 from "node:path";
+var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "running",
+  "dispatching",
+  "pending",
+  "queued",
+  "needs_attention"
+]);
+var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "done"]);
+function deriveTerminalRunStatus(run) {
   const names = Object.keys(run.workers || {});
   if (names.length === 0) return "failed";
   let anyAlive = false;
@@ -4787,7 +4947,7 @@ function terminalStatusFor(run) {
   let anyLandingBlocked = false;
   for (const name of names) {
     const worker = readJson(
-      path21.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path23.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) continue;
@@ -4816,7 +4976,7 @@ function finalizeStaleRuns() {
   const finalized = [];
   for (const run of listRunRecords()) {
     if (!ACTIVE_RUN_STATUSES.has(run.status)) continue;
-    const next = terminalStatusFor(run);
+    const next = deriveTerminalRunStatus(run);
     if (!next || next === run.status) continue;
     const from = run.status;
     run.status = next;
@@ -4839,7 +4999,7 @@ function reconcileStaleWorkers() {
   const now = Date.now();
   for (const run of listRunRecords()) {
     for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path22.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path24.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker || worker.status !== "running") {
         outcomes.push({
@@ -4933,7 +5093,7 @@ function reconcileRunsCli() {
 }
 
 // src/plan-progress-daemon-sync.ts
-import path23 from "node:path";
+import path25 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -4957,7 +5117,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path23.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path25.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -5006,15 +5166,28 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 }
 
 // src/cleanup.ts
-import path28 from "node:path";
+import path30 from "node:path";
 
-// src/cleanup-types.ts
-var DEFAULT_NODE_MODULES_AGE_MS = 6 * 60 * 60 * 1e3;
-var DEFAULT_WORKTREES_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+// src/cleanup-run-liveness.ts
+function isWorkerProcessLive(indexed) {
+  if (indexed.status.alive) return true;
+  if (indexed.worker.status === "running") return true;
+  return false;
+}
+function isRunStaleActive(indexed) {
+  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
+  return deriveTerminalRunStatus(indexed.run) !== null;
+}
+function runBlocksWorktreeRemoval(indexed) {
+  if (isWorkerProcessLive(indexed)) return true;
+  if (indexed.worker.completionBlocker) return true;
+  if (TERMINAL_RUN_STATUSES.has(indexed.run.status)) return false;
+  if (isRunStaleActive(indexed)) return false;
+  if (!isFinishedWorkerStatus(indexed.status)) return true;
+  return deriveTerminalRunStatus(indexed.run) === null;
+}
 
 // src/cleanup-guards.ts
-var ACTIVE_RUN_STATUSES2 = /* @__PURE__ */ new Set(["running", "dispatching", "pending", "queued", "needs_attention"]);
-var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 function prUrlFromFinalResult(finalResult) {
   if (typeof finalResult === "string") {
     const match = finalResult.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/i);
@@ -5036,18 +5209,29 @@ function isPrOrUnmergedWork(status) {
   if (status.changedFiles.length > 0 && status.finalResult) return true;
   return false;
 }
+function materialWorktreeChanges(changedFiles) {
+  return changedFiles.filter((line) => {
+    const trimmed = line.trim();
+    const pathPart = trimmed.startsWith("??") ? trimmed.slice(2).trim() : trimmed.length > 3 ? trimmed.slice(3).trim() : trimmed;
+    return pathPart !== "node_modules" && !pathPart.startsWith("node_modules/");
+  });
+}
+function hasUnrestorableWorktreeChanges(status) {
+  if (materialWorktreeChanges(status.changedFiles).length > 0) return true;
+  if (status.gitAncestry?.relation === "diverged") return true;
+  return false;
+}
 function skipWorktreeRemoval(input) {
   const { indexed, includeOrphans, worktreesAgeMs, ageMs } = input;
   if (worktreesAgeMs <= 0) return "worktrees_disabled";
   if (ageMs < worktreesAgeMs) return "below_age_threshold";
   if (!indexed) return includeOrphans ? null : "orphan_without_flag";
-  if (ACTIVE_RUN_STATUSES2.has(indexed.run.status)) return "run_still_active";
-  if (!TERMINAL_RUN_STATUSES.has(indexed.run.status)) return "run_still_active";
-  if (indexed.status.alive) return "active_worker";
-  if (indexed.worker.status === "running") return "active_worker";
+  if (isWorkerProcessLive(indexed)) return "active_worker";
   if (indexed.worker.completionBlocker) return "completion_blocked";
+  if (runBlocksWorktreeRemoval(indexed)) return "run_still_active";
+  if (!isFinishedWorkerStatus(indexed.status)) return "run_still_active";
   if (isPrOrUnmergedWork(indexed.status)) return "pr_or_unmerged_commits";
-  if (indexed.status.changedFiles.length > 0) return "dirty_worktree";
+  if (materialWorktreeChanges(indexed.status.changedFiles).length > 0) return "dirty_worktree";
   const landing = assessWorkerLanding({
     finalResult: indexed.status.finalResult,
     changedFiles: indexed.status.changedFiles,
@@ -5061,30 +5245,31 @@ function skipNodeModulesRemoval(input) {
   const { indexed, includeOrphans, nodeModulesAgeMs, ageMs } = input;
   if (ageMs < nodeModulesAgeMs) return "below_age_threshold";
   if (!indexed) return includeOrphans ? null : "orphan_without_flag";
-  if (indexed.status.alive) return "active_worker";
-  if (indexed.worker.status === "running") return "active_worker";
+  if (isWorkerProcessLive(indexed)) return "active_worker";
   if (indexed.worker.completionBlocker) return "completion_blocked";
-  if (isPrOrUnmergedWork(indexed.status)) return "pr_or_unmerged_commits";
-  if (indexed.status.changedFiles.length > 0) return "dirty_worktree";
+  if (!isFinishedWorkerStatus(indexed.status)) return "run_still_active";
+  if (hasUnrestorableWorktreeChanges(indexed.status)) return "dirty_worktree";
   const landing = assessWorkerLanding({
     finalResult: indexed.status.finalResult,
     changedFiles: indexed.status.changedFiles,
     gitAncestry: indexed.status.gitAncestry,
     prUrl: prUrlFromFinalResult(indexed.status.finalResult)
   });
-  if (landing.blocked) return "landing_blocked";
+  if (landing.blocked && materialWorktreeChanges(indexed.status.changedFiles).length > 0) {
+    return "landing_blocked";
+  }
   return null;
 }
 
 // src/cleanup-execute.ts
-import { existsSync as existsSync16, rmSync } from "node:fs";
-import path25 from "node:path";
+import { existsSync as existsSync17, rmSync } from "node:fs";
+import path27 from "node:path";
 
 // src/cleanup-dir-size.ts
-import { existsSync as existsSync15, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
-import path24 from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
+import path26 from "node:path";
 function directorySizeBytes(root, maxEntries = 5e4) {
-  if (!existsSync15(root)) return 0;
+  if (!existsSync16(root)) return 0;
   let total = 0;
   let seen = 0;
   const stack = [root];
@@ -5098,7 +5283,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path24.join(current, name);
+      const full = path26.join(current, name);
       let st;
       try {
         st = statSync2(full);
@@ -5114,7 +5299,7 @@ function directorySizeBytes(root, maxEntries = 5e4) {
 
 // src/cleanup-execute.ts
 function removeNodeModules(candidate, execute) {
-  if (!existsSync16(candidate.path)) {
+  if (!existsSync17(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -5145,7 +5330,7 @@ function removeNodeModules(candidate, execute) {
   }
 }
 function removeWorktree(candidate, execute) {
-  if (!existsSync16(candidate.path)) {
+  if (!existsSync17(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -5162,7 +5347,7 @@ function removeWorktree(candidate, execute) {
     if (repo) {
       git(repo, ["worktree", "remove", "--force", candidate.path], { allowFailure: true });
     }
-    if (existsSync16(candidate.path)) {
+    if (existsSync17(candidate.path)) {
       rmSync(candidate.path, { recursive: true, force: true });
     }
     return {
@@ -5182,20 +5367,20 @@ function removeWorktree(candidate, execute) {
   }
 }
 function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path25.resolve(targetPath);
-  const nm = resolved.endsWith(`${path25.sep}node_modules`) ? resolved : null;
+  const resolved = path27.resolve(targetPath);
+  const nm = resolved.endsWith(`${path27.sep}node_modules`) ? resolved : null;
   if (!nm) return "path_outside_harness";
-  const rel = path25.relative(worktreesDir, nm);
-  if (rel.startsWith("..") || path25.isAbsolute(rel)) return "path_outside_harness";
-  const parts = rel.split(path25.sep);
+  const rel = path27.relative(worktreesDir, nm);
+  if (rel.startsWith("..") || path27.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path27.sep);
   if (parts.length < 3 || parts[parts.length - 1] !== "node_modules") return "path_outside_harness";
-  if (!resolved.startsWith(path25.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path27.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 
 // src/cleanup-scan.ts
-import { existsSync as existsSync17, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
-import path26 from "node:path";
+import { existsSync as existsSync18, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import path28 from "node:path";
 function pathAgeMs(target, now) {
   try {
     const mtime = statSync3(target).mtimeMs;
@@ -5205,17 +5390,17 @@ function pathAgeMs(target, now) {
   }
 }
 function isPathInside(child, parent) {
-  const rel = path26.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path26.isAbsolute(rel);
+  const rel = path28.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path28.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 = path26.join(entry.worktreePath, "node_modules");
-    if (!existsSync17(nm)) continue;
-    const resolved = path26.resolve(nm);
+    const nm = path28.join(entry.worktreePath, "node_modules");
+    if (!existsSync18(nm)) continue;
+    const resolved = path28.resolve(nm);
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     candidates.push({
@@ -5228,16 +5413,16 @@ function scanNodeModulesCandidates(opts) {
       ageMs: pathAgeMs(resolved, opts.now)
     });
   }
-  if (!opts.includeOrphans || !existsSync17(opts.worktreesDir)) return candidates;
+  if (!opts.includeOrphans || !existsSync18(opts.worktreesDir)) return candidates;
   for (const runEntry of readdirSync6(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path26.join(opts.worktreesDir, runEntry.name);
+    const runPath = path28.join(opts.worktreesDir, runEntry.name);
     for (const workerEntry of readdirSync6(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path26.join(runPath, workerEntry.name);
-      const nm = path26.join(worktreePath, "node_modules");
-      if (!existsSync17(nm)) continue;
-      const resolved = path26.resolve(nm);
+      const worktreePath = path28.join(runPath, workerEntry.name);
+      const nm = path28.join(worktreePath, "node_modules");
+      if (!existsSync18(nm)) continue;
+      const resolved = path28.resolve(nm);
       if (seen.has(resolved)) continue;
       if (!isPathInside(resolved, opts.harnessRoot)) continue;
       seen.add(resolved);
@@ -5260,7 +5445,7 @@ function scanWorktreeCandidates(opts) {
   for (const entry of opts.index.values()) {
     if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
     const resolved = entry.worktreePath;
-    if (!existsSync17(resolved)) continue;
+    if (!existsSync18(resolved)) continue;
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     candidates.push({
@@ -5277,17 +5462,17 @@ function scanWorktreeCandidates(opts) {
 }
 
 // src/cleanup-worktree-index.ts
-import path27 from "node:path";
+import path29 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 = path27.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path29.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(path27.resolve(worker.worktreePath), {
-        worktreePath: path27.resolve(worker.worktreePath),
+      index.set(path29.resolve(worker.worktreePath), {
+        worktreePath: path29.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -5299,59 +5484,109 @@ function buildWorktreeIndex() {
   return index;
 }
 
-// src/cleanup.ts
-function resolveOptions(options = {}) {
-  const harnessRoot = options.harnessRoot ? resolveUserPath(options.harnessRoot) : resolveHarnessRoot();
-  const { worktreesDir } = options.harnessRoot ? { worktreesDir: path28.join(harnessRoot, "worktrees") } : getHarnessPaths();
-  const execute = options.execute === true;
-  const nodeModulesAgeMs = options.nodeModulesAgeMs ?? DEFAULT_NODE_MODULES_AGE_MS;
-  const worktreesAgeMs = options.worktreesAgeMs ?? 0;
-  const includeOrphans = options.includeOrphans === true;
-  const runIdFilter = options.runIdFilter ? String(options.runIdFilter) : void 0;
-  const now = options.now ?? Date.now();
+// src/cleanup-types.ts
+var DEFAULT_NODE_MODULES_AGE_MS = 6 * 60 * 60 * 1e3;
+var DEFAULT_WORKTREES_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+
+// src/cleanup-retention-config.ts
+function envFlag(name) {
+  const v = process.env[name];
+  return v === "1" || v === "true" || v === "yes";
+}
+function envMs(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function resolveHarnessRetention(options = {}) {
+  const execute = options.execute === true || options.execute !== false && envFlag("KYNVER_CLEANUP_EXECUTE");
+  const finalizeStaleRuns2 = options.finalizeStaleRuns !== false && !envFlag("KYNVER_CLEANUP_SKIP_FINALIZE");
+  const nodeModulesAgeMs = options.nodeModulesAgeMs ?? envMs("KYNVER_CLEANUP_NODE_MODULES_AGE_MS", DEFAULT_NODE_MODULES_AGE_MS);
+  const worktreesAgeMs = options.worktreesAgeMs ?? envMs("KYNVER_CLEANUP_WORKTREES_AGE_MS", 0);
+  const includeOrphans = options.includeOrphans === true || envFlag("KYNVER_CLEANUP_INCLUDE_ORPHANS");
+  const scopeAll = envFlag("KYNVER_CLEANUP_SCOPE_ALL") || process.env.KYNVER_CLEANUP_SCOPE === "all";
+  const runIdFilter = scopeAll ? options.runIdFilter : options.runIdFilter ?? (process.env.KYNVER_CLEANUP_RUN_ID || void 0);
+  const accountBytes = options.accountBytes !== false && !envFlag("KYNVER_CLEANUP_SKIP_BYTE_ACCOUNTING");
   return {
-    harnessRoot,
-    worktreesDir,
     execute,
-    dryRun: !execute,
+    finalizeStaleRuns: finalizeStaleRuns2,
     nodeModulesAgeMs,
-    worktreesAgeMs,
+    worktreesAgeMs: worktreesAgeMs > 0 ? worktreesAgeMs : 0,
     includeOrphans,
-    runIdFilter,
-    now
+    runIdFilter: runIdFilter ? String(runIdFilter) : void 0,
+    accountBytes
   };
 }
+function resolvePipelineHarnessRetention(runId) {
+  const scopeAll = process.env.KYNVER_CLEANUP_SCOPE === "all";
+  const envWorktrees = Number(process.env.KYNVER_CLEANUP_WORKTREES_AGE_MS);
+  const worktreesAgeMs = scopeAll ? Number.isFinite(envWorktrees) && envWorktrees > 0 ? envWorktrees : DEFAULT_WORKTREES_AGE_MS : Number.isFinite(envWorktrees) && envWorktrees > 0 ? envWorktrees : 0;
+  return resolveHarnessRetention({
+    runIdFilter: scopeAll ? void 0 : runId,
+    worktreesAgeMs,
+    finalizeStaleRuns: true,
+    accountBytes: true
+  });
+}
+
+// src/cleanup.ts
+function resolvePaths(options = {}) {
+  const harnessRoot = options.harnessRoot ? resolveUserPath(options.harnessRoot) : resolveHarnessRoot();
+  const { worktreesDir } = options.harnessRoot ? { worktreesDir: path30.join(harnessRoot, "worktrees") } : getHarnessPaths();
+  const now = options.now ?? Date.now();
+  return { harnessRoot, worktreesDir, now };
+}
 function recordSkip(skips, pathValue, reason, detail) {
   skips.push({ path: pathValue, reason, ...detail ? { detail } : {} });
 }
+function attachCandidateBytes(candidate, accountBytes) {
+  if (!accountBytes || candidate.bytes != null) return candidate;
+  return { ...candidate, bytes: directorySizeBytes(candidate.path) };
+}
+function tallySkipReasons(actions, skips) {
+  const counts = {};
+  for (const skip of skips) {
+    counts[skip.reason] = (counts[skip.reason] ?? 0) + 1;
+  }
+  for (const action of actions) {
+    if (action.skipReason) {
+      counts[action.skipReason] = (counts[action.skipReason] ?? 0) + 1;
+    }
+  }
+  return counts;
+}
 function runHarnessCleanup(options = {}) {
-  const resolved = resolveOptions(options);
+  const retention = resolveHarnessRetention(options);
+  const paths = resolvePaths(options);
+  const finalizedRuns = retention.finalizeStaleRuns ? finalizeStaleRuns().map((f) => ({ runId: f.runId, from: f.from, to: f.to })) : [];
   const index = buildWorktreeIndex();
   const scanOpts = {
-    harnessRoot: resolved.harnessRoot,
-    worktreesDir: resolved.worktreesDir,
-    nodeModulesAgeMs: resolved.nodeModulesAgeMs,
-    worktreesAgeMs: resolved.worktreesAgeMs,
-    includeOrphans: resolved.includeOrphans,
-    runIdFilter: resolved.runIdFilter,
+    harnessRoot: paths.harnessRoot,
+    worktreesDir: paths.worktreesDir,
+    nodeModulesAgeMs: retention.nodeModulesAgeMs,
+    worktreesAgeMs: retention.worktreesAgeMs,
+    includeOrphans: retention.includeOrphans,
+    runIdFilter: retention.runIdFilter,
     index,
-    now: resolved.now
+    now: paths.now
   };
   const skips = [];
   const actions = [];
-  for (const candidate of scanNodeModulesCandidates(scanOpts)) {
-    const pathSkip = isHarnessNodeModulesPath(candidate.path, resolved.harnessRoot, resolved.worktreesDir);
+  for (const raw of scanNodeModulesCandidates(scanOpts)) {
+    const candidate = attachCandidateBytes(raw, retention.accountBytes);
+    const pathSkip = isHarnessNodeModulesPath(candidate.path, paths.harnessRoot, paths.worktreesDir);
     if (pathSkip) {
       recordSkip(skips, candidate.path, pathSkip);
       actions.push({ ...candidate, executed: false, skipped: true, skipReason: pathSkip });
       continue;
     }
-    const worktreePath = path28.resolve(candidate.path, "..");
+    const worktreePath = path30.resolve(candidate.path, "..");
     const indexed = index.get(worktreePath) ?? null;
     const guardReason = skipNodeModulesRemoval({
       indexed,
-      includeOrphans: resolved.includeOrphans,
-      nodeModulesAgeMs: resolved.nodeModulesAgeMs,
+      includeOrphans: retention.includeOrphans,
+      nodeModulesAgeMs: retention.nodeModulesAgeMs,
       ageMs: candidate.ageMs
     });
     if (guardReason) {
@@ -5359,14 +5594,15 @@ function runHarnessCleanup(options = {}) {
       actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
       continue;
     }
-    actions.push(removeNodeModules(candidate, resolved.execute));
+    actions.push(removeNodeModules(candidate, retention.execute));
   }
-  for (const candidate of scanWorktreeCandidates(scanOpts)) {
-    const indexed = index.get(path28.resolve(candidate.path)) ?? null;
+  for (const raw of scanWorktreeCandidates(scanOpts)) {
+    const candidate = attachCandidateBytes(raw, retention.accountBytes);
+    const indexed = index.get(path30.resolve(candidate.path)) ?? null;
     const guardReason = skipWorktreeRemoval({
       indexed,
-      includeOrphans: resolved.includeOrphans,
-      worktreesAgeMs: resolved.worktreesAgeMs,
+      includeOrphans: retention.includeOrphans,
+      worktreesAgeMs: retention.worktreesAgeMs,
       ageMs: candidate.ageMs
     });
     if (guardReason) {
@@ -5374,51 +5610,55 @@ function runHarnessCleanup(options = {}) {
       actions.push({ ...candidate, executed: false, skipped: true, skipReason: guardReason });
       continue;
     }
-    actions.push(removeWorktree(candidate, resolved.execute));
+    actions.push(removeWorktree(candidate, retention.execute));
   }
   let candidateBytes = 0;
+  let reclaimableBytes = 0;
   let removedBytes = 0;
   let removedPaths = 0;
   let skippedPaths = 0;
   for (const action of actions) {
     if (action.bytes) candidateBytes += action.bytes;
+    if (!action.skipped && !action.executed && action.bytes) reclaimableBytes += action.bytes;
     if (action.executed) {
       removedPaths += 1;
       removedBytes += action.bytes ?? 0;
     } else if (action.skipped) {
       skippedPaths += 1;
+      if (action.skipReason === "dry_run" && action.bytes) reclaimableBytes += action.bytes;
     }
   }
   return {
-    harnessRoot: resolved.harnessRoot,
-    dryRun: resolved.dryRun,
-    execute: resolved.execute,
-    nodeModulesAgeMs: resolved.nodeModulesAgeMs,
-    worktreesAgeMs: resolved.worktreesAgeMs,
-    includeOrphans: resolved.includeOrphans,
-    scannedAt: new Date(resolved.now).toISOString(),
+    harnessRoot: paths.harnessRoot,
+    dryRun: !retention.execute,
+    execute: retention.execute,
+    nodeModulesAgeMs: retention.nodeModulesAgeMs,
+    worktreesAgeMs: retention.worktreesAgeMs,
+    includeOrphans: retention.includeOrphans,
+    scannedAt: new Date(paths.now).toISOString(),
+    finalizedRuns,
     actions,
     skips,
     totals: {
       candidateBytes,
+      reclaimableBytes,
       removedBytes,
       removedPaths,
-      skippedPaths
+      skippedPaths,
+      skipReasons: tallySkipReasons(actions, skips)
     }
   };
 }
 function runPipelineHarnessCleanup(runId) {
-  const nodeModulesAgeMs = Number(process.env.KYNVER_CLEANUP_NODE_MODULES_AGE_MS) || DEFAULT_NODE_MODULES_AGE_MS;
-  const worktreesAgeMs = Number(process.env.KYNVER_CLEANUP_WORKTREES_AGE_MS) || 0;
-  const execute = process.env.KYNVER_CLEANUP_EXECUTE === "1";
-  const includeOrphans = process.env.KYNVER_CLEANUP_INCLUDE_ORPHANS === "1";
-  const scopeAll = process.env.KYNVER_CLEANUP_SCOPE === "all";
+  const retention = resolvePipelineHarnessRetention(runId);
   return runHarnessCleanup({
-    execute,
-    nodeModulesAgeMs,
-    worktreesAgeMs,
-    includeOrphans,
-    runIdFilter: scopeAll ? void 0 : runId
+    execute: retention.execute,
+    finalizeStaleRuns: retention.finalizeStaleRuns,
+    accountBytes: retention.accountBytes,
+    nodeModulesAgeMs: retention.nodeModulesAgeMs,
+    worktreesAgeMs: retention.worktreesAgeMs,
+    includeOrphans: retention.includeOrphans,
+    runIdFilter: retention.runIdFilter
   });
 }
 function isPipelineCleanupEnabled() {
@@ -5427,8 +5667,8 @@ function isPipelineCleanupEnabled() {
 
 // src/installed-package-versions.ts
 import { readFile } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import path29 from "node:path";
+import { homedir as homedir6 } from "node:os";
+import path31 from "node:path";
 var MANAGED_PACKAGES = [
   "@kynver-app/runtime",
   "@kynver-app/openclaw-agent-os",
@@ -5442,13 +5682,13 @@ function unique(values) {
   return [...new Set(values.filter((value) => Boolean(value)))];
 }
 function moduleRoots() {
-  const home = homedir5();
-  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path29.join(home, ".openclaw", "npm");
-  const npmGlobalRoot = trim(process.env.KYNVER_NPM_GLOBAL_ROOT) ?? trim(process.env.KYNVER_NPM_GLOBAL_MODULES_ROOT) ?? (trim(process.env.NPM_CONFIG_PREFIX) ? path29.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path29.join(home, ".npm-global", "lib", "node_modules"));
+  const home = homedir6();
+  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path31.join(home, ".openclaw", "npm");
+  const npmGlobalRoot = trim(process.env.KYNVER_NPM_GLOBAL_ROOT) ?? trim(process.env.KYNVER_NPM_GLOBAL_MODULES_ROOT) ?? (trim(process.env.NPM_CONFIG_PREFIX) ? path31.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path31.join(home, ".npm-global", "lib", "node_modules"));
   return unique([
-    path29.join(openClawPrefix, "lib", "node_modules"),
-    path29.join(openClawPrefix, "node_modules"),
-    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path29.join(npmGlobalRoot, "lib", "node_modules")
+    path31.join(openClawPrefix, "lib", "node_modules"),
+    path31.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path31.join(npmGlobalRoot, "lib", "node_modules")
   ]);
 }
 async function readVersion(packageJsonPath) {
@@ -5464,7 +5704,7 @@ async function collectInstalledPackageVersions(observedAt = (/* @__PURE__ */ new
   const out = {};
   for (const packageName of MANAGED_PACKAGES) {
     for (const root of roots) {
-      const packageJsonPath = path29.join(root, packageName, "package.json");
+      const packageJsonPath = path31.join(root, packageName, "package.json");
       const version = await readVersion(packageJsonPath);
       if (!version) continue;
       out[packageName] = { version, observedAt, path: packageJsonPath };
@@ -5480,7 +5720,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path30.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path32.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -5622,7 +5862,7 @@ async function runDaemon(args) {
 }
 
 // src/plan-progress.ts
-import path31 from "node:path";
+import path33 from "node:path";
 
 // src/bounded-build/constants.ts
 var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
@@ -5908,7 +6148,7 @@ async function emitPlanProgress(args) {
 }
 function verifyPlanLocal(args) {
   const worktree = required(args.worktree ? String(args.worktree) : void 0, "worktree");
-  const cwd = path31.resolve(worktree);
+  const cwd = path33.resolve(worktree);
   const summary = runHarnessVerifyCommands(cwd);
   const emitJson = args.json === true || args.json === "true";
   const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
@@ -5957,9 +6197,9 @@ async function verifyPlan(args) {
 }
 
 // src/harness-verify-cli.ts
-import path32 from "node:path";
+import path34 from "node:path";
 function runHarnessVerifyCli(args) {
-  const cwd = path32.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const cwd = path34.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
   const emitJson = args.json === true || args.json === "true" || args.emitJson === true || args.emitJson === "true";
   const commands = [];
   const rawCmd = args.command;
@@ -6003,7 +6243,7 @@ function runHarnessVerifyCli(args) {
 }
 
 // src/plan-persist-cli.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 var OPERATIONS = ["create", "add_version", "update_metadata"];
 var FAILURE_KINDS = [
   "approval_guard",
@@ -6015,7 +6255,7 @@ var FAILURE_KINDS = [
 function readBodyArg(args) {
   const bodyFile = args.bodyFile ? String(args.bodyFile) : void 0;
   if (bodyFile) {
-    return { body: readFileSync8(bodyFile, "utf8"), bodyPathHint: bodyFile };
+    return { body: readFileSync9(bodyFile, "utf8"), bodyPathHint: bodyFile };
   }
   const inline = args.body ? String(args.body) : void 0;
   if (inline) return { body: inline };
@@ -6085,12 +6325,14 @@ async function runPlanOutboxDrain(args) {
 // src/cleanup-cli.ts
 function runCleanupCli(args) {
   const execute = args.execute === true || args.execute === "true";
+  const skipFinalize = args.skipFinalize === true || args.skipFinalize === "true";
   const nodeModulesAgeMs = args.nodeModulesAgeMs ? Number(args.nodeModulesAgeMs) : DEFAULT_NODE_MODULES_AGE_MS;
   const worktreesAgeMs = args.worktreesAgeMs ? Number(args.worktreesAgeMs) : 0;
   const includeOrphans = args.includeOrphans === true || args.includeOrphans === "true";
   const harnessRoot = args.harnessRoot ? String(args.harnessRoot) : void 0;
   const summary = runHarnessCleanup({
     execute,
+    finalizeStaleRuns: !skipFinalize,
     nodeModulesAgeMs: Number.isFinite(nodeModulesAgeMs) ? nodeModulesAgeMs : DEFAULT_NODE_MODULES_AGE_MS,
     worktreesAgeMs: Number.isFinite(worktreesAgeMs) ? worktreesAgeMs : 0,
     includeOrphans,
@@ -6103,7 +6345,7 @@ function runCleanupCli(args) {
 }
 
 // src/monitor/monitor.service.ts
-import path34 from "node:path";
+import path36 from "node:path";
 
 // src/monitor/monitor.classify.ts
 function expectedLeaseOwner(runId) {
@@ -6159,11 +6401,11 @@ function classifyWorkerHealth(input) {
 }
 
 // src/monitor/monitor.store.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync6, readdirSync as readdirSync7, unlinkSync as unlinkSync2 } from "node:fs";
-import path33 from "node:path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync6, readdirSync as readdirSync7, unlinkSync as unlinkSync2 } from "node:fs";
+import path35 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path33.join(harnessRoot, "monitors");
+  const dir = path35.join(harnessRoot, "monitors");
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
@@ -6171,7 +6413,7 @@ function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path33.join(monitorsDir(), `${monitorId}.json`);
+  return path35.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -6181,18 +6423,18 @@ function saveMonitorSession(session) {
 }
 function deleteMonitorSession(monitorId) {
   const file = monitorPath(monitorId);
-  if (!existsSync18(file)) return false;
+  if (!existsSync19(file)) return false;
   unlinkSync2(file);
   return true;
 }
 function listMonitorSessions() {
   const dir = monitorsDir();
-  if (!existsSync18(dir)) return [];
+  if (!existsSync19(dir)) return [];
   const entries = [];
   for (const name of readdirSync7(dir)) {
     if (!name.endsWith(".json")) continue;
     const session = readJson(
-      path33.join(dir, name),
+      path35.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -6283,7 +6525,7 @@ async function fetchTaskLeasesForWorkers(input) {
 // src/monitor/monitor.service.ts
 function workerRecord2(runId, name) {
   return readJson(
-    path34.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path36.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -6485,18 +6727,18 @@ async function runMonitorLoop(args) {
 
 // src/monitor/monitor-spawn.ts
 import { spawn as spawn4 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync19, openSync as openSync4 } from "node:fs";
-import path35 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { closeSync as closeSync4, existsSync as existsSync20, openSync as openSync4 } from "node:fs";
+import path37 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path35.join(fileURLToPath3(new URL(".", import.meta.url)), "..", "cli.js");
+  return path37.join(fileURLToPath4(new URL(".", import.meta.url)), "..", "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
-  if (!existsSync19(cliPath)) return void 0;
+  if (!existsSync20(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path35.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path37.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
     logFd = openSync4(logPath, "a");
@@ -6616,12 +6858,12 @@ async function monitorTickCli(args) {
 }
 
 // src/doctor/runtime-takeover.ts
-import path37 from "node:path";
+import path39 from "node:path";
 
 // src/doctor/runtime-takeover.probes.ts
-import { accessSync, constants, existsSync as existsSync20, readFileSync as readFileSync9 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import path36 from "node:path";
+import { accessSync, constants, existsSync as existsSync21, readFileSync as readFileSync10 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import path38 from "node:path";
 import { spawnSync as spawnSync6 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
@@ -6650,7 +6892,7 @@ function tokenPrefix(token) {
   return trimmed.length <= 12 ? `${trimmed}\u2026` : `${trimmed.slice(0, 12)}\u2026`;
 }
 function isWritable(target) {
-  if (!existsSync20(target)) return false;
+  if (!existsSync21(target)) return false;
   try {
     accessSync(target, constants.W_OK);
     return true;
@@ -6663,15 +6905,15 @@ var defaultRuntimeTakeoverProbes = {
   commandOnPath: (bin) => captureCommand(process.platform === "win32" ? "where" : "which", [bin]),
   kynverVersion: (bin) => captureCommand(bin, ["--version"]),
   loadConfig: () => loadUserConfig(),
-  configFilePath: () => path36.join(homedir6(), ".kynver", "config.json"),
-  credentialsFilePath: () => path36.join(homedir6(), ".kynver", "credentials"),
+  configFilePath: () => path38.join(homedir7(), ".kynver", "config.json"),
+  credentialsFilePath: () => path38.join(homedir7(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path36.join(homedir6(), ".kynver", "credentials");
-    if (!existsSync20(credPath)) {
+    const credPath = path38.join(homedir7(), ".kynver", "credentials");
+    if (!existsSync21(credPath)) {
       return { hasApiKey: false };
     }
     try {
-      const parsed = JSON.parse(readFileSync9(credPath, "utf8"));
+      const parsed = JSON.parse(readFileSync10(credPath, "utf8"));
       return {
         hasApiKey: Boolean(parsed.apiKey?.trim()),
         runnerTokenPrefix: tokenPrefix(parsed.runnerToken),
@@ -6697,8 +6939,8 @@ var defaultRuntimeTakeoverProbes = {
     })()
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path36.join(homedir6(), ".openclaw", "harness"),
-  pathExists: (target) => existsSync20(target),
+  legacyOpenclawHarnessRoot: () => path38.join(homedir7(), ".openclaw", "harness"),
+  pathExists: (target) => existsSync21(target),
   pathWritable: (target) => isWritable(target),
   vercelVersion: () => captureCommand("vercel", ["--version"]),
   vercelWhoami: () => captureCommand("vercel", ["whoami"])
@@ -6713,8 +6955,36 @@ function assessRuntimeTakeoverScheduler(env, ctx) {
   const runnerQstash = env.kynverSchedulerProvider === "qstash";
   const hostedDeployment = Boolean(env.qstashTokenPresent) || Boolean(env.kynverHostedDeployment);
   const daemonDispatchReady = Boolean(ctx.agentOsId?.trim()) && Boolean(ctx.apiBaseUrl?.trim()) && ctx.hasScopedRunnerToken;
-  const deploymentNeedsQstash = hostedDeployment && !env.qstashTokenPresent && env.kynverSchedulerProvider !== "qstash";
-  const deploymentOpenclaw = hostedDeployment && env.kynverSchedulerProvider === "openclaw-cron";
+  const hostedSchedulerProcess = hostedDeployment && !daemonDispatchReady;
+  const deploymentNeedsQstash = hostedSchedulerProcess && !env.qstashTokenPresent && env.kynverSchedulerProvider !== "qstash";
+  const deploymentOpenclaw = hostedSchedulerProcess && env.kynverSchedulerProvider === "openclaw-cron";
+  if (daemonDispatchReady && runnerOpenclaw) {
+    return check({
+      id: "hotspot_openclaw_scheduler",
+      label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
+      status: "warn",
+      summary: "KYNVER_SCHEDULER_PROVIDER=openclaw-cron on this runner \u2014 dispatch is owned by kynver daemon; unset the OpenClaw override",
+      remediation: "Unset KYNVER_SCHEDULER_PROVIDER on user runners. Use `kynver daemon` (pipeline-tick \u2192 operator/tick). On the Kynver server set KYNVER_SCHEDULER_PROVIDER=qstash when QStash is configured.",
+      details: {
+        schedulerProvider: env.kynverSchedulerProvider ?? null,
+        dispatchPath: "kynver-daemon-pipeline-tick",
+        hostedDeployment
+      }
+    });
+  }
+  if (daemonDispatchReady) {
+    return check({
+      id: "hotspot_openclaw_scheduler",
+      label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
+      status: "pass",
+      summary: runnerQstash ? "Runner override qstash present; hosted dispatch still owned by kynver daemon pipeline-tick" : "Hosted dispatch owned by kynver daemon (pipeline-tick \u2192 operator/tick); no OpenClaw cron on runner",
+      details: {
+        schedulerProvider: env.kynverSchedulerProvider ?? null,
+        dispatchPath: "kynver-daemon-pipeline-tick",
+        hostedDeployment
+      }
+    });
+  }
   if (runnerOpenclaw) {
     return check({
       id: "hotspot_openclaw_scheduler",
@@ -6730,7 +7000,7 @@ function assessRuntimeTakeoverScheduler(env, ctx) {
       id: "hotspot_openclaw_scheduler",
       label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
       status: "warn",
-      summary: deploymentOpenclaw ? "Hosted deployment has KYNVER_SCHEDULER_PROVIDER=openclaw-cron \u2014 AgentOS scheduled ticks should use QStash" : "Hosted deployment without QSTASH_TOKEN \u2014 scheduler may fall back to openclaw-cron",
+      summary: deploymentOpenclaw ? "Hosted deployment has KYNVER_SCHEDULER_PROVIDER=openclaw-cron \u2014 AgentOS scheduled ticks should use QStash" : env.kynverSchedulerProvider ? `Hosted deployment without QSTASH_TOKEN (KYNVER_SCHEDULER_PROVIDER=${env.kynverSchedulerProvider}) \u2014 scheduler may fall back to openclaw-cron` : "KYNVER_SCHEDULER_PROVIDER unset on hosted deployment; without QSTASH_TOKEN the server may fall back to openclaw-cron",
       remediation: "Set QSTASH_TOKEN and KYNVER_SCHEDULER_PROVIDER=qstash on the Kynver server. User runners use `kynver daemon` for dispatch and should not set a scheduler provider.",
       details: {
         schedulerProvider: env.kynverSchedulerProvider ?? null,
@@ -6739,15 +7009,15 @@ function assessRuntimeTakeoverScheduler(env, ctx) {
       }
     });
   }
-  if (daemonDispatchReady) {
+  if (hostedDeployment && env.qstashTokenPresent && !env.kynverSchedulerProvider) {
     return check({
       id: "hotspot_openclaw_scheduler",
       label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
       status: "pass",
-      summary: runnerQstash ? "Runner override qstash present; hosted dispatch still owned by kynver daemon pipeline-tick" : "Hosted dispatch owned by kynver daemon (pipeline-tick \u2192 operator/tick); no OpenClaw cron on runner",
+      summary: "QSTASH_TOKEN present; hosted scheduler auto-selects qstash (explicit KYNVER_SCHEDULER_PROVIDER=qstash optional)",
       details: {
-        schedulerProvider: env.kynverSchedulerProvider ?? null,
-        dispatchPath: "kynver-daemon-pipeline-tick",
+        schedulerProvider: null,
+        qstashTokenPresent: true,
         hostedDeployment
       }
     });
@@ -6841,8 +7111,14 @@ function assessUserConfig(probes) {
   if (exists) {
     const apiBaseUrl = config.apiBaseUrl?.trim();
     const agentOsId = config.agentOsId?.trim();
-    const defaultRepo = config.defaultRepo?.trim();
-    const displayDefaultRepo = defaultRepo ? displayUserPath(defaultRepo) : null;
+    const resolvedDefaultRepo = resolveDefaultRepo({ config });
+    const formatted = resolvedDefaultRepo ? formatResolvedDefaultRepo(resolvedDefaultRepo) : null;
+    let defaultRepoRemediation;
+    if (!resolvedDefaultRepo) {
+      defaultRepoRemediation = "Run `kynver setup` from a Kynver checkout (auto-discovers repo) or `kynver setup --repo /path/to/Kynver`.";
+    } else if (!resolvedDefaultRepo.persistedInConfig) {
+      defaultRepoRemediation = "Run `kynver setup` (no --repo) to persist discovered defaultRepo in ~/.kynver/config.json.";
+    }
     checks.push(
       check2({
         id: "config_api_base_url",
@@ -6863,11 +7139,13 @@ function assessUserConfig(probes) {
       check2({
         id: "config_default_repo",
         label: "Default repo path",
-        status: defaultRepo ? "pass" : "warn",
-        summary: displayDefaultRepo ?? "Not set (pass --repo on `kynver run create`)",
-        remediation: defaultRepo ? void 0 : "Set `defaultRepo` via `kynver setup --repo /path/to/repo`.",
+        status: resolvedDefaultRepo ? "pass" : "warn",
+        summary: resolvedDefaultRepo ? `${formatted.defaultRepo} (${resolvedDefaultRepo.source}${resolvedDefaultRepo.persistedInConfig ? "" : ", not persisted"})` : "Not set (pass --repo on `kynver run create` or run `kynver setup` to auto-discover)",
+        remediation: defaultRepoRemediation,
         details: {
-          defaultRepo: displayDefaultRepo,
+          defaultRepo: formatted?.defaultRepo ?? null,
+          source: formatted?.source ?? null,
+          persistedInConfig: formatted?.persistedInConfig ?? false,
           harnessRoot: config.harnessRoot ? redactHomePath(config.harnessRoot) : null
         }
       })
@@ -6949,8 +7227,8 @@ function assessVercelCli(probes) {
 }
 function assessHarnessDirs(probes) {
   const harnessRoot = probes.harnessRoot();
-  const runsDir = path37.join(harnessRoot, "runs");
-  const worktreesDir = path37.join(harnessRoot, "worktrees");
+  const runsDir = path39.join(harnessRoot, "runs");
+  const worktreesDir = path39.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -7153,9 +7431,9 @@ function usage(code = 0) {
       "Usage:",
       "  kynver login --api-key KEY",
       "  kynver runner credential [--agent-os-id ID] [--base-url URL]",
-      "  kynver setup [--api-base-url URL] [--agent-os-id ID] [--agent-os-slug SLUG] [--repo PATH] [--max-workers N] [--provider claude|cursor]",
+      "  kynver setup [--api-base-url URL] [--agent-os-id ID] [--agent-os-slug SLUG] [--repo PATH] [--discover-repo] [--max-workers N] [--provider claude|cursor]",
       "  kynver daemon --run RUN_ID --agent-os-id AOS_ID [--execute] [--interval-ms MS]",
-      "  kynver run create --repo /path/repo [--name name] [--base origin/main]",
+      "  kynver run create [--repo /path/repo] [--name name] [--base origin/main]",
       "  kynver run list",
       "  kynver run status --run RUN_ID",
       "  kynver run dispatch --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--execute] [--lane any|implementation|review|landing] [--target-task-id TASK_ID] [--executor harness] [--max-starts 1] [--lease-ms MS] [--owned path[,path]] [--model claude-opus-4-8] [--disk-path /]",
@@ -7173,7 +7451,7 @@ function usage(code = 0) {
       "  kynver plan persist --operation create|add_version|update_metadata --title TITLE (--body-file PATH | --body TEXT) [--slug SLUG] [--plan PLAN_ID] [--summary TEXT] [--failure-kind approval_guard|auth|network|server|tool_interruption]",
       "  kynver plan outbox list",
       "  kynver plan outbox drain [--max N] [--id OUTBOX_ID]",
-      "  kynver cleanup [--execute] [--node-modules-age-ms MS] [--worktrees-age-ms MS] [--harness-root PATH] [--include-orphans]",
+      "  kynver cleanup [--execute] [--node-modules-age-ms MS] [--worktrees-age-ms MS] [--harness-root PATH] [--include-orphans] [--skip-finalize]",
       "  kynver monitor start --run RUN_ID [--name worker] [--agent-os-id AOS_ID] [--poll-ms MS]",
       "  kynver monitor status [--run RUN_ID] [--name worker] [--tick]",
       "  kynver monitor stop --run RUN_ID [--name worker]",
@@ -7248,7 +7526,7 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "monitor" && action === "run-loop") return void await monitorRunLoopCli(args);
   unknownCommand(scope, action);
 }
-var isCliEntry = process.argv[1] && realpathSync.native(process.argv[1]) === realpathSync.native(fileURLToPath4(import.meta.url));
+var isCliEntry = process.argv[1] && realpathSync.native(process.argv[1]) === realpathSync.native(fileURLToPath5(import.meta.url));
 if (isCliEntry) {
   void main().catch((error) => {
     console.error(error);
@@ -7571,6 +7849,8 @@ export {
   computeWorkerStatus,
   createRun,
   deriveRunStatus,
+  discoverDefaultRepo,
+  discoverDefaultRepoCandidates,
   dispatchRun,
   drainPlanOutbox,
   ensurePrReadyHandoff,
@@ -7578,13 +7858,16 @@ export {
   extractPlanOutboxFromTask,
   extractPrUrlFromText,
   formatPlanOutboxHandoffBlock,
+  formatResolvedDefaultRepo,
   getHarnessPaths,
   getMonitorStatus,
+  gitRepoRoot,
   hashPlanBody,
   isDashboardVercelUrl,
   isEngagementRequiredSkip,
   isFinishedWorkerStatus,
   isForbiddenWorkerEnvKey,
+  isKynverMonorepoRoot,
   isLandingBlockedWorkerStatus,
   isSystemdRunAvailable,
   isTerminalHeartbeatPhase,
@@ -7603,6 +7886,7 @@ export {
   parseClaudeStream,
   parseHarnessStream,
   parseHeartbeat,
+  persistDefaultRepo,
   persistPlan,
   pickVercelStatusContext,
   postJson,
@@ -7611,9 +7895,11 @@ export {
   reconcileRunsCli,
   reconcileStaleWorkers,
   redactHarness,
+  remediateDefaultRepo,
   resolveBaseUrl,
   resolveCallbackSecret,
   resolveCallbackSecretWithMint,
+  resolveDefaultRepo,
   resolveHarnessRoot,
   resolveVercelInspectTarget,
   runBoundedBuildCheck,