@kynver-app/runtime 0.1.48 → 0.1.50

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;
@@ -1052,238 +1301,63 @@ function classifyExitFailure(errorText) {
     }
   }
   return null;
-}
-
-// src/exited-salvage.ts
-function trimOrNull(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed.length ? trimmed : null;
-}
-function hasFinalResult(value) {
-  if (value === void 0 || value === null) return false;
-  if (typeof value === "string") return value.trim().length > 0;
-  if (typeof value === "boolean") return value;
-  if (Array.isArray(value)) return value.length > 0;
-  if (typeof value === "object") return Object.keys(value).length > 0;
-  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();
+}
+
+// src/exited-salvage.ts
+function trimOrNull(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+function hasFinalResult(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "boolean") return value;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  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`
+    );
   }
-  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;
@@ -1956,7 +2030,7 @@ function inferModelRoutingFromTask(task) {
       rule: "lane:landing"
     };
   }
-  if (ref.includes("review") || title.startsWith("review ") || roleLane.includes("review")) {
+  if (ref.includes("review") || /^review[\s:]/.test(title) || roleLane.includes("review")) {
     if (isOpusLane(ref, title) || roleLane === "deep_reviewer") {
       return { model: "claude-opus-4-7", provider: "claude", rule: "lane:deep_review" };
     }
@@ -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) {
@@ -2419,6 +2493,11 @@ function isHarnessExpertReviewWorker(worker) {
 
 // src/pr-handoff/pr-handoff-assess.ts
 var REVIEW_LANE_RULE = /^(lane:)?(review|deep_review|planning|landing)(:|$)/i;
+var REVIEW_PERSONA_SLUGS = /* @__PURE__ */ new Set(["lorentz", "sentinel"]);
+var NO_PR_COMMITS_BETWEEN_RE = /no commits between/i;
+function isGhNoCommitsBetweenError(detail) {
+  return Boolean(detail && NO_PR_COMMITS_BETWEEN_RE.test(detail));
+}
 function trimOrNull4(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
@@ -2437,8 +2516,30 @@ function extractPrUrlFromText(value) {
   );
   return m ? trimOrNull4(m[0]) : null;
 }
-function hasWorkProduct(snapshot) {
+function countCommitsAheadOfBase(worktreePath, baseRef, exec) {
+  const base = baseRef.trim();
+  if (!base) return null;
+  const count = exec.git(worktreePath, ["rev-list", "--count", `${base}..HEAD`]);
+  if (count.status !== 0) return null;
+  const n = Number.parseInt(count.stdout.trim(), 10);
+  return Number.isFinite(n) ? n : null;
+}
+function isReviewArtifactWorker(worker, snapshot) {
+  if (snapshot.changedFiles.length > 0) return false;
+  const persona = trimOrNull4(worker.personaSlug)?.toLowerCase();
+  if (persona && REVIEW_PERSONA_SLUGS.has(persona)) return true;
+  const rule = trimOrNull4(worker.routingRule) ?? "";
+  if (rule && REVIEW_LANE_RULE.test(rule)) return true;
+  return false;
+}
+function hasWorkProduct(snapshot, options) {
   if (snapshot.changedFiles.length > 0) return true;
+  const baseRef = trimOrNull4(options?.baseRef);
+  if (baseRef && options?.exec && options.worktreePath) {
+    const ahead = countCommitsAheadOfBase(options.worktreePath, baseRef, options.exec);
+    if (ahead === 0) return false;
+    if (ahead !== null && ahead > 0) return true;
+  }
   if (trimOrNull4(snapshot.headCommit)) return true;
   if (committedHead(snapshot.gitAncestry)) return true;
   return false;
@@ -2459,6 +2560,13 @@ function assessPrHandoffRequirement(input) {
   if (rule && REVIEW_LANE_RULE.test(rule)) {
     return { required: false, reason: "review_lane" };
   }
+  const workerCtx = input.worker ?? {
+    personaSlug: input.personaSlug,
+    routingRule: input.routingRule
+  };
+  if (isReviewArtifactWorker(workerCtx, input.snapshot)) {
+    return { required: false, reason: "review_artifact" };
+  }
   if (trimOrNull4(input.patchPath) || trimOrNull4(input.artifactBundlePath)) {
     return { required: false, reason: "patch_or_bundle" };
   }
@@ -2466,7 +2574,12 @@ function assessPrHandoffRequirement(input) {
   if (prUrl) {
     return { required: false, reason: "already_has_pr" };
   }
-  if (!hasWorkProduct(input.snapshot)) {
+  const workProductOpts = input.exec && input.baseRef ? {
+    baseRef: input.baseRef,
+    exec: input.exec,
+    worktreePath: input.snapshot.worktreePath
+  } : void 0;
+  if (!hasWorkProduct(input.snapshot, workProductOpts)) {
     return { required: false, reason: "no_work_product" };
   }
   return { required: true, snapshot: input.snapshot };
@@ -2675,15 +2788,19 @@ function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
     prUrl: prUrlHint,
     headCommit: null
   });
+  const baseRef = input.run.baseCommit?.trim() || input.run.base?.trim() || "origin/main";
   const requirement = assessPrHandoffRequirement({
     dispatched: input.worker.dispatched,
     routingRule: input.worker.routingRule,
+    personaSlug: input.worker.personaSlug,
     prUrl: prUrlHint,
     taskTitle: input.worker.taskTitle,
     executorRef: input.worker.executorRef,
     parentTaskId: input.worker.parentTaskId,
-    personaSlug: input.worker.personaSlug,
     taskPrUrl: input.worker.taskPrUrl,
+    baseRef,
+    exec,
+    worker: input.worker,
     snapshot
   });
   if (!requirement.required) {
@@ -2768,6 +2885,14 @@ function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
     exec
   });
   if (!pr.ok || !pr.prUrl) {
+    if (isGhNoCommitsBetweenError(pr.detail)) {
+      return {
+        ok: true,
+        headCommit: headCommit ?? void 0,
+        committed,
+        pushed
+      };
+    }
     const dirty = snapshot.changedFiles.length;
     const detail = dirty ? `${dirty} uncommitted change(s) and no PR URL after handoff attempt` : "no PR URL after handoff attempt";
     return {
@@ -2787,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",
@@ -2843,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;
@@ -3101,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) {
@@ -3109,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) {
@@ -3220,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) {
@@ -3409,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");
@@ -3496,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 || [],
@@ -3570,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) {
@@ -3862,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();
@@ -3884,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() {
@@ -3905,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));
@@ -3917,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");
   }
@@ -3971,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) {
@@ -4174,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
@@ -4208,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);
 }
 
@@ -4308,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;
@@ -4533,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) {
@@ -4547,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;
@@ -4567,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();
@@ -4588,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,
@@ -4608,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 {
@@ -4621,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;
@@ -4665,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;
@@ -4722,10 +4926,10 @@ 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";
+import path23 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set(["running", "dispatching", "pending", "queued"]);
 function terminalStatusFor(run) {
   const names = Object.keys(run.workers || {});
@@ -4736,7 +4940,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;
@@ -4788,7 +4992,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({
@@ -4882,7 +5086,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) {
@@ -4906,7 +5110,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;
@@ -4955,7 +5159,7 @@ 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;
@@ -5026,14 +5230,14 @@ function skipNodeModulesRemoval(input) {
 }
 
 // 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];
@@ -5047,7 +5251,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);
@@ -5063,7 +5267,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,
@@ -5094,7 +5298,7 @@ function removeNodeModules(candidate, execute) {
   }
 }
 function removeWorktree(candidate, execute) {
-  if (!existsSync16(candidate.path)) {
+  if (!existsSync17(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -5111,7 +5315,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 {
@@ -5131,20 +5335,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;
@@ -5154,17 +5358,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({
@@ -5177,16 +5381,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);
@@ -5209,7 +5413,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({
@@ -5226,17 +5430,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,
@@ -5251,7 +5455,7 @@ function buildWorktreeIndex() {
 // 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 { worktreesDir } = options.harnessRoot ? { worktreesDir: path30.join(harnessRoot, "worktrees") } : getHarnessPaths();
   const execute = options.execute === true;
   const nodeModulesAgeMs = options.nodeModulesAgeMs ?? DEFAULT_NODE_MODULES_AGE_MS;
   const worktreesAgeMs = options.worktreesAgeMs ?? 0;
@@ -5295,7 +5499,7 @@ function runHarnessCleanup(options = {}) {
       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,
@@ -5311,7 +5515,7 @@ function runHarnessCleanup(options = {}) {
     actions.push(removeNodeModules(candidate, resolved.execute));
   }
   for (const candidate of scanWorktreeCandidates(scanOpts)) {
-    const indexed = index.get(path28.resolve(candidate.path)) ?? null;
+    const indexed = index.get(path30.resolve(candidate.path)) ?? null;
     const guardReason = skipWorktreeRemoval({
       indexed,
       includeOrphans: resolved.includeOrphans,
@@ -5376,8 +5580,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",
@@ -5391,13 +5595,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) {
@@ -5413,7 +5617,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 };
@@ -5429,7 +5633,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;
@@ -5571,7 +5775,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;
@@ -5857,7 +6061,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 };
@@ -5906,9 +6110,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;
@@ -5952,7 +6156,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",
@@ -5964,7 +6168,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 };
@@ -6052,7 +6256,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) {
@@ -6108,11 +6312,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;
 }
@@ -6120,7 +6324,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);
@@ -6130,18 +6334,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;
@@ -6232,7 +6436,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
   );
 }
@@ -6434,18 +6638,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");
@@ -6565,12 +6769,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 {
@@ -6599,7 +6803,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;
@@ -6612,15 +6816,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),
@@ -6638,20 +6842,119 @@ var defaultRuntimeTakeoverProbes = {
     openclawCronSecret: Boolean(process.env.OPENCLAW_CRON_SECRET?.trim()),
     kynverHarnessRoot: process.env.KYNVER_HARNESS_ROOT?.trim() || void 0,
     opusHarnessRoot: process.env.OPUS_HARNESS_ROOT?.trim() || void 0,
-    kynverSchedulerProvider: process.env.KYNVER_SCHEDULER_PROVIDER?.trim() || void 0
+    kynverSchedulerProvider: process.env.KYNVER_SCHEDULER_PROVIDER?.trim() || void 0,
+    qstashTokenPresent: Boolean(process.env.QSTASH_TOKEN?.trim()),
+    kynverHostedDeployment: (() => {
+      const v = process.env.KYNVER_HOSTED_DEPLOYMENT?.trim().toLowerCase();
+      return v === "1" || v === "true" || v === "yes";
+    })()
   }),
   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"])
 };
 
-// src/doctor/runtime-takeover.ts
+// src/doctor/runtime-takeover-scheduler.ts
 function check(partial) {
   return partial;
 }
+function assessRuntimeTakeoverScheduler(env, ctx) {
+  const runnerOpenclaw = env.kynverSchedulerProvider === "openclaw-cron";
+  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 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",
+      label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
+      status: "warn",
+      summary: "KYNVER_SCHEDULER_PROVIDER=openclaw-cron on this runner \u2014 hosted dispatch still depends on the OpenClaw local-cron adapter",
+      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, hostedDeployment }
+    });
+  }
+  if (deploymentOpenclaw || deploymentNeedsQstash) {
+    return check({
+      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" : 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,
+        qstashTokenPresent: env.qstashTokenPresent ?? false,
+        hostedDeployment
+      }
+    });
+  }
+  if (hostedDeployment && env.qstashTokenPresent && !env.kynverSchedulerProvider) {
+    return check({
+      id: "hotspot_openclaw_scheduler",
+      label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
+      status: "pass",
+      summary: "QSTASH_TOKEN present; hosted scheduler auto-selects qstash (explicit KYNVER_SCHEDULER_PROVIDER=qstash optional)",
+      details: {
+        schedulerProvider: null,
+        qstashTokenPresent: true,
+        hostedDeployment
+      }
+    });
+  }
+  if (!env.kynverSchedulerProvider) {
+    return check({
+      id: "hotspot_openclaw_scheduler",
+      label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
+      status: "pass",
+      summary: "No KYNVER_SCHEDULER_PROVIDER on runner (expected) \u2014 finish runner setup so daemon pipeline-tick owns dispatch",
+      details: { schedulerProvider: null, dispatchPath: "kynver-daemon-pipeline-tick-pending" }
+    });
+  }
+  return check({
+    id: "hotspot_openclaw_scheduler",
+    label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
+    status: "pass",
+    summary: `KYNVER_SCHEDULER_PROVIDER=${env.kynverSchedulerProvider}`,
+    details: { schedulerProvider: env.kynverSchedulerProvider ?? null }
+  });
+}
+
+// src/doctor/runtime-takeover.ts
+function check2(partial) {
+  return partial;
+}
 function summarizeCounts(sections) {
   const counts = { pass: 0, warn: 0, fail: 0 };
   for (const section of sections) {
@@ -6668,14 +6971,14 @@ function assessCliPackage(probes) {
   const firstPath = onPath ? which.stdout.split(/\r?\n/)[0]?.trim() : void 0;
   const displayCliPath = firstPath ? displayUserPath(firstPath) : void 0;
   const checks = [
-    check({
+    check2({
       id: "cli_running_version",
       label: "Running @kynver-app/runtime version",
       status: "pass",
       summary: `@kynver-app/runtime ${runningVersion}`,
       details: { version: runningVersion }
     }),
-    check({
+    check2({
       id: "cli_on_path",
       label: "kynver executable on PATH",
       status: onPath ? "pass" : "warn",
@@ -6689,7 +6992,7 @@ function assessCliPackage(probes) {
     const installedVersion = versionProbe.stdout.replace(/^kynver\s+/i, "").trim() || void 0;
     const versionMatch = versionProbe.ok && (!installedVersion || installedVersion === runningVersion);
     checks.push(
-      check({
+      check2({
         id: "cli_installed_version",
         label: "Installed kynver CLI version matches running package",
         status: versionMatch ? "pass" : "warn",
@@ -6707,7 +7010,7 @@ function assessUserConfig(probes) {
   const exists = probes.pathExists(configPath);
   const config = probes.loadConfig();
   const checks = [
-    check({
+    check2({
       id: "config_file",
       label: "~/.kynver/config.json present",
       status: exists ? "pass" : "fail",
@@ -6719,10 +7022,16 @@ 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(
-      check({
+      check2({
         id: "config_api_base_url",
         label: "Default API base URL",
         status: apiBaseUrl ? "pass" : "warn",
@@ -6730,7 +7039,7 @@ function assessUserConfig(probes) {
         remediation: apiBaseUrl ? void 0 : "Set `apiBaseUrl` via `kynver setup --api-base-url https://\u2026`.",
         details: { apiBaseUrl: apiBaseUrl ?? null }
       }),
-      check({
+      check2({
         id: "config_agent_os_id",
         label: "Default AgentOS id",
         status: agentOsId ? "pass" : "warn",
@@ -6738,14 +7047,16 @@ function assessUserConfig(probes) {
         remediation: agentOsId ? void 0 : "Set `agentOsId` via `kynver setup --agent-os-id <uuid>`.",
         details: { agentOsId: agentOsId ?? null, agentOsSlug: config.agentOsSlug ?? null }
       }),
-      check({
+      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
         }
       })
@@ -6766,7 +7077,7 @@ function assessRunnerToken(probes) {
   const scopedSaved = Boolean(savedToken) && (!targetAgentOsId || !savedAgentOsId || savedAgentOsId === targetAgentOsId);
   const hasScoped = Boolean(envToken?.startsWith("krc1.")) || scopedSaved && savedToken?.startsWith("krc1.");
   const checks = [
-    check({
+    check2({
       id: "runner_token_scoped",
       label: "Scoped runner token (krc1.*) ready",
       status: hasScoped ? "pass" : "fail",
@@ -6779,7 +7090,7 @@ function assessRunnerToken(probes) {
         credentialsPath: displayCredPath
       }
     }),
-    check({
+    check2({
       id: "runner_token_agent_os_match",
       label: "Saved runner token matches configured agentOsId",
       status: !savedToken || !targetAgentOsId || !savedAgentOsId || savedAgentOsId === targetAgentOsId ? "pass" : "warn",
@@ -6787,7 +7098,7 @@ function assessRunnerToken(probes) {
       remediation: savedToken && targetAgentOsId && savedAgentOsId && savedAgentOsId !== targetAgentOsId ? "`kynver runner credential --agent-os-id <configured-id>` to mint a workspace-bound token." : void 0,
       details: { configuredAgentOsId: targetAgentOsId ?? null, savedAgentOsId: savedAgentOsId ?? null }
     }),
-    check({
+    check2({
       id: "runner_api_key_for_refresh",
       label: "API key available for token refresh",
       status: creds.hasApiKey || Boolean(process.env.KYNVER_API_KEY?.trim()) ? "pass" : "warn",
@@ -6806,7 +7117,7 @@ function assessVercelCli(probes) {
     id: "vercel_cli",
     label: "Vercel CLI",
     checks: [
-      check({
+      check2({
         id: "vercel_installed",
         label: "Vercel CLI installed",
         status: installed ? "pass" : "warn",
@@ -6814,7 +7125,7 @@ function assessVercelCli(probes) {
         remediation: installed ? void 0 : "Install Vercel CLI (`npm i -g vercel`) for deploy evidence and env pulls.",
         details: { stderr: version.stderr || null }
       }),
-      check({
+      check2({
         id: "vercel_authenticated",
         label: "Vercel CLI authenticated",
         status: !installed ? "warn" : whoami.ok ? "pass" : "warn",
@@ -6827,8 +7138,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);
@@ -6838,14 +7149,14 @@ function assessHarnessDirs(probes) {
     id: "harness_dirs",
     label: "Harness / daemon directories",
     checks: [
-      check({
+      check2({
         id: "harness_root",
         label: "Harness root resolved",
         status: "pass",
         summary: displayHarnessRoot,
         details: { harnessRoot: displayHarnessRoot }
       }),
-      check({
+      check2({
         id: "harness_runs_dir",
         label: "Runs directory ready",
         status: runsExists && probes.pathWritable(runsDir) ? "pass" : runsExists ? "warn" : "warn",
@@ -6853,7 +7164,7 @@ function assessHarnessDirs(probes) {
         remediation: runsExists && !probes.pathWritable(runsDir) ? `Fix permissions on ${displayRunsDir} or set KYNVER_HARNESS_ROOT to a writable path.` : void 0,
         details: { runsDir: displayRunsDir, exists: runsExists, writable: probes.pathWritable(runsDir) }
       }),
-      check({
+      check2({
         id: "harness_worktrees_dir",
         label: "Worktrees directory ready",
         status: worktreesExists && probes.pathWritable(worktreesDir) ? "pass" : "warn",
@@ -6874,7 +7185,7 @@ function assessCallbackAuth(probes) {
   const creds = probes.readCredentials();
   const savedScoped = creds.runnerTokenPrefix?.startsWith("krc1.");
   const checks = [
-    check({
+    check2({
       id: "callback_base_url",
       label: "Callback base URL configured",
       status: baseUrl ? usingLegacyBase ? "warn" : "pass" : "fail",
@@ -6885,7 +7196,7 @@ function assessCallbackAuth(probes) {
         baseUrl: baseUrl ?? null
       }
     }),
-    check({
+    check2({
       id: "callback_auth_mode",
       label: "Callback auth uses scoped runner token",
       status: envScoped || savedScoped ? "pass" : legacySecret ? "warn" : "fail",
@@ -6901,15 +7212,22 @@ function assessCallbackAuth(probes) {
 }
 function assessOpenclawHotspots(probes) {
   const env = probes.envSnapshot();
+  const config = probes.loadConfig();
+  const creds = probes.readCredentials();
   const harnessRoot = probes.harnessRoot();
   const legacyRoot = probes.legacyOpenclawHarnessRoot();
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayLegacyRoot = redactHomePath(legacyRoot);
   const displayOpusHarnessRoot = env.opusHarnessRoot ? redactHomePath(env.opusHarnessRoot) : null;
   const legacyHarnessActive = harnessRoot === legacyRoot && probes.pathExists(legacyRoot);
-  const schedulerOpenclaw = !env.kynverSchedulerProvider || env.kynverSchedulerProvider === "openclaw-cron";
+  const targetAgentOsId = config.agentOsId?.trim();
+  const envToken = env.kynverRunnerTokenPrefix;
+  const savedToken = creds.runnerTokenPrefix;
+  const savedAgentOsId = creds.runnerTokenAgentOsId;
+  const scopedSaved = Boolean(savedToken) && (!targetAgentOsId || !savedAgentOsId || savedAgentOsId === targetAgentOsId);
+  const hasScopedRunnerToken = Boolean(envToken?.startsWith("krc1.")) || scopedSaved && Boolean(savedToken?.startsWith("krc1."));
   const checks = [
-    check({
+    check2({
       id: "hotspot_legacy_harness_root",
       label: "Legacy ~/.openclaw/harness still active",
       status: legacyHarnessActive ? "warn" : "pass",
@@ -6917,7 +7235,7 @@ function assessOpenclawHotspots(probes) {
       remediation: legacyHarnessActive ? "Set KYNVER_HARNESS_ROOT=~/.kynver/harness (or run setup), migrate artifacts, retire OPUS_HARNESS_ROOT." : env.opusHarnessRoot ? "Prefer KYNVER_HARNESS_ROOT over OPUS_HARNESS_ROOT." : void 0,
       details: { harnessRoot: displayHarnessRoot, legacyRoot: displayLegacyRoot, opusHarnessRoot: displayOpusHarnessRoot }
     }),
-    check({
+    check2({
       id: "hotspot_openclaw_env_secrets",
       label: "OpenClaw deployment secrets in runner env",
       status: env.openclawCronSecret || env.openclawCronFireBaseUrl ? "warn" : "pass",
@@ -6927,15 +7245,12 @@ function assessOpenclawHotspots(probes) {
       ].filter(Boolean).join("; ") : "No OpenClaw cron env overrides on this runner",
       remediation: env.openclawCronSecret || env.openclawCronFireBaseUrl ? "Move to KYNVER_API_URL + scoped runner tokens; unset OpenClaw cron env on user-hosted runners." : void 0
     }),
-    check({
-      id: "hotspot_openclaw_scheduler",
-      label: "openclaw-cron scheduler dependency (deployment)",
-      status: schedulerOpenclaw ? "warn" : "pass",
-      summary: schedulerOpenclaw ? env.kynverSchedulerProvider === "openclaw-cron" ? "KYNVER_SCHEDULER_PROVIDER=openclaw-cron \u2014 AgentOS ticks still routed via OpenClaw local cron adapter" : "KYNVER_SCHEDULER_PROVIDER unset \u2014 server may fall back to openclaw-cron when QStash is absent" : `KYNVER_SCHEDULER_PROVIDER=${env.kynverSchedulerProvider}`,
-      remediation: schedulerOpenclaw ? "On Kynver-hosted scheduler: set KYNVER_SCHEDULER_PROVIDER=qstash where QStash is configured; retire openclaw-cron stub when runtime daemon owns dispatch." : void 0,
-      details: { schedulerProvider: env.kynverSchedulerProvider ?? null }
+    assessRuntimeTakeoverScheduler(env, {
+      agentOsId: targetAgentOsId ?? null,
+      apiBaseUrl: config.apiBaseUrl?.trim() ?? env.kynverApiUrl ?? null,
+      hasScopedRunnerToken
     }),
-    check({
+    check2({
       id: "hotspot_lease_source_names",
       label: "Harness lease/completion source names",
       status: "pass",
@@ -7027,9 +7342,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 /]",
@@ -7122,7 +7437,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);
@@ -7445,6 +7760,8 @@ export {
   computeWorkerStatus,
   createRun,
   deriveRunStatus,
+  discoverDefaultRepo,
+  discoverDefaultRepoCandidates,
   dispatchRun,
   drainPlanOutbox,
   ensurePrReadyHandoff,
@@ -7452,13 +7769,16 @@ export {
   extractPlanOutboxFromTask,
   extractPrUrlFromText,
   formatPlanOutboxHandoffBlock,
+  formatResolvedDefaultRepo,
   getHarnessPaths,
   getMonitorStatus,
+  gitRepoRoot,
   hashPlanBody,
   isDashboardVercelUrl,
   isEngagementRequiredSkip,
   isFinishedWorkerStatus,
   isForbiddenWorkerEnvKey,
+  isKynverMonorepoRoot,
   isLandingBlockedWorkerStatus,
   isSystemdRunAvailable,
   isTerminalHeartbeatPhase,
@@ -7477,6 +7797,7 @@ export {
   parseClaudeStream,
   parseHarnessStream,
   parseHeartbeat,
+  persistDefaultRepo,
   persistPlan,
   pickVercelStatusContext,
   postJson,
@@ -7485,9 +7806,11 @@ export {
   reconcileRunsCli,
   reconcileStaleWorkers,
   redactHarness,
+  remediateDefaultRepo,
   resolveBaseUrl,
   resolveCallbackSecret,
   resolveCallbackSecretWithMint,
+  resolveDefaultRepo,
   resolveHarnessRoot,
   resolveVercelInspectTarget,
   runBoundedBuildCheck,