@kynver-app/runtime 0.1.91 → 0.1.93

package/dist/cli.js

@@ -5,9 +5,9 @@ import { mkdirSync as mkdirSync8, realpathSync } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/config.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import path4 from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir4, totalmem } from "node:os";
+import path8 from "node:path";
 
 // src/default-repo-discovery.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
@@ -381,768 +381,440 @@ function discoverDefaultRepo(opts) {
   return discoverDefaultRepoCandidates(opts)[0] ?? null;
 }
 
-// src/config.ts
-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 {};
-  try {
-    return JSON.parse(readFileSync3(CONFIG_FILE, "utf8"));
-  } catch {
-    return {};
+// src/box-identity.ts
+function normalizeWorkerPoolBoxKind(raw) {
+  const kind = (raw ?? "").trim().toLowerCase();
+  if (kind === "ghost" || kind === "forge") return kind;
+  if (kind.includes("forge")) return "forge";
+  if (kind.includes("ghost") || kind.includes("openclaw")) return "ghost";
+  return "forge";
+}
+function trimEnv(env, key) {
+  const value = env[key]?.trim();
+  return value || null;
+}
+function resolveBoxIdentity(env = process.env, config = {}) {
+  const warnings = [];
+  const configKind = config.boxKind?.trim();
+  if (configKind) {
+    return {
+      boxKind: normalizeWorkerPoolBoxKind(configKind),
+      source: "config",
+      slugInferenceBlocked: false,
+      warnings
+    };
+  }
+  const envKind = trimEnv(env, "KYNVER_BOX_KIND");
+  if (envKind) {
+    return {
+      boxKind: normalizeWorkerPoolBoxKind(envKind),
+      source: "env",
+      slugInferenceBlocked: false,
+      warnings
+    };
+  }
+  const agentOsSlug = trimEnv(env, "KYNVER_AGENT_OS_SLUG");
+  if (agentOsSlug) {
+    warnings.push(
+      `KYNVER_AGENT_OS_SLUG=${agentOsSlug} is a workspace slug, not box identity \u2014 set boxKind via \`kynver setup --box-kind forge|ghost\` or KYNVER_BOX_KIND (defaulting box kind to forge)`
+    );
   }
+  return {
+    boxKind: "forge",
+    source: "default",
+    slugInferenceBlocked: Boolean(agentOsSlug),
+    warnings
+  };
 }
-function saveUserConfig(config) {
-  mkdirSync2(CONFIG_DIR, { recursive: true });
-  writeFileSync2(CONFIG_FILE, `${JSON.stringify(normalizeConfigPaths(config), null, 2)}
-`, { mode: 384 });
+function resolveBoxKindFromConfig(config = {}, env = process.env) {
+  return resolveBoxIdentity(env, config).boxKind;
 }
-function normalizeConfigPaths(config) {
+
+// src/resource-gate.ts
+import os2 from "node:os";
+
+// src/bounded-build/meminfo.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import os from "node:os";
+function readMemAvailableBytes(meminfoText) {
+  if (meminfoText !== void 0) {
+    const match = meminfoText.match(/^MemAvailable:\s+(\d+)\s*kB/m);
+    if (match) return Number(match[1]) * 1024;
+    return os.freemem();
+  }
+  if (process.platform === "linux") {
+    try {
+      const meminfo = readFileSync3("/proc/meminfo", "utf8");
+      const match = meminfo.match(/^MemAvailable:\s+(\d+)\s*kB/m);
+      if (match) return Number(match[1]) * 1024;
+    } catch {
+    }
+  }
+  return os.freemem();
+}
+
+// src/resource-gate.ts
+import path7 from "node:path";
+
+// src/disk-gate.ts
+import { statfsSync as statfsSync2 } from "node:fs";
+
+// src/wsl-host.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, statfsSync } from "node:fs";
+var DEFAULT_WSL_HOST_WARN_FREE_BYTES = 25 * 1024 * 1024 * 1024;
+var DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES = 12 * 1024 * 1024 * 1024;
+var DEFAULT_WSL_HOST_MOUNT = "/mnt/c";
+function isWslHost() {
+  if (process.platform !== "linux") return false;
+  for (const probe of ["/proc/sys/kernel/osrelease", "/proc/version"]) {
+    try {
+      if (!existsSync3(probe)) continue;
+      const text = readFileSync4(probe, "utf8");
+      if (/microsoft|wsl/i.test(text)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function observeWslHostDisk(options = {}) {
+  const wsl = options.forceWsl === void 0 ? isWslHost() : options.forceWsl;
+  if (!wsl) return null;
+  const path67 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
+  const warnBelowBytes = options.wslHostFreeWarnBytes ?? DEFAULT_WSL_HOST_WARN_FREE_BYTES;
+  const criticalBelowBytes = options.wslHostFreeCriticalBytes ?? DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES;
+  const statfs = options.statfs ?? statfsSync;
+  let stats;
+  try {
+    stats = statfs(path67);
+  } catch (error) {
+    return {
+      ok: false,
+      path: path67,
+      freeBytes: 0,
+      totalBytes: 0,
+      usedPercent: 100,
+      warnBelowBytes,
+      criticalBelowBytes,
+      reason: `Windows host disk probe failed at ${path67}: ${error.message}`,
+      probeError: error.message
+    };
+  }
+  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;
+  const lowFree = freeBytes < warnBelowBytes;
+  const criticalFree = freeBytes < criticalBelowBytes;
+  const ok = !lowFree && !criticalFree;
+  const freeGiB = (freeBytes / (1024 * 1024 * 1024)).toFixed(1);
+  let reason = null;
+  if (!ok) {
+    const tag = criticalFree ? "critical" : "warning";
+    reason = `Windows host disk ${path67} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+  }
   return {
-    ...config,
-    ...config.harnessRoot?.trim() ? { harnessRoot: redactHomePath(config.harnessRoot.trim()) } : {},
-    ...config.defaultRepo?.trim() ? { defaultRepo: redactHomePath(config.defaultRepo.trim()) } : {}
+    ok,
+    path: path67,
+    freeBytes,
+    totalBytes,
+    usedPercent,
+    warnBelowBytes,
+    criticalBelowBytes,
+    reason,
+    probeError: null
   };
 }
-function presentUserConfig(config) {
-  return normalizeConfigPaths(config);
+function summarizeWslRecoverySteps() {
+  return "Recovery: 1) free Windows C: (empty Recycle Bin / Storage Sense / clear %TEMP%); 2) shut down WSL (`wsl --shutdown`) then compact the VHDX (`Optimize-VHD` or `diskpart compact vdisk`); 3) clear local node_modules / .next / harness worktrees before restarting workers. Full runbook: docs/runbooks/wsl-disk-pressure.md.";
 }
-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.KYNVER_CRON_FIRE_BASE_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 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();
+
+// src/disk-gate.ts
+var DEFAULT_WARN_FREE_BYTES = 30 * 1024 * 1024 * 1024;
+var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
+var DEFAULT_MAX_USED_PERCENT = 80;
+var DEFAULT_HARD_MAX_USED_PERCENT = 90;
+function observeRunnerDiskGate(input = {}) {
+  const path67 = 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 = statfsSync2(path67);
+  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;
+  const lowFree = freeBytes < warnBelowBytes;
+  const criticalFree = freeBytes < criticalBelowBytes;
+  const highUse = usedPercent > maxUsedPercent;
+  const hardHighUse = usedPercent > hardMaxUsedPercent;
+  const localOk = !lowFree && !criticalFree && !highUse && !hardHighUse;
+  const wslHost = input.skipWslHostCheck ? null : observeWslHostDisk(input.wslHost);
+  const ok = localOk && (wslHost ? wslHost.ok : true);
+  let reason = null;
+  if (!ok) {
+    reason = [
+      criticalFree ? `free space below critical ${criticalBelowBytes} bytes` : null,
+      lowFree ? `free space below warning ${warnBelowBytes} bytes` : null,
+      hardHighUse ? `used percent above hard cap ${hardMaxUsedPercent}%` : null,
+      highUse ? `used percent above cap ${maxUsedPercent}%` : null,
+      wslHost && !wslHost.ok ? wslHost.reason : null
+    ].filter(Boolean).join("; ");
+  }
   return {
-    ...apiBaseUrl ? { apiBaseUrl: trimTrailingSlash(apiBaseUrl) } : {},
-    ...agentOsId ? { agentOsId } : {},
-    ...defaultRepo ? { defaultRepo } : {},
-    ...harnessRoot ? { harnessRoot } : {},
-    ...typeof args.agentOsSlug === "string" ? { agentOsSlug: args.agentOsSlug } : existing.agentOsSlug ? { agentOsSlug: existing.agentOsSlug } : {}
+    ok,
+    path: path67,
+    freeBytes,
+    totalBytes,
+    usedPercent,
+    warnBelowBytes,
+    criticalBelowBytes,
+    maxUsedPercent,
+    hardMaxUsedPercent,
+    reason,
+    wslHost
   };
 }
-function loadCredentialsFile() {
-  if (!existsSync3(CREDENTIALS_FILE)) return {};
-  try {
-    return JSON.parse(readFileSync3(CREDENTIALS_FILE, "utf8"));
-  } catch {
-    return {};
+
+// src/run-store.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import path5 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");
+var HARNESS_LAYOUT_DIR_NAMES = /* @__PURE__ */ new Set(["runs", "worktrees"]);
+function normalizeHarnessRoot(root) {
+  let resolved = path4.resolve(resolveUserPath(root.trim()));
+  while (HARNESS_LAYOUT_DIR_NAMES.has(path4.basename(resolved))) {
+    resolved = path4.dirname(resolved);
   }
+  return resolved;
 }
-function saveCredentialsFile(parsed) {
-  mkdirSync2(CONFIG_DIR, { recursive: true });
-  writeFileSync2(CREDENTIALS_FILE, `${JSON.stringify(parsed, null, 2)}
-`, { mode: 384 });
+function resolveHarnessRoot() {
+  const env = process.env.KYNVER_HARNESS_ROOT || process.env.OPUS_HARNESS_ROOT;
+  if (env) return normalizeHarnessRoot(env);
+  const configured = loadUserConfig().harnessRoot?.trim();
+  if (configured) return normalizeHarnessRoot(configured);
+  const kynverRoot = path4.join(homedir3(), ".kynver", "harness");
+  if (existsSync4(kynverRoot)) return kynverRoot;
+  if (existsSync4(LEGACY_ROOT)) return LEGACY_ROOT;
+  return kynverRoot;
 }
-function loadApiKey() {
-  if (process.env.KYNVER_API_KEY) return process.env.KYNVER_API_KEY;
-  return loadCredentialsFile().apiKey;
+function harnessRunsDir(harnessRoot) {
+  return path4.join(normalizeHarnessRoot(harnessRoot), "runs");
 }
-function saveApiKey(apiKey) {
-  saveCredentialsFile({ ...loadCredentialsFile(), apiKey });
+function harnessWorktreesDir(harnessRoot) {
+  return path4.join(normalizeHarnessRoot(harnessRoot), "worktrees");
 }
-function loadRunnerToken(agentOsId) {
-  const envToken = process.env.KYNVER_RUNNER_TOKEN?.trim();
-  if (envToken) return envToken;
-  const creds = loadCredentialsFile();
-  if (!creds.runnerToken) return void 0;
-  if (agentOsId && creds.runnerTokenAgentOsId && creds.runnerTokenAgentOsId !== agentOsId) {
-    return void 0;
-  }
-  return creds.runnerToken;
+function getHarnessPaths() {
+  const harnessRoot = resolveHarnessRoot();
+  return {
+    harnessRoot,
+    runsDir: harnessRunsDir(harnessRoot),
+    worktreesDir: harnessWorktreesDir(harnessRoot)
+  };
 }
-function saveRunnerToken(agentOsId, token) {
-  saveCredentialsFile({
-    ...loadCredentialsFile(),
-    runnerToken: token,
-    runnerTokenAgentOsId: agentOsId
-  });
+function runDir(runsDir, id) {
+  return path4.join(runsDir, safeSlug(id));
 }
-function resolveBaseUrl(argsBaseUrl) {
-  const baseUrl = resolveConfiguredBaseUrl(argsBaseUrl);
-  if (!baseUrl) failConfig("requires --base-url, KYNVER_API_URL, KYNVER_CRON_FIRE_BASE_URL, or ~/.kynver/config.json apiBaseUrl");
-  return baseUrl;
+
+// src/run-store.ts
+function getPaths() {
+  return getHarnessPaths();
 }
-function resolveConfiguredBaseUrl(argsBaseUrl) {
-  const baseUrl = argsBaseUrl || process.env.KYNVER_API_URL || process.env.KYNVER_CRON_FIRE_BASE_URL || process.env.OPENCLAW_CRON_FIRE_BASE_URL || loadUserConfig().apiBaseUrl;
-  return baseUrl ? trimTrailingSlash(String(baseUrl)) : void 0;
+function loadRun(id) {
+  const { runsDir } = getPaths();
+  return readJson(path5.join(runDir(runsDir, safeSlug(id)), "run.json"));
 }
-function resolveConfiguredCallbackSecret(argsSecret, agentOsId) {
-  const scoped = argsSecret || loadRunnerToken(agentOsId) || (agentOsId ? void 0 : loadRunnerToken(loadUserConfig().agentOsId));
-  if (scoped) return String(scoped);
-  const globalSecret = process.env.KYNVER_RUNTIME_SECRET || process.env.KYNVER_CRON_SECRET || process.env.OPENCLAW_CRON_SECRET;
-  if (globalSecret) {
-    console.warn(
-      "[kynver] using deployment-level callback secret; run `kynver runner credential --agent-os-id <id>` for a scoped token"
-    );
-    return String(globalSecret);
-  }
-  return void 0;
+function listRunRecords() {
+  const { runsDir } = getPaths();
+  return listRunRecordsAt(runsDir);
 }
-async function resolveCallbackSecretWithMint(argsSecret, agentOsId, opts) {
-  const configured = resolveConfiguredCallbackSecret(argsSecret, agentOsId);
-  if (configured) return configured;
-  const apiKey = loadApiKey();
-  const baseUrl = resolveConfiguredBaseUrl(opts?.baseUrl);
-  if (apiKey && agentOsId && baseUrl) {
-    try {
-      const token = await fetchRunnerCredential(agentOsId, { baseUrl, apiKey });
-      saveRunnerToken(agentOsId, token);
-      return token;
-    } catch (error) {
-      failConfig(`runner credential mint failed: ${error.message}`);
-    }
-  }
-  failConfig(
-    "requires --secret, KYNVER_RUNNER_TOKEN, a scoped runner token (`kynver runner credential`), ~/.kynver/credentials runnerToken, KYNVER_API_KEY with an API base URL to mint one, or (legacy) KYNVER_RUNTIME_SECRET / KYNVER_CRON_SECRET / OPENCLAW_CRON_SECRET"
-  );
+function listRunRecordsForHarnessRoot(harnessRoot) {
+  return listRunRecordsAt(harnessRunsDir(harnessRoot));
 }
-async function refreshRunnerToken(agentOsId, opts) {
-  const apiKey = loadApiKey();
-  const baseUrl = resolveConfiguredBaseUrl(opts?.baseUrl);
-  if (!apiKey || !agentOsId || !baseUrl) return null;
+function isRunDirectoryEntry(runDirPath) {
   try {
-    const token = await fetchRunnerCredential(agentOsId, { baseUrl, apiKey });
-    saveRunnerToken(agentOsId, token);
-    return token;
+    return statSync2(runDirPath).isDirectory();
   } catch {
-    return null;
-  }
-}
-async function refreshRunnerTokenForAuthFailure(rejectedSecret, agentOsId, opts) {
-  const apiKey = loadApiKey();
-  const baseUrl = resolveConfiguredBaseUrl(opts?.baseUrl);
-  if (!apiKey) return { ok: false, reason: "KYNVER_API_KEY is required to refresh a rejected runner token" };
-  if (!agentOsId) return { ok: false, reason: "agentOsId is required to refresh a rejected runner token" };
-  if (!baseUrl) return { ok: false, reason: "KYNVER_API_URL or --base-url is required to refresh a rejected runner token" };
-  try {
-    const token = await fetchRunnerCredential(agentOsId, { baseUrl, apiKey });
-    if (token && token !== rejectedSecret) {
-      saveRunnerToken(agentOsId, token);
-      return { ok: true, token };
-    }
-    return { ok: false, reason: "runner credential refresh returned the rejected token" };
-  } catch (error) {
-    return { ok: false, reason: error.message };
+    return false;
   }
 }
-async function fetchRunnerCredential(agentOsId, opts) {
-  const apiKey = opts?.apiKey || loadApiKey();
-  if (!apiKey) throw new Error("API key required \u2014 run `kynver login` first");
-  const base = resolveBaseUrl(opts?.baseUrl);
-  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/runner-credentials`;
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify({})
-  });
-  const text = await res.text();
-  let parsed = null;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    parsed = null;
-  }
-  if (!res.ok || !parsed?.token) {
-    throw new Error(
-      `runner credential mint failed (${res.status}): ${parsed?.error ?? text.slice(0, 200)}`
+function listRunRecordsAt(runsDir) {
+  if (!existsSync5(runsDir)) return [];
+  const runs = [];
+  for (const entry of readdirSync2(runsDir, { withFileTypes: true })) {
+    if (entry.name === "runs") continue;
+    const runDir2 = path5.join(runsDir, entry.name);
+    if (!isRunDirectoryEntry(runDir2)) continue;
+    const run = readJson(
+      path5.join(runDir2, "run.json"),
+      void 0
     );
+    if (run?.id) runs.push(run);
   }
-  return parsed.token;
+  return runs;
 }
-async function mintRunnerCredential(args) {
-  const agentOsId = (args.agentOsId ? String(args.agentOsId) : loadUserConfig().agentOsId) || "";
-  if (!agentOsId) failConfig("runner credential requires --agent-os-id or agentOsId in ~/.kynver/config.json");
-  try {
-    const token = await fetchRunnerCredential(agentOsId, {
-      baseUrl: args.baseUrl ? String(args.baseUrl) : void 0
-    });
-    saveRunnerToken(agentOsId, token);
-    console.log(
-      JSON.stringify(
-        {
-          ok: true,
-          agentOsId,
-          credentialsPath: displayUserPath(CREDENTIALS_FILE),
-          tokenPrefix: `${token.slice(0, 12)}\u2026`,
-          note: "Scoped runner token saved; callbacks use X-Kynver-Runner-Token."
-        },
-        null,
-        2
-      )
-    );
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
+function loadWorker(runId, name) {
+  const { runsDir } = getPaths();
+  return readJson(
+    path5.join(runDir(runsDir, safeSlug(runId)), "workers", safeSlug(name), "worker.json")
+  );
 }
-function failConfig(message) {
-  console.error(message);
-  process.exit(1);
+function saveRun(run) {
+  const { runsDir } = getPaths();
+  writeJson(path5.join(runDir(runsDir, run.id), "run.json"), run);
 }
-function parseArgs(argv) {
-  const args = {};
-  for (let i = 0; i < argv.length; i++) {
-    const item = argv[i];
-    if (!item.startsWith("--")) continue;
-    const key = item.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-    const next = argv[i + 1];
-    if (!next || next.startsWith("--")) args[key] = true;
-    else {
-      args[key] = next;
-      i++;
-    }
-  }
-  return args;
+function saveWorker(runId, worker) {
+  const { runsDir } = getPaths();
+  writeJson(path5.join(runDir(runsDir, runId), "workers", worker.name, "worker.json"), worker);
 }
-async function runSetup(args) {
-  const existing = loadUserConfig();
-  const maxWorkersRaw = typeof args.maxWorkers === "string" ? args.maxWorkers : typeof args.maxConcurrentWorkers === "string" ? args.maxConcurrentWorkers : void 0;
-  const config = normalizeConfigPaths({
-    ...existing,
-    ...inferSetupFields(existing, args),
-    ...maxWorkersRaw ? { maxConcurrentWorkers: Math.max(1, Math.floor(Number(maxWorkersRaw))) } : {},
-    workerProvider: typeof args.provider === "string" ? args.provider : existing.workerProvider || "cursor"
-  });
-  saveUserConfig(config);
-  let runnerCredentialNote;
-  const apiKey = loadApiKey();
-  const agentOsId = config.agentOsId;
-  if (apiKey && agentOsId) {
-    try {
-      const token = await fetchRunnerCredential(agentOsId, {
-        baseUrl: typeof args.apiBaseUrl === "string" ? args.apiBaseUrl : config.apiBaseUrl,
-        apiKey
-      });
-      saveRunnerToken(agentOsId, token);
-      runnerCredentialNote = "Scoped runner token minted and saved to ~/.kynver/credentials.";
-    } catch {
-      runnerCredentialNote = "Runner token not minted (server offline or master secret unset). Run `kynver runner credential` after deploy.";
-    }
-  }
-  console.log(
-    JSON.stringify(
-      {
-        ok: true,
-        configPath: displayUserPath(CONFIG_FILE),
-        config: presentUserConfig(config),
-        note: runnerCredentialNote ?? "Set worker limit once with --max-workers N (or omit to auto-size from RAM). Run `kynver login` + `kynver runner credential` for scoped callbacks."
-      },
-      null,
-      2
-    )
-  );
+function runDirectory(id) {
+  const { harnessRoot } = getPaths();
+  return runDirectoryAt(harnessRoot, id);
 }
-async function runLogin(args) {
-  const apiKey = typeof args.apiKey === "string" ? args.apiKey : process.env.KYNVER_API_KEY;
-  if (!apiKey) failConfig("kynver login requires --api-key or KYNVER_API_KEY");
-  saveApiKey(apiKey);
-  console.log(JSON.stringify({ ok: true, credentialsPath: displayUserPath(CREDENTIALS_FILE) }, null, 2));
+function runDirectoryAt(harnessRoot, id) {
+  return runDir(harnessRunsDir(harnessRoot), safeSlug(id));
 }
 
-// src/callback-headers.ts
-function buildHarnessCallbackHeaders(secret) {
-  const trimmed = String(secret).trim();
-  if (trimmed.startsWith("krc1.")) {
-    return {
-      "Content-Type": "application/json",
-      "X-Kynver-Runner-Token": trimmed
-    };
+// src/run-worker-index.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "node:fs";
+import path6 from "node:path";
+function listRunWorkerNames(run) {
+  const names = /* @__PURE__ */ new Set();
+  for (const name of Object.keys(run.workers || {})) {
+    names.add(safeSlug(name));
   }
-  return {
-    "Content-Type": "application/json",
-    // Canonical header. We keep sending the legacy `X-OpenClaw-Cron-Secret`
-    // (and `X-Kynver-Runtime-Secret`) so an un-upgraded Kynver server that
-    // only reads the old header still authenticates this runner during the
-    // rename compat window.
-    "X-Kynver-Cron-Secret": trimmed,
-    "X-OpenClaw-Cron-Secret": trimmed,
-    "X-Kynver-Runtime-Secret": trimmed
-  };
-}
-
-// src/callbacks.ts
-function callbackTimeoutMs() {
-  const parsed = Number(process.env.KYNVER_CALLBACK_TIMEOUT_MS);
-  if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
-  return 3e4;
-}
-async function withTimeout(fn) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), callbackTimeoutMs());
-  try {
-    return await fn(controller.signal);
-  } finally {
-    clearTimeout(timeout);
+  const workersDir = path6.join(runDirectory(run.id), "workers");
+  if (!existsSync6(workersDir)) return [...names];
+  for (const entry of readdirSync3(workersDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    names.add(safeSlug(entry.name));
   }
+  return [...names];
 }
-async function postJson(url, secret, body) {
-  const res = await withTimeout(
-    (signal) => fetch(url, {
-      method: "POST",
-      headers: buildHarnessCallbackHeaders(secret),
-      body: JSON.stringify(body),
-      signal
-    })
-  );
-  let response = null;
+
+// src/heartbeat.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
+
+// src/heartbeat-final-result.ts
+function tryParseJsonObject(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{")) return null;
   try {
-    response = await res.json();
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
   } catch {
-    response = null;
+    return null;
   }
-  return { ok: res.ok, status: res.status, response };
-}
-async function postJsonWithCredentialRefresh(url, secret, body, opts) {
-  const first = await postJson(url, secret, body);
-  if (first.ok || first.status !== 401) return first;
-  const refreshed = await refreshRunnerTokenForAuthFailure(secret, opts.agentOsId, { baseUrl: opts.baseUrl });
-  if (!refreshed.ok) return { ...first, authRefreshFailure: refreshed.reason };
-  const retry = await postJson(url, refreshed.token, body);
-  return { ...retry, refreshedAuth: true };
+  return null;
 }
-async function getJson(url, secret) {
-  const res = await withTimeout(
-    (signal) => fetch(url, {
-      method: "GET",
-      headers: buildHarnessCallbackHeaders(secret),
-      signal
-    })
-  );
-  let response = null;
-  try {
-    response = await res.json();
-  } catch {
-    response = null;
+function embeddedRecordFromProse(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+  const direct = tryParseJsonObject(trimmed);
+  if (direct) return direct;
+  const candidates = [];
+  const fenceRe = /```(?:json)?\s*([\s\S]*?)```/gi;
+  let fenceMatch;
+  while ((fenceMatch = fenceRe.exec(trimmed)) !== null) {
+    const fromFence = tryParseJsonObject(fenceMatch[1] ?? "");
+    if (fromFence) candidates.push(fromFence);
   }
-  return { ok: res.ok, status: res.status, response };
-}
-
-// src/dispatch-lane-normalization.ts
-function trimLower(value) {
-  return (value ?? "").trim().toLowerCase();
-}
-function roleLaneToDispatchLane(roleLane) {
-  switch (trimLower(roleLane)) {
-    case "implementer":
-    case "repair_implementer":
-    case "plan_author":
-    case "runtime_verifier":
-      return "implementation";
-    case "plan_reviewer":
-    case "report_reviewer":
-    case "deep_reviewer":
-      return "review";
-    default:
-      return null;
+  const firstBrace = trimmed.indexOf("{");
+  const lastBrace = trimmed.lastIndexOf("}");
+  if (firstBrace >= 0 && lastBrace > firstBrace) {
+    const slice = tryParseJsonObject(trimmed.slice(firstBrace, lastBrace + 1));
+    if (slice) candidates.push(slice);
   }
+  return candidates.length > 0 ? candidates[candidates.length - 1] : null;
 }
-function normalizeDispatchNextLaneFilter(raw) {
-  const key = trimLower(raw);
-  if (!key) return void 0;
-  if (key === "implementation" || key === "review" || key === "landing" || key === "any") {
-    return key;
+function terminalFinalResultFromHeartbeatRow(row) {
+  const explicit = row.finalResult ?? row.final_result;
+  if (explicit !== void 0 && explicit !== null) {
+    if (typeof explicit === "string") {
+      const embedded2 = embeddedRecordFromProse(explicit);
+      return embedded2 ?? (explicit.trim() || null);
+    }
+    return explicit;
   }
-  const mapped = roleLaneToDispatchLane(key);
-  if (mapped) return mapped;
-  if (key === "implement" || key === "repair" || key === "coding") return "implementation";
-  if (key === "land" || key === "merge") return "landing";
-  return void 0;
-}
-function resolveDispatchNextLaneFilter(raw) {
-  return normalizeDispatchNextLaneFilter(raw) ?? "any";
+  const summary = typeof row.summary === "string" ? row.summary.trim() : "";
+  if (!summary) return null;
+  const embedded = embeddedRecordFromProse(summary);
+  if (embedded) return embedded;
+  return summary;
 }
 
-// src/disk-gate.ts
-import { statfsSync as statfsSync2 } from "node:fs";
-
-// src/wsl-host.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, statfsSync } from "node:fs";
-var DEFAULT_WSL_HOST_WARN_FREE_BYTES = 25 * 1024 * 1024 * 1024;
-var DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES = 12 * 1024 * 1024 * 1024;
-var DEFAULT_WSL_HOST_MOUNT = "/mnt/c";
-function isWslHost() {
-  if (process.platform !== "linux") return false;
-  for (const probe of ["/proc/sys/kernel/osrelease", "/proc/version"]) {
-    try {
-      if (!existsSync4(probe)) continue;
-      const text = readFileSync4(probe, "utf8");
-      if (/microsoft|wsl/i.test(text)) return true;
-    } catch {
-    }
-  }
-  return false;
+// src/heartbeat.ts
+var HEARTBEAT_FUTURE_SKEW_MS = 6e4;
+function isTerminalHeartbeatPhase(phase) {
+  return phase === "complete";
 }
-function observeWslHostDisk(options = {}) {
-  const wsl = options.forceWsl === void 0 ? isWslHost() : options.forceWsl;
-  if (!wsl) return null;
-  const path65 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
-  const warnBelowBytes = options.wslHostFreeWarnBytes ?? DEFAULT_WSL_HOST_WARN_FREE_BYTES;
-  const criticalBelowBytes = options.wslHostFreeCriticalBytes ?? DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES;
-  const statfs = options.statfs ?? statfsSync;
-  let stats;
-  try {
-    stats = statfs(path65);
-  } catch (error) {
-    return {
-      ok: false,
-      path: path65,
-      freeBytes: 0,
-      totalBytes: 0,
-      usedPercent: 100,
-      warnBelowBytes,
-      criticalBelowBytes,
-      reason: `Windows host disk probe failed at ${path65}: ${error.message}`,
-      probeError: error.message
-    };
-  }
-  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;
-  const lowFree = freeBytes < warnBelowBytes;
-  const criticalFree = freeBytes < criticalBelowBytes;
-  const ok = !lowFree && !criticalFree;
-  const freeGiB = (freeBytes / (1024 * 1024 * 1024)).toFixed(1);
-  let reason = null;
-  if (!ok) {
-    const tag = criticalFree ? "critical" : "warning";
-    reason = `Windows host disk ${path65} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+function terminalFinalResultFromHeartbeat(heartbeat) {
+  if (!isTerminalHeartbeatPhase(heartbeat.lastHeartbeatPhase)) return null;
+  if (heartbeat.terminalFinalResult !== void 0 && heartbeat.terminalFinalResult !== null) {
+    return heartbeat.terminalFinalResult;
   }
-  return {
-    ok,
-    path: path65,
-    freeBytes,
-    totalBytes,
-    usedPercent,
-    warnBelowBytes,
-    criticalBelowBytes,
-    reason,
-    probeError: null
-  };
-}
-function summarizeWslRecoverySteps() {
-  return "Recovery: 1) free Windows C: (empty Recycle Bin / Storage Sense / clear %TEMP%); 2) shut down WSL (`wsl --shutdown`) then compact the VHDX (`Optimize-VHD` or `diskpart compact vdisk`); 3) clear local node_modules / .next / harness worktrees before restarting workers. Full runbook: docs/runbooks/wsl-disk-pressure.md.";
+  const summary = heartbeat.lastHeartbeatSummary?.trim();
+  return summary || "completed";
 }
-
-// src/disk-gate.ts
-var DEFAULT_WARN_FREE_BYTES = 30 * 1024 * 1024 * 1024;
-var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
-var DEFAULT_MAX_USED_PERCENT = 80;
-var DEFAULT_HARD_MAX_USED_PERCENT = 90;
-function observeRunnerDiskGate(input = {}) {
-  const path65 = 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 = statfsSync2(path65);
-  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;
-  const lowFree = freeBytes < warnBelowBytes;
-  const criticalFree = freeBytes < criticalBelowBytes;
-  const highUse = usedPercent > maxUsedPercent;
-  const hardHighUse = usedPercent > hardMaxUsedPercent;
-  const localOk = !lowFree && !criticalFree && !highUse && !hardHighUse;
-  const wslHost = input.skipWslHostCheck ? null : observeWslHostDisk(input.wslHost);
-  const ok = localOk && (wslHost ? wslHost.ok : true);
-  let reason = null;
-  if (!ok) {
-    reason = [
-      criticalFree ? `free space below critical ${criticalBelowBytes} bytes` : null,
-      lowFree ? `free space below warning ${warnBelowBytes} bytes` : null,
-      hardHighUse ? `used percent above hard cap ${hardMaxUsedPercent}%` : null,
-      highUse ? `used percent above cap ${maxUsedPercent}%` : null,
-      wslHost && !wslHost.ok ? wslHost.reason : null
-    ].filter(Boolean).join("; ");
-  }
-  return {
-    ok,
-    path: path65,
-    freeBytes,
-    totalBytes,
-    usedPercent,
-    warnBelowBytes,
-    criticalBelowBytes,
-    maxUsedPercent,
-    hardMaxUsedPercent,
-    reason,
-    wslHost
+function parseHeartbeat(file) {
+  const result = {
+    heartbeatCount: 0,
+    lastHeartbeatAt: null,
+    lastHeartbeatPhase: null,
+    lastHeartbeatSummary: null,
+    terminalFinalResult: null,
+    heartbeatBlocker: null,
+    timestampAnomalies: [],
+    lastBoxResourceSnapshot: null,
+    lastPrEvidence: []
   };
-}
-
-// src/resource-gate.ts
-import os2 from "node:os";
-
-// src/bounded-build/meminfo.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import os from "node:os";
-function readMemAvailableBytes(meminfoText) {
-  if (meminfoText !== void 0) {
-    const match = meminfoText.match(/^MemAvailable:\s+(\d+)\s*kB/m);
-    if (match) return Number(match[1]) * 1024;
-    return os.freemem();
-  }
-  if (process.platform === "linux") {
-    try {
-      const meminfo = readFileSync5("/proc/meminfo", "utf8");
-      const match = meminfo.match(/^MemAvailable:\s+(\d+)\s*kB/m);
-      if (match) return Number(match[1]) * 1024;
-    } catch {
+  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);
+  for (const line of lines) {
+    const entry = safeJson(line);
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const row = entry;
+    result.heartbeatCount++;
+    if (row.ts) {
+      const ts = String(row.ts);
+      const tsMs = Date.parse(ts);
+      if (Number.isFinite(tsMs) && tsMs > maxFutureMs) {
+        result.timestampAnomalies.push({
+          kind: "future_heartbeat_timestamp",
+          observedAt: ts,
+          clampedTo
+        });
+      } else {
+        result.lastHeartbeatAt = ts;
+      }
+    }
+    if (row.phase !== void 0 && row.phase !== null) result.lastHeartbeatPhase = String(row.phase);
+    if (row.summary !== void 0 && row.summary !== null) result.lastHeartbeatSummary = String(row.summary);
+    if (isTerminalHeartbeatPhase(result.lastHeartbeatPhase)) {
+      result.terminalFinalResult = terminalFinalResultFromHeartbeatRow(row);
+    }
+    result.heartbeatBlocker = row.blocker ? String(row.blocker) : null;
+    if (row.boxResourceSnapshot && typeof row.boxResourceSnapshot === "object" && !Array.isArray(row.boxResourceSnapshot)) {
+      result.lastBoxResourceSnapshot = row.boxResourceSnapshot;
+    }
+    if (Array.isArray(row.prEvidence)) {
+      result.lastPrEvidence = row.prEvidence.filter(
+        (entry2) => !!entry2 && typeof entry2 === "object" && typeof entry2.prUrl === "string"
+      );
     }
   }
-  return os.freemem();
+  return result;
 }
 
-// src/resource-gate.ts
-import path8 from "node:path";
-
-// src/run-store.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import path6 from "node:path";
-
-// src/paths.ts
-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");
-var HARNESS_LAYOUT_DIR_NAMES = /* @__PURE__ */ new Set(["runs", "worktrees"]);
-function normalizeHarnessRoot(root) {
-  let resolved = path5.resolve(resolveUserPath(root.trim()));
-  while (HARNESS_LAYOUT_DIR_NAMES.has(path5.basename(resolved))) {
-    resolved = path5.dirname(resolved);
-  }
-  return resolved;
-}
-function resolveHarnessRoot() {
-  const env = process.env.KYNVER_HARNESS_ROOT || process.env.OPUS_HARNESS_ROOT;
-  if (env) return normalizeHarnessRoot(env);
-  const configured = loadUserConfig().harnessRoot?.trim();
-  if (configured) return normalizeHarnessRoot(configured);
-  const kynverRoot = path5.join(homedir4(), ".kynver", "harness");
-  if (existsSync5(kynverRoot)) return kynverRoot;
-  if (existsSync5(LEGACY_ROOT)) return LEGACY_ROOT;
-  return kynverRoot;
-}
-function harnessRunsDir(harnessRoot) {
-  return path5.join(normalizeHarnessRoot(harnessRoot), "runs");
-}
-function harnessWorktreesDir(harnessRoot) {
-  return path5.join(normalizeHarnessRoot(harnessRoot), "worktrees");
-}
-function getHarnessPaths() {
-  const harnessRoot = resolveHarnessRoot();
-  return {
-    harnessRoot,
-    runsDir: harnessRunsDir(harnessRoot),
-    worktreesDir: harnessWorktreesDir(harnessRoot)
-  };
-}
-function runDir(runsDir, id) {
-  return path5.join(runsDir, safeSlug(id));
-}
-
-// src/run-store.ts
-function getPaths() {
-  return getHarnessPaths();
-}
-function loadRun(id) {
-  const { runsDir } = getPaths();
-  return readJson(path6.join(runDir(runsDir, safeSlug(id)), "run.json"));
-}
-function listRunRecords() {
-  const { runsDir } = getPaths();
-  return listRunRecordsAt(runsDir);
-}
-function listRunRecordsForHarnessRoot(harnessRoot) {
-  return listRunRecordsAt(harnessRunsDir(harnessRoot));
-}
-function isRunDirectoryEntry(runDirPath) {
-  try {
-    return statSync2(runDirPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function listRunRecordsAt(runsDir) {
-  if (!existsSync6(runsDir)) return [];
-  const runs = [];
-  for (const entry of readdirSync2(runsDir, { withFileTypes: true })) {
-    if (entry.name === "runs") continue;
-    const runDir2 = path6.join(runsDir, entry.name);
-    if (!isRunDirectoryEntry(runDir2)) continue;
-    const run = readJson(
-      path6.join(runDir2, "run.json"),
-      void 0
-    );
-    if (run?.id) runs.push(run);
-  }
-  return runs;
-}
-function loadWorker(runId, name) {
-  const { runsDir } = getPaths();
-  return readJson(
-    path6.join(runDir(runsDir, safeSlug(runId)), "workers", safeSlug(name), "worker.json")
-  );
-}
-function saveRun(run) {
-  const { runsDir } = getPaths();
-  writeJson(path6.join(runDir(runsDir, run.id), "run.json"), run);
-}
-function saveWorker(runId, worker) {
-  const { runsDir } = getPaths();
-  writeJson(path6.join(runDir(runsDir, runId), "workers", worker.name, "worker.json"), worker);
-}
-function runDirectory(id) {
-  const { harnessRoot } = getPaths();
-  return runDirectoryAt(harnessRoot, id);
-}
-function runDirectoryAt(harnessRoot, id) {
-  return runDir(harnessRunsDir(harnessRoot), safeSlug(id));
-}
-
-// src/run-worker-index.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3 } from "node:fs";
-import path7 from "node:path";
-function listRunWorkerNames(run) {
-  const names = /* @__PURE__ */ new Set();
-  for (const name of Object.keys(run.workers || {})) {
-    names.add(safeSlug(name));
-  }
-  const workersDir = path7.join(runDirectory(run.id), "workers");
-  if (!existsSync7(workersDir)) return [...names];
-  for (const entry of readdirSync3(workersDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    names.add(safeSlug(entry.name));
-  }
-  return [...names];
-}
-
-// src/heartbeat.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
-
-// src/heartbeat-final-result.ts
-function tryParseJsonObject(text) {
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("{")) return null;
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-function embeddedRecordFromProse(text) {
-  const trimmed = text.trim();
-  if (!trimmed) return null;
-  const direct = tryParseJsonObject(trimmed);
-  if (direct) return direct;
-  const candidates = [];
-  const fenceRe = /```(?:json)?\s*([\s\S]*?)```/gi;
-  let fenceMatch;
-  while ((fenceMatch = fenceRe.exec(trimmed)) !== null) {
-    const fromFence = tryParseJsonObject(fenceMatch[1] ?? "");
-    if (fromFence) candidates.push(fromFence);
-  }
-  const firstBrace = trimmed.indexOf("{");
-  const lastBrace = trimmed.lastIndexOf("}");
-  if (firstBrace >= 0 && lastBrace > firstBrace) {
-    const slice = tryParseJsonObject(trimmed.slice(firstBrace, lastBrace + 1));
-    if (slice) candidates.push(slice);
-  }
-  return candidates.length > 0 ? candidates[candidates.length - 1] : null;
-}
-function terminalFinalResultFromHeartbeatRow(row) {
-  const explicit = row.finalResult ?? row.final_result;
-  if (explicit !== void 0 && explicit !== null) {
-    if (typeof explicit === "string") {
-      const embedded2 = embeddedRecordFromProse(explicit);
-      return embedded2 ?? (explicit.trim() || null);
-    }
-    return explicit;
-  }
-  const summary = typeof row.summary === "string" ? row.summary.trim() : "";
-  if (!summary) return null;
-  const embedded = embeddedRecordFromProse(summary);
-  if (embedded) return embedded;
-  return summary;
-}
-
-// src/heartbeat.ts
-var HEARTBEAT_FUTURE_SKEW_MS = 6e4;
-function isTerminalHeartbeatPhase(phase) {
-  return phase === "complete";
-}
-function terminalFinalResultFromHeartbeat(heartbeat) {
-  if (!isTerminalHeartbeatPhase(heartbeat.lastHeartbeatPhase)) return null;
-  if (heartbeat.terminalFinalResult !== void 0 && heartbeat.terminalFinalResult !== null) {
-    return heartbeat.terminalFinalResult;
-  }
-  const summary = heartbeat.lastHeartbeatSummary?.trim();
-  return summary || "completed";
-}
-function parseHeartbeat(file) {
-  const result = {
-    heartbeatCount: 0,
-    lastHeartbeatAt: null,
-    lastHeartbeatPhase: null,
-    lastHeartbeatSummary: null,
-    terminalFinalResult: null,
-    heartbeatBlocker: null,
-    timestampAnomalies: [],
-    lastBoxResourceSnapshot: null,
-    lastPrEvidence: []
-  };
-  if (!existsSync8(file)) return result;
-  const maxFutureMs = Date.now() + HEARTBEAT_FUTURE_SKEW_MS;
-  const clampedTo = new Date(maxFutureMs).toISOString();
-  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;
-    const row = entry;
-    result.heartbeatCount++;
-    if (row.ts) {
-      const ts = String(row.ts);
-      const tsMs = Date.parse(ts);
-      if (Number.isFinite(tsMs) && tsMs > maxFutureMs) {
-        result.timestampAnomalies.push({
-          kind: "future_heartbeat_timestamp",
-          observedAt: ts,
-          clampedTo
-        });
-      } else {
-        result.lastHeartbeatAt = ts;
-      }
-    }
-    if (row.phase !== void 0 && row.phase !== null) result.lastHeartbeatPhase = String(row.phase);
-    if (row.summary !== void 0 && row.summary !== null) result.lastHeartbeatSummary = String(row.summary);
-    if (isTerminalHeartbeatPhase(result.lastHeartbeatPhase)) {
-      result.terminalFinalResult = terminalFinalResultFromHeartbeatRow(row);
-    }
-    result.heartbeatBlocker = row.blocker ? String(row.blocker) : null;
-    if (row.boxResourceSnapshot && typeof row.boxResourceSnapshot === "object" && !Array.isArray(row.boxResourceSnapshot)) {
-      result.lastBoxResourceSnapshot = row.boxResourceSnapshot;
-    }
-    if (Array.isArray(row.prEvidence)) {
-      result.lastPrEvidence = row.prEvidence.filter(
-        (entry2) => !!entry2 && typeof entry2 === "object" && typeof entry2.prUrl === "string"
-      );
-    }
-  }
-  return result;
-}
-
-// src/stream.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+// src/stream.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
 
 // src/repo-search.ts
 var RG_BINARIES = /* @__PURE__ */ new Set(["rg", "ripgrep", "grep"]);
@@ -1626,8 +1298,8 @@ function parseHarnessStream(file) {
     error: null,
     lastShellOutcome: null
   };
-  if (!existsSync9(file)) return result;
-  const lines = readFileSync7(file, "utf8").split("\n").filter(Boolean);
+  if (!existsSync8(file)) return result;
+  const lines = readFileSync6(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const event = safeJson(line);
     if (!event) continue;
@@ -2221,161 +1893,675 @@ function computeWorkerStatus(worker, options = {}) {
   });
   const workerStatusLabel = completionBlocker || attention.state === "blocked" ? "blocked" : completionAcknowledged || attention.state === "done" ? "done" : finalResult ? "exited" : alive ? "running" : "exited";
   return {
-    runId: worker.runId,
-    worker: worker.name,
-    pid: worker.pid,
-    alive,
-    status: workerStatusLabel,
-    attention,
-    branch: worker.branch,
-    worktreePath: worker.worktreePath,
-    ownedPaths: worker.ownedPaths,
-    stdoutBytes,
-    stderrBytes,
-    heartbeatBytes,
-    firstEventAt: parsed.firstEventAt,
-    lastEventAt: parsed.lastEventAt,
-    lastActivityAt,
-    currentTool: completionAcknowledged ? null : parsed.currentTool,
-    heartbeatCount: heartbeat.heartbeatCount,
-    lastHeartbeatAt: heartbeat.lastHeartbeatAt,
-    lastHeartbeatPhase: heartbeat.lastHeartbeatPhase,
-    lastHeartbeatSummary: heartbeat.lastHeartbeatSummary,
-    heartbeatBlocker: heartbeat.heartbeatBlocker,
-    timestampAnomalies: heartbeat.timestampAnomalies,
-    finalResult,
-    error,
-    changedFiles,
-    gitAncestry,
-    instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
-    instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null
+    runId: worker.runId,
+    worker: worker.name,
+    pid: worker.pid,
+    alive,
+    status: workerStatusLabel,
+    attention,
+    branch: worker.branch,
+    worktreePath: worker.worktreePath,
+    ownedPaths: worker.ownedPaths,
+    stdoutBytes,
+    stderrBytes,
+    heartbeatBytes,
+    firstEventAt: parsed.firstEventAt,
+    lastEventAt: parsed.lastEventAt,
+    lastActivityAt,
+    currentTool: completionAcknowledged ? null : parsed.currentTool,
+    heartbeatCount: heartbeat.heartbeatCount,
+    lastHeartbeatAt: heartbeat.lastHeartbeatAt,
+    lastHeartbeatPhase: heartbeat.lastHeartbeatPhase,
+    lastHeartbeatSummary: heartbeat.lastHeartbeatSummary,
+    heartbeatBlocker: heartbeat.heartbeatBlocker,
+    timestampAnomalies: heartbeat.timestampAnomalies,
+    finalResult,
+    error,
+    changedFiles,
+    gitAncestry,
+    instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
+    instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null
+  };
+}
+function isFinishedWorkerStatus(status) {
+  if (status.finalResult) return true;
+  if (status.alive === false) return true;
+  if (status.status === "exited" || status.status === "done") return true;
+  return false;
+}
+function isLandingBlockedWorkerStatus(status) {
+  if (!status.finalResult) return false;
+  return status.attention.state === "needs_attention" || status.attention.state === "blocked";
+}
+function deriveRunStatus(fallback, workers) {
+  if (workers.length === 0) return fallback;
+  if (workers.some((w) => w.attention === "needs_attention" || w.attention === "stale" || w.attention === "blocked")) {
+    return "needs_attention";
+  }
+  if (workers.every((w) => w.status === "done")) return "done";
+  if (workers.some((w) => w.status === "running")) return "running";
+  return fallback;
+}
+
+// src/resource-gate.ts
+var DEFAULT_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
+var DEFAULT_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
+var DEFAULT_MEM_UTILIZATION = 0.85;
+var AUTO_MAX_WORKERS_CEILING = 64;
+function positiveInt(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+function resolveResourceConfig(config = loadUserConfig(), configuredMaxWorkersOverride, totalMemBytes) {
+  const perWorkerMemBytes = positiveInt(config.perWorkerMemBytes, DEFAULT_PER_WORKER_MEM_BYTES);
+  const memReserveBytes = positiveInt(config.memReserveBytes, DEFAULT_MEM_RESERVE_BYTES);
+  const memUtilization = Math.min(
+    1,
+    Math.max(0.1, Number(config.memUtilization) > 0 ? Number(config.memUtilization) : DEFAULT_MEM_UTILIZATION)
+  );
+  const cap = resolveWorkerCap({
+    config,
+    configuredMaxWorkersOverride,
+    totalMemBytes: totalMemBytes ?? os2.totalmem()
+  });
+  return {
+    perWorkerMemBytes,
+    memReserveBytes,
+    memUtilization,
+    configuredMaxWorkers: cap.configuredMaxWorkers,
+    autoCap: cap.autoCap,
+    workerCapSource: cap.workerCapSource
+  };
+}
+function computeAutoMaxWorkers(totalMemBytes, opts = {}) {
+  const perWorkerMemBytes = opts.perWorkerMemBytes ?? DEFAULT_PER_WORKER_MEM_BYTES;
+  const memReserveBytes = opts.memReserveBytes ?? DEFAULT_MEM_RESERVE_BYTES;
+  const memUtilization = opts.memUtilization ?? DEFAULT_MEM_UTILIZATION;
+  const budgetBytes = Math.max(0, Math.floor(totalMemBytes * memUtilization) - memReserveBytes);
+  const raw = Math.max(1, Math.floor(budgetBytes / perWorkerMemBytes));
+  return Math.min(raw, AUTO_MAX_WORKERS_CEILING);
+}
+function readAvailableMemBytes() {
+  return readMemAvailableBytes();
+}
+function isActiveHarnessWorker(worker) {
+  if (typeof worker.completionBlocker === "string" && worker.completionBlocker.trim()) {
+    return false;
+  }
+  const status = computeWorkerStatus(worker);
+  return status.alive && !status.finalResult && status.attention.state !== "done";
+}
+function countActiveWorkersForRun(run) {
+  let active = 0;
+  for (const name of listRunWorkerNames(run)) {
+    const worker = readJson(
+      path7.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
+    );
+    if (!worker || !isActiveHarnessWorker(worker)) continue;
+    active++;
+  }
+  return active;
+}
+function countActiveWorkersGlobal() {
+  let active = 0;
+  for (const run of listRunRecords()) active += countActiveWorkersForRun(run);
+  return active;
+}
+function observeRunnerResourceGate(input) {
+  const config = input.config ?? loadUserConfig();
+  const totalMemBytes = input.totalMemBytes ?? os2.totalmem();
+  const { perWorkerMemBytes, memReserveBytes, memUtilization, configuredMaxWorkers, autoCap: resolvedAutoCap, workerCapSource } = resolveResourceConfig(config, input.configuredMaxWorkersOverride, totalMemBytes);
+  const boxKind = resolveBoxKindFromConfig(config);
+  const freeMemBytes = input.freeMemBytes ?? readAvailableMemBytes();
+  const activeWorkers = input.activeWorkers ?? countActiveWorkersGlobal();
+  const budgetBytes = Math.max(0, Math.floor(totalMemBytes * memUtilization) - memReserveBytes);
+  const capacityFromTotal = Math.max(0, Math.floor(budgetBytes / perWorkerMemBytes));
+  const capacityFromFree = Math.max(0, Math.floor(Math.max(0, freeMemBytes - memReserveBytes) / perWorkerMemBytes));
+  const autoCap = resolvedAutoCap;
+  const targetCap = configuredMaxWorkers ?? autoCap;
+  const maxConcurrentWorkers = Math.max(0, Math.min(targetCap, capacityFromTotal));
+  const slotsByCapacity = Math.max(0, maxConcurrentWorkers - activeWorkers);
+  const slotsByFreeMem = capacityFromFree;
+  let slotsAvailable = Math.min(slotsByCapacity, slotsByFreeMem);
+  const skipDisk = input.skipDiskGate || process.env.KYNVER_RESOURCE_GATE_SKIP_DISK === "1";
+  const diskGate = skipDisk ? void 0 : observeRunnerDiskGate({
+    diskPath: input.diskPath?.trim() || process.env.KYNVER_DISK_GUARD_PATH?.trim() || "/"
+  });
+  if (diskGate && !diskGate.ok) slotsAvailable = 0;
+  let reason = null;
+  if (slotsAvailable <= 0) {
+    if (diskGate && !diskGate.ok) {
+      reason = diskGate.reason ?? "disk gate blocked worker admission";
+    } else if (activeWorkers >= maxConcurrentWorkers) {
+      reason = `at worker limit (${activeWorkers}/${maxConcurrentWorkers} running)`;
+    } else if (capacityFromFree <= 0) {
+      reason = "insufficient free memory \u2014 waiting for workers to finish";
+    } else {
+      reason = "no worker slots available";
+    }
+  }
+  return {
+    ok: slotsAvailable > 0,
+    totalMemBytes,
+    freeMemBytes,
+    memReserveBytes,
+    perWorkerMemBytes,
+    configuredMaxWorkers,
+    workerCapSource,
+    boxKind,
+    autoCap,
+    capacityWorkers: capacityFromTotal,
+    maxConcurrentWorkers,
+    activeWorkers,
+    slotsAvailable,
+    reason,
+    ...diskGate ? { diskGate } : {}
+  };
+}
+
+// src/worker-cap-source.ts
+function positiveInt2(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+function resolveWorkerCap(input) {
+  const config = input.config ?? {};
+  const env = input.env ?? process.env;
+  const perWorkerMemBytes = positiveInt2(config.perWorkerMemBytes, DEFAULT_PER_WORKER_MEM_BYTES);
+  const memReserveBytes = positiveInt2(config.memReserveBytes, DEFAULT_MEM_RESERVE_BYTES);
+  const memUtilization = Math.min(
+    1,
+    Math.max(0.1, Number(config.memUtilization) > 0 ? Number(config.memUtilization) : DEFAULT_MEM_UTILIZATION)
+  );
+  const autoCap = computeAutoMaxWorkers(input.totalMemBytes, {
+    perWorkerMemBytes,
+    memReserveBytes,
+    memUtilization
+  });
+  if (input.configuredMaxWorkersOverride !== void 0 && input.configuredMaxWorkersOverride !== null) {
+    return {
+      configuredMaxWorkers: positiveInt2(input.configuredMaxWorkersOverride, autoCap),
+      autoCap,
+      workerCapSource: "workspace_override"
+    };
+  }
+  if (config.maxConcurrentWorkers !== void 0 && config.maxConcurrentWorkers !== null) {
+    const configured = positiveInt2(config.maxConcurrentWorkers, 0) || null;
+    if (configured) {
+      return {
+        configuredMaxWorkers: Math.min(configured, AUTO_MAX_WORKERS_CEILING),
+        autoCap,
+        workerCapSource: "config"
+      };
+    }
+  }
+  const envIntentional = env.KYNVER_MAX_WORKERS_INTENTIONAL === "1" || env.KYNVER_MAX_WORKERS_INTENTIONAL === "true";
+  const envCap = envIntentional && env.KYNVER_MAX_WORKERS ? positiveInt2(env.KYNVER_MAX_WORKERS, 0) || null : null;
+  if (envCap) {
+    return {
+      configuredMaxWorkers: Math.min(envCap, AUTO_MAX_WORKERS_CEILING),
+      autoCap,
+      workerCapSource: "env"
+    };
+  }
+  return {
+    configuredMaxWorkers: null,
+    autoCap,
+    workerCapSource: "auto"
+  };
+}
+function recommendSetupWorkerCap(input = {}) {
+  const totalMemBytes = input.totalMemBytes ?? 0;
+  const autoCap = computeAutoMaxWorkers(totalMemBytes, {
+    perWorkerMemBytes: positiveInt2(input.config?.perWorkerMemBytes, DEFAULT_PER_WORKER_MEM_BYTES),
+    memReserveBytes: positiveInt2(input.config?.memReserveBytes, DEFAULT_MEM_RESERVE_BYTES),
+    memUtilization: input.config?.memUtilization && Number(input.config.memUtilization) > 0 ? Number(input.config.memUtilization) : DEFAULT_MEM_UTILIZATION
+  });
+  const diskGateOk = input.diskGateOk ?? true;
+  const recommendedMaxWorkers = diskGateOk ? autoCap : Math.max(1, Math.min(autoCap, 4));
+  return {
+    totalMemBytes,
+    autoCap,
+    recommendedMaxWorkers,
+    diskPath: input.diskPath ?? "/",
+    diskGateOk,
+    diskFreeBytes: input.diskFreeBytes ?? null
+  };
+}
+
+// src/config.ts
+import os3 from "node:os";
+var CONFIG_DIR = path8.join(homedir4(), ".kynver");
+var CONFIG_FILE = path8.join(CONFIG_DIR, "config.json");
+var CREDENTIALS_FILE = path8.join(CONFIG_DIR, "credentials");
+function loadUserConfig() {
+  if (!existsSync9(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync7(CONFIG_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveUserConfig(config) {
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  writeFileSync2(CONFIG_FILE, `${JSON.stringify(normalizeConfigPaths(config), null, 2)}
+`, { mode: 384 });
+}
+function normalizeConfigPaths(config) {
+  return {
+    ...config,
+    ...config.harnessRoot?.trim() ? { harnessRoot: redactHomePath(config.harnessRoot.trim()) } : {},
+    ...config.defaultRepo?.trim() ? { defaultRepo: redactHomePath(config.defaultRepo.trim()) } : {}
+  };
+}
+function presentUserConfig(config) {
+  return normalizeConfigPaths(config);
+}
+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.KYNVER_CRON_FIRE_BASE_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 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) } : {},
+    ...agentOsId ? { agentOsId } : {},
+    ...defaultRepo ? { defaultRepo } : {},
+    ...harnessRoot ? { harnessRoot } : {},
+    ...typeof args.agentOsSlug === "string" ? { agentOsSlug: args.agentOsSlug } : existing.agentOsSlug ? { agentOsSlug: existing.agentOsSlug } : {}
+  };
+}
+var SETUP_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
+var SETUP_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
+function resolveSetupWorkerConfig(existing, args, totalMemBytes = totalmem()) {
+  const maxWorkersRaw = typeof args.maxWorkers === "string" ? args.maxWorkers : typeof args.maxConcurrentWorkers === "string" ? args.maxConcurrentWorkers : void 0;
+  const explicitBoxKindArg = typeof args.boxKind === "string" ? args.boxKind : typeof args["box-kind"] === "string" ? String(args["box-kind"]) : void 0;
+  const boxKind = resolveBoxIdentity(process.env, {
+    ...existing,
+    ...explicitBoxKindArg ? { boxKind: normalizeWorkerPoolBoxKind(explicitBoxKindArg) } : {}
+  }).boxKind;
+  const diskGate = observeRunnerDiskGate({
+    diskPath: typeof args.diskPath === "string" ? args.diskPath : "/"
+  });
+  const capRecommendation = recommendSetupWorkerCap({
+    totalMemBytes,
+    diskPath: diskGate.path,
+    diskGateOk: diskGate.ok,
+    diskFreeBytes: diskGate.freeBytes,
+    config: existing
+  });
+  if (maxWorkersRaw) {
+    return {
+      maxConcurrentWorkers: Math.max(1, Math.floor(Number(maxWorkersRaw))),
+      maxConcurrentWorkersSource: "setup-flag",
+      boxKind
+    };
+  }
+  if (existing.maxConcurrentWorkers !== void 0 && existing.maxConcurrentWorkers !== null) {
+    return {
+      maxConcurrentWorkers: Math.max(1, Math.floor(Number(existing.maxConcurrentWorkers))),
+      maxConcurrentWorkersSource: existing.maxConcurrentWorkersSource ?? "operator",
+      boxKind
+    };
+  }
+  return {
+    maxConcurrentWorkers: capRecommendation.recommendedMaxWorkers,
+    maxConcurrentWorkersSource: "setup-auto",
+    boxKind
+  };
+}
+function loadCredentialsFile() {
+  if (!existsSync9(CREDENTIALS_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync7(CREDENTIALS_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveCredentialsFile(parsed) {
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  writeFileSync2(CREDENTIALS_FILE, `${JSON.stringify(parsed, null, 2)}
+`, { mode: 384 });
+}
+function loadApiKey() {
+  if (process.env.KYNVER_API_KEY) return process.env.KYNVER_API_KEY;
+  return loadCredentialsFile().apiKey;
+}
+function saveApiKey(apiKey) {
+  saveCredentialsFile({ ...loadCredentialsFile(), apiKey });
+}
+function loadRunnerToken(agentOsId) {
+  const envToken = process.env.KYNVER_RUNNER_TOKEN?.trim();
+  if (envToken) return envToken;
+  const creds = loadCredentialsFile();
+  if (!creds.runnerToken) return void 0;
+  if (agentOsId && creds.runnerTokenAgentOsId && creds.runnerTokenAgentOsId !== agentOsId) {
+    return void 0;
+  }
+  return creds.runnerToken;
+}
+function saveRunnerToken(agentOsId, token) {
+  saveCredentialsFile({
+    ...loadCredentialsFile(),
+    runnerToken: token,
+    runnerTokenAgentOsId: agentOsId
+  });
+}
+function resolveBaseUrl(argsBaseUrl) {
+  const baseUrl = resolveConfiguredBaseUrl(argsBaseUrl);
+  if (!baseUrl) failConfig("requires --base-url, KYNVER_API_URL, KYNVER_CRON_FIRE_BASE_URL, or ~/.kynver/config.json apiBaseUrl");
+  return baseUrl;
+}
+function resolveConfiguredBaseUrl(argsBaseUrl) {
+  const baseUrl = argsBaseUrl || process.env.KYNVER_API_URL || process.env.KYNVER_CRON_FIRE_BASE_URL || process.env.OPENCLAW_CRON_FIRE_BASE_URL || loadUserConfig().apiBaseUrl;
+  return baseUrl ? trimTrailingSlash(String(baseUrl)) : void 0;
+}
+function resolveConfiguredCallbackSecret(argsSecret, agentOsId) {
+  const scoped = argsSecret || loadRunnerToken(agentOsId) || (agentOsId ? void 0 : loadRunnerToken(loadUserConfig().agentOsId));
+  if (scoped) return String(scoped);
+  const globalSecret = process.env.KYNVER_RUNTIME_SECRET || process.env.KYNVER_CRON_SECRET || process.env.OPENCLAW_CRON_SECRET;
+  if (globalSecret) {
+    console.warn(
+      "[kynver] using deployment-level callback secret; run `kynver runner credential --agent-os-id <id>` for a scoped token"
+    );
+    return String(globalSecret);
+  }
+  return void 0;
+}
+async function resolveCallbackSecretWithMint(argsSecret, agentOsId, opts) {
+  const configured = resolveConfiguredCallbackSecret(argsSecret, agentOsId);
+  if (configured) return configured;
+  const apiKey = loadApiKey();
+  const baseUrl = resolveConfiguredBaseUrl(opts?.baseUrl);
+  if (apiKey && agentOsId && baseUrl) {
+    try {
+      const token = await fetchRunnerCredential(agentOsId, { baseUrl, apiKey });
+      saveRunnerToken(agentOsId, token);
+      return token;
+    } catch (error) {
+      failConfig(`runner credential mint failed: ${error.message}`);
+    }
+  }
+  failConfig(
+    "requires --secret, KYNVER_RUNNER_TOKEN, a scoped runner token (`kynver runner credential`), ~/.kynver/credentials runnerToken, KYNVER_API_KEY with an API base URL to mint one, or (legacy) KYNVER_RUNTIME_SECRET / KYNVER_CRON_SECRET / OPENCLAW_CRON_SECRET"
+  );
+}
+async function refreshRunnerToken(agentOsId, opts) {
+  const apiKey = loadApiKey();
+  const baseUrl = resolveConfiguredBaseUrl(opts?.baseUrl);
+  if (!apiKey || !agentOsId || !baseUrl) return null;
+  try {
+    const token = await fetchRunnerCredential(agentOsId, { baseUrl, apiKey });
+    saveRunnerToken(agentOsId, token);
+    return token;
+  } catch {
+    return null;
+  }
+}
+async function refreshRunnerTokenForAuthFailure(rejectedSecret, agentOsId, opts) {
+  const apiKey = loadApiKey();
+  const baseUrl = resolveConfiguredBaseUrl(opts?.baseUrl);
+  if (!apiKey) return { ok: false, reason: "KYNVER_API_KEY is required to refresh a rejected runner token" };
+  if (!agentOsId) return { ok: false, reason: "agentOsId is required to refresh a rejected runner token" };
+  if (!baseUrl) return { ok: false, reason: "KYNVER_API_URL or --base-url is required to refresh a rejected runner token" };
+  try {
+    const token = await fetchRunnerCredential(agentOsId, { baseUrl, apiKey });
+    if (token && token !== rejectedSecret) {
+      saveRunnerToken(agentOsId, token);
+      return { ok: true, token };
+    }
+    return { ok: false, reason: "runner credential refresh returned the rejected token" };
+  } catch (error) {
+    return { ok: false, reason: error.message };
+  }
+}
+async function fetchRunnerCredential(agentOsId, opts) {
+  const apiKey = opts?.apiKey || loadApiKey();
+  if (!apiKey) throw new Error("API key required \u2014 run `kynver login` first");
+  const base = resolveBaseUrl(opts?.baseUrl);
+  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/runner-credentials`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({})
+  });
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = null;
+  }
+  if (!res.ok || !parsed?.token) {
+    throw new Error(
+      `runner credential mint failed (${res.status}): ${parsed?.error ?? text.slice(0, 200)}`
+    );
+  }
+  return parsed.token;
+}
+async function mintRunnerCredential(args) {
+  const agentOsId = (args.agentOsId ? String(args.agentOsId) : loadUserConfig().agentOsId) || "";
+  if (!agentOsId) failConfig("runner credential requires --agent-os-id or agentOsId in ~/.kynver/config.json");
+  try {
+    const token = await fetchRunnerCredential(agentOsId, {
+      baseUrl: args.baseUrl ? String(args.baseUrl) : void 0
+    });
+    saveRunnerToken(agentOsId, token);
+    console.log(
+      JSON.stringify(
+        {
+          ok: true,
+          agentOsId,
+          credentialsPath: displayUserPath(CREDENTIALS_FILE),
+          tokenPrefix: `${token.slice(0, 12)}\u2026`,
+          note: "Scoped runner token saved; callbacks use X-Kynver-Runner-Token."
+        },
+        null,
+        2
+      )
+    );
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+function failConfig(message) {
+  console.error(message);
+  process.exit(1);
+}
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const item = argv[i];
+    if (!item.startsWith("--")) continue;
+    const key = item.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) args[key] = true;
+    else {
+      args[key] = next;
+      i++;
+    }
+  }
+  return args;
+}
+async function runSetup(args) {
+  const existing = loadUserConfig();
+  const diskGate = observeRunnerDiskGate({
+    diskPath: typeof args.diskPath === "string" ? args.diskPath : "/"
+  });
+  const capRecommendation = recommendSetupWorkerCap({
+    totalMemBytes: os3.totalmem(),
+    diskPath: diskGate.path,
+    diskGateOk: diskGate.ok,
+    diskFreeBytes: diskGate.freeBytes,
+    config: existing
+  });
+  const workerConfig = resolveSetupWorkerConfig(existing, args);
+  const config = normalizeConfigPaths({
+    ...existing,
+    ...inferSetupFields(existing, args),
+    ...workerConfig,
+    workerProvider: typeof args.provider === "string" ? args.provider : existing.workerProvider || "cursor"
+  });
+  saveUserConfig(config);
+  const boxIdentity = resolveBoxIdentity(process.env, config);
+  let runnerCredentialNote;
+  const apiKey = loadApiKey();
+  const agentOsId = config.agentOsId;
+  if (apiKey && agentOsId) {
+    try {
+      const token = await fetchRunnerCredential(agentOsId, {
+        baseUrl: typeof args.apiBaseUrl === "string" ? args.apiBaseUrl : config.apiBaseUrl,
+        apiKey
+      });
+      saveRunnerToken(agentOsId, token);
+      runnerCredentialNote = "Scoped runner token minted and saved to ~/.kynver/credentials.";
+    } catch {
+      runnerCredentialNote = "Runner token not minted (server offline or master secret unset). Run `kynver runner credential` after deploy.";
+    }
+  }
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        configPath: displayUserPath(CONFIG_FILE),
+        config: presentUserConfig(config),
+        boxKind: config.boxKind,
+        boxKindSource: boxIdentity.source,
+        workerCapRecommendation: capRecommendation,
+        ...boxIdentity.warnings.length ? { boxIdentityWarnings: boxIdentity.warnings } : {},
+        note: runnerCredentialNote ?? "boxKind and maxConcurrentWorkers persisted; override with --box-kind and --max-workers. Run `kynver login` + `kynver runner credential` for scoped callbacks."
+      },
+      null,
+      2
+    )
+  );
+}
+async function runLogin(args) {
+  const apiKey = typeof args.apiKey === "string" ? args.apiKey : process.env.KYNVER_API_KEY;
+  if (!apiKey) failConfig("kynver login requires --api-key or KYNVER_API_KEY");
+  saveApiKey(apiKey);
+  console.log(JSON.stringify({ ok: true, credentialsPath: displayUserPath(CREDENTIALS_FILE) }, null, 2));
+}
+
+// src/callback-headers.ts
+function buildHarnessCallbackHeaders(secret) {
+  const trimmed = String(secret).trim();
+  if (trimmed.startsWith("krc1.")) {
+    return {
+      "Content-Type": "application/json",
+      "X-Kynver-Runner-Token": trimmed
+    };
+  }
+  return {
+    "Content-Type": "application/json",
+    // Canonical header. We keep sending the legacy `X-OpenClaw-Cron-Secret`
+    // (and `X-Kynver-Runtime-Secret`) so an un-upgraded Kynver server that
+    // only reads the old header still authenticates this runner during the
+    // rename compat window.
+    "X-Kynver-Cron-Secret": trimmed,
+    "X-OpenClaw-Cron-Secret": trimmed,
+    "X-Kynver-Runtime-Secret": trimmed
   };
 }
-function isFinishedWorkerStatus(status) {
-  if (status.finalResult) return true;
-  if (status.alive === false) return true;
-  if (status.status === "exited" || status.status === "done") return true;
-  return false;
+
+// src/callbacks.ts
+function callbackTimeoutMs() {
+  const parsed = Number(process.env.KYNVER_CALLBACK_TIMEOUT_MS);
+  if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  return 3e4;
 }
-function isLandingBlockedWorkerStatus(status) {
-  if (!status.finalResult) return false;
-  return status.attention.state === "needs_attention" || status.attention.state === "blocked";
+async function withTimeout(fn) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), callbackTimeoutMs());
+  try {
+    return await fn(controller.signal);
+  } finally {
+    clearTimeout(timeout);
+  }
 }
-function deriveRunStatus(fallback, workers) {
-  if (workers.length === 0) return fallback;
-  if (workers.some((w) => w.attention === "needs_attention" || w.attention === "stale" || w.attention === "blocked")) {
-    return "needs_attention";
+async function postJson(url, secret, body) {
+  const res = await withTimeout(
+    (signal) => fetch(url, {
+      method: "POST",
+      headers: buildHarnessCallbackHeaders(secret),
+      body: JSON.stringify(body),
+      signal
+    })
+  );
+  let response = null;
+  try {
+    response = await res.json();
+  } catch {
+    response = null;
   }
-  if (workers.every((w) => w.status === "done")) return "done";
-  if (workers.some((w) => w.status === "running")) return "running";
-  return fallback;
+  return { ok: res.ok, status: res.status, response };
 }
-
-// src/resource-gate.ts
-var DEFAULT_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
-var DEFAULT_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
-var DEFAULT_MEM_UTILIZATION = 0.85;
-var AUTO_MAX_WORKERS_CEILING = 64;
-function positiveInt(value, fallback) {
-  const n = Number(value);
-  if (!Number.isFinite(n) || n <= 0) return fallback;
-  return Math.floor(n);
+async function postJsonWithCredentialRefresh(url, secret, body, opts) {
+  const first = await postJson(url, secret, body);
+  if (first.ok || first.status !== 401) return first;
+  const refreshed = await refreshRunnerTokenForAuthFailure(secret, opts.agentOsId, { baseUrl: opts.baseUrl });
+  if (!refreshed.ok) return { ...first, authRefreshFailure: refreshed.reason };
+  const retry = await postJson(url, refreshed.token, body);
+  return { ...retry, refreshedAuth: true };
 }
-function resolveResourceConfig(config = loadUserConfig(), configuredMaxWorkersOverride) {
-  const perWorkerMemBytes = positiveInt(config.perWorkerMemBytes, DEFAULT_PER_WORKER_MEM_BYTES);
-  const memReserveBytes = positiveInt(config.memReserveBytes, DEFAULT_MEM_RESERVE_BYTES);
-  const memUtilization = Math.min(
-    1,
-    Math.max(0.1, Number(config.memUtilization) > 0 ? Number(config.memUtilization) : DEFAULT_MEM_UTILIZATION)
+async function getJson(url, secret) {
+  const res = await withTimeout(
+    (signal) => fetch(url, {
+      method: "GET",
+      headers: buildHarnessCallbackHeaders(secret),
+      signal
+    })
   );
-  const envCap = process.env.KYNVER_MAX_WORKERS ? positiveInt(process.env.KYNVER_MAX_WORKERS, 0) || null : null;
-  const configuredMaxWorkers = configuredMaxWorkersOverride !== void 0 ? configuredMaxWorkersOverride : envCap ?? (config.maxConcurrentWorkers !== void 0 && config.maxConcurrentWorkers !== null ? positiveInt(config.maxConcurrentWorkers, 0) || null : null);
-  return { perWorkerMemBytes, memReserveBytes, memUtilization, configuredMaxWorkers };
-}
-function computeAutoMaxWorkers(totalMemBytes, opts = {}) {
-  const perWorkerMemBytes = opts.perWorkerMemBytes ?? DEFAULT_PER_WORKER_MEM_BYTES;
-  const memReserveBytes = opts.memReserveBytes ?? DEFAULT_MEM_RESERVE_BYTES;
-  const memUtilization = opts.memUtilization ?? DEFAULT_MEM_UTILIZATION;
-  const budgetBytes = Math.max(0, Math.floor(totalMemBytes * memUtilization) - memReserveBytes);
-  const raw = Math.max(1, Math.floor(budgetBytes / perWorkerMemBytes));
-  return Math.min(raw, AUTO_MAX_WORKERS_CEILING);
+  let response = null;
+  try {
+    response = await res.json();
+  } catch {
+    response = null;
+  }
+  return { ok: res.ok, status: res.status, response };
 }
-function readAvailableMemBytes() {
-  return readMemAvailableBytes();
+
+// src/dispatch-lane-normalization.ts
+function trimLower(value) {
+  return (value ?? "").trim().toLowerCase();
 }
-function isActiveHarnessWorker(worker) {
-  if (typeof worker.completionBlocker === "string" && worker.completionBlocker.trim()) {
-    return false;
+function roleLaneToDispatchLane(roleLane) {
+  switch (trimLower(roleLane)) {
+    case "implementer":
+    case "repair_implementer":
+    case "plan_author":
+    case "runtime_verifier":
+      return "implementation";
+    case "plan_reviewer":
+    case "report_reviewer":
+    case "deep_reviewer":
+      return "review";
+    default:
+      return null;
   }
-  const status = computeWorkerStatus(worker);
-  return status.alive && !status.finalResult && status.attention.state !== "done";
 }
-function countActiveWorkersForRun(run) {
-  let active = 0;
-  for (const name of listRunWorkerNames(run)) {
-    const worker = readJson(
-      path8.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-      void 0
-    );
-    if (!worker || !isActiveHarnessWorker(worker)) continue;
-    active++;
+function normalizeDispatchNextLaneFilter(raw) {
+  const key = trimLower(raw);
+  if (!key) return void 0;
+  if (key === "implementation" || key === "review" || key === "landing" || key === "any") {
+    return key;
   }
-  return active;
-}
-function countActiveWorkersGlobal() {
-  let active = 0;
-  for (const run of listRunRecords()) active += countActiveWorkersForRun(run);
-  return active;
+  const mapped = roleLaneToDispatchLane(key);
+  if (mapped) return mapped;
+  if (key === "implement" || key === "repair" || key === "coding") return "implementation";
+  if (key === "land" || key === "merge") return "landing";
+  return void 0;
 }
-function observeRunnerResourceGate(input) {
-  const { perWorkerMemBytes, memReserveBytes, memUtilization, configuredMaxWorkers } = resolveResourceConfig(
-    input.config,
-    input.configuredMaxWorkersOverride
-  );
-  const totalMemBytes = input.totalMemBytes ?? os2.totalmem();
-  const freeMemBytes = input.freeMemBytes ?? readAvailableMemBytes();
-  const activeWorkers = input.activeWorkers ?? countActiveWorkersGlobal();
-  const budgetBytes = Math.max(0, Math.floor(totalMemBytes * memUtilization) - memReserveBytes);
-  const capacityFromTotal = Math.max(0, Math.floor(budgetBytes / perWorkerMemBytes));
-  const capacityFromFree = Math.max(0, Math.floor(Math.max(0, freeMemBytes - memReserveBytes) / perWorkerMemBytes));
-  const autoCap = computeAutoMaxWorkers(totalMemBytes, { perWorkerMemBytes, memReserveBytes, memUtilization });
-  const targetCap = configuredMaxWorkers ?? autoCap;
-  const maxConcurrentWorkers = Math.max(0, Math.min(targetCap, capacityFromTotal));
-  const slotsByCapacity = Math.max(0, maxConcurrentWorkers - activeWorkers);
-  const slotsByFreeMem = capacityFromFree;
-  let slotsAvailable = Math.min(slotsByCapacity, slotsByFreeMem);
-  const skipDisk = input.skipDiskGate || process.env.KYNVER_RESOURCE_GATE_SKIP_DISK === "1";
-  const diskGate = skipDisk ? void 0 : observeRunnerDiskGate({
-    diskPath: input.diskPath?.trim() || process.env.KYNVER_DISK_GUARD_PATH?.trim() || "/"
-  });
-  if (diskGate && !diskGate.ok) slotsAvailable = 0;
-  let reason = null;
-  if (slotsAvailable <= 0) {
-    if (diskGate && !diskGate.ok) {
-      reason = diskGate.reason ?? "disk gate blocked worker admission";
-    } else if (activeWorkers >= maxConcurrentWorkers) {
-      reason = `at worker limit (${activeWorkers}/${maxConcurrentWorkers} running)`;
-    } else if (capacityFromFree <= 0) {
-      reason = "insufficient free memory \u2014 waiting for workers to finish";
-    } else {
-      reason = "no worker slots available";
-    }
-  }
-  return {
-    ok: slotsAvailable > 0,
-    totalMemBytes,
-    freeMemBytes,
-    memReserveBytes,
-    perWorkerMemBytes,
-    configuredMaxWorkers,
-    autoCap,
-    capacityWorkers: capacityFromTotal,
-    maxConcurrentWorkers,
-    activeWorkers,
-    slotsAvailable,
-    reason,
-    ...diskGate ? { diskGate } : {}
-  };
+function resolveDispatchNextLaneFilter(raw) {
+  return normalizeDispatchNextLaneFilter(raw) ?? "any";
 }
 
 // src/worker-persona-catalog.ts
@@ -3639,15 +3825,15 @@ function resolveModelFallback(startedModel, launchModel, providerDefault) {
 }
 
 // src/retry-limits.ts
-function positiveInt2(value, fallback) {
+function positiveInt3(value, fallback) {
   const n = Number(value);
   if (!Number.isFinite(n) || n <= 0) return fallback;
   return Math.floor(n);
 }
 function readHarnessRetryLimits() {
   return {
-    maxTaskAttempts: positiveInt2(process.env.KYNVER_MAX_TASK_ATTEMPTS, 4),
-    dispatchCooldownMs: positiveInt2(process.env.KYNVER_DISPATCH_COOLDOWN_MS, 5e3)
+    maxTaskAttempts: positiveInt3(process.env.KYNVER_MAX_TASK_ATTEMPTS, 4),
+    dispatchCooldownMs: positiveInt3(process.env.KYNVER_DISPATCH_COOLDOWN_MS, 5e3)
   };
 }
 
@@ -3688,22 +3874,12 @@ function resolveHarnessLeaseOwnerForRenewal(input) {
 }
 
 // src/runner-identity.ts
-import os4 from "node:os";
+import os5 from "node:os";
 
 // src/box-resource-snapshot-shared.ts
-import os3 from "node:os";
-function normalizeWorkerPoolBoxKind(raw) {
-  const kind = (raw ?? "").trim().toLowerCase();
-  if (kind === "ghost" || kind === "forge") return kind;
-  if (kind.includes("forge")) return "forge";
-  if (kind.includes("ghost") || kind.includes("openclaw")) return "ghost";
-  return "forge";
-}
-function resolveBoxKindFromEnv(env = process.env) {
-  return normalizeWorkerPoolBoxKind(env.KYNVER_BOX_KIND ?? env.KYNVER_AGENT_OS_SLUG ?? "forge");
-}
+import os4 from "node:os";
 function defaultBoxId(boxKind, hostLabel) {
-  const host = (hostLabel ?? os3.hostname()).trim().toLowerCase().replace(/\s+/g, "-") || "unknown-host";
+  const host = (hostLabel ?? os4.hostname()).trim().toLowerCase().replace(/\s+/g, "-") || "unknown-host";
   return `${boxKind}:${host}`;
 }
 
@@ -3714,10 +3890,10 @@ function trimOrNull5(value) {
 }
 function resolveRunnerPresencePayload(input = {}) {
   const env = input.env ?? process.env;
-  const runnerId = trimOrNull5(env.KYNVER_RUNTIME_ID) ?? trimOrNull5(env.OPENCLAW_RUNTIME_ID) ?? trimOrNull5(env.HOSTNAME) ?? os4.hostname();
+  const runnerId = trimOrNull5(env.KYNVER_RUNTIME_ID) ?? trimOrNull5(env.OPENCLAW_RUNTIME_ID) ?? trimOrNull5(env.HOSTNAME) ?? os5.hostname();
   return {
     runnerId,
-    hostname: trimOrNull5(env.HOSTNAME) ?? os4.hostname(),
+    hostname: trimOrNull5(env.HOSTNAME) ?? os5.hostname(),
     profile: trimOrNull5(env.KYNVER_RUNNER_PROFILE) ?? trimOrNull5(env.OPENCLAW_RUNNER_PROFILE),
     harnessRepo: trimOrNull5(env.KYNVER_HARNESS_REPO) ?? trimOrNull5(env.KYNVER_DEFAULT_REPO),
     runId: input.runId ?? null
@@ -3893,13 +4069,13 @@ function buildPrompt(input) {
     input.planId ? `Active planId: ${input.planId}${input.taskId ? ` \xB7 taskId: ${input.taskId}` : ""}` : "No planId on this worker \u2014 still emit progress when you touch plan-scoped work."
   ];
   const mergeGateLines = compact ? [
-    "Merge-gate cost control: run `node scripts/agent-os-pr-merge-gate.mjs --pr <url> --agent-os-id <id>` (or `verify-pr-local.mjs --from-pr` + `collect-pr-vercel-evidence.mjs` + POST pr-merge-gate/refresh) before any GitHub Actions run; request merge-gate only via refresh then POST pr-merge-gate/request-run (one Actions run per PR head unless human approves extra)."
+    "Merge-gate cost control: do not use Vercel previews/builds for PR verification. Run `node scripts/agent-os-pr-merge-gate.mjs --pr <url> --agent-os-id <id>` (or `verify-pr-local.mjs --from-pr` + POST pr-merge-gate/refresh) before any GitHub Actions run; request merge-gate only via refresh then POST pr-merge-gate/request-run (one Actions run per PR head unless human approves extra)."
   ] : [
     "GitHub Actions merge-gate cost control (Kynver/Hermes PRs):",
-    "- Prefer local cached package verification (`node scripts/verify-pr-local.mjs --emit-json`) and Vercel preview evidence before GitHub Actions.",
+    "- Prefer local cached package verification (`node scripts/verify-pr-local.mjs --emit-json`) before GitHub Actions. Do not use Vercel previews/builds as PR evidence.",
     "- Do not push empty commits to re-trigger CI. One budgeted merge-gate Actions run per PR candidate (head SHA) unless a human approves extra.",
-    "- Record evidence: POST `/api/agent-os/by-id/<agentOsId>/pr-merge-gate/refresh` with prUrl + local/vercel payloads.",
-    "- Request the final Actions run only when local + Vercel are green: POST `.../pr-merge-gate/request-run` (applies `merge-gate` label).",
+    "- Record evidence: POST `/api/agent-os/by-id/<agentOsId>/pr-merge-gate/refresh` with prUrl + local payloads.",
+    "- Request the final Actions run only when local verification is green: POST `.../pr-merge-gate/request-run` (applies `merge-gate` label).",
     "- Empty failed Actions jobs (no runner/steps/logs) are infra/quota \u2014 do not enter repair loops; escalate to operator."
   ];
   const planArtifactLines = compact ? [
@@ -3953,7 +4129,7 @@ function buildPrompt(input) {
 // src/providers/cursor.ts
 import { closeSync as closeSync4, existsSync as existsSync17, mkdirSync as mkdirSync3, openSync as openSync4, statSync as statSync4, unlinkSync } from "node:fs";
 import { spawn as spawn4 } from "node:child_process";
-import os5 from "node:os";
+import os6 from "node:os";
 import path16 from "node:path";
 
 // src/providers/cursor-windows.ts
@@ -4064,7 +4240,7 @@ function positiveIntEnv(name, fallback) {
   return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : fallback;
 }
 function cursorStartLockPath() {
-  const root = process.env.KYNVER_CURSOR_START_LOCK_DIR?.trim() || path16.join(os5.homedir(), ".kynver", "locks");
+  const root = process.env.KYNVER_CURSOR_START_LOCK_DIR?.trim() || path16.join(os6.homedir(), ".kynver", "locks");
   mkdirSync3(root, { recursive: true });
   return path16.join(root, "cursor-agent-start.lock");
 }
@@ -4799,8 +4975,8 @@ function dirtyPathsCoveredByDisposableRemoval(changedFiles, removed) {
   if (removed.length === 0) return false;
   const removedSet = new Set(removed.map((p) => normalizeRelativePath(p)));
   return material.every((line) => {
-    const path65 = normalizeRelativePath(pathFromGitStatusLine(line));
-    return removedSet.has(path65);
+    const path67 = normalizeRelativePath(pathFromGitStatusLine(line));
+    return removedSet.has(path67);
   });
 }
 
@@ -8113,6 +8289,45 @@ function discardDisposableCli(args) {
   if (!result.ok) process.exit(1);
 }
 
+// src/daemon-box-identity.ts
+import os7 from "node:os";
+function emitDaemonIdentityMessage(level, message) {
+  console.error(JSON.stringify({ event: "daemon_identity", level, message }));
+}
+function validateDaemonInstallIdentity(config = loadUserConfig(), env = process.env) {
+  const box = resolveBoxIdentity(env, config);
+  const cap = resolveWorkerCap({
+    config,
+    totalMemBytes: os7.totalmem(),
+    env
+  });
+  const warnings = [...box.warnings];
+  const errors = [];
+  if (!config.boxKind?.trim() && !env.KYNVER_BOX_KIND?.trim()) {
+    warnings.push(
+      "boxKind is not persisted in ~/.kynver/config.json \u2014 run `kynver setup --box-kind forge|ghost` so Command Center attributes snapshots to the correct pool"
+    );
+  }
+  if (box.slugInferenceBlocked) {
+    const strict = env.KYNVER_DAEMON_STRICT_IDENTITY === "1" || env.KYNVER_DAEMON_STRICT_IDENTITY === "true";
+    const msg = "ambiguous box identity: KYNVER_AGENT_OS_SLUG is set without KYNVER_BOX_KIND or config.boxKind; treating this host as forge";
+    if (strict) errors.push(msg);
+    else warnings.push(msg);
+  }
+  const ok = errors.length === 0;
+  for (const warning of warnings) emitDaemonIdentityMessage("warn", warning);
+  for (const error of errors) emitDaemonIdentityMessage("error", error);
+  return {
+    ok,
+    box,
+    workerCapSource: cap.workerCapSource,
+    maxConcurrentWorkers: cap.configuredMaxWorkers ?? cap.autoCap,
+    autoCap: cap.autoCap,
+    warnings,
+    errors
+  };
+}
+
 // src/cron/cron-env.ts
 import { existsSync as existsSync27 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
@@ -8578,7 +8793,7 @@ async function runKynverCronTick(opts = {}) {
 }
 
 // src/pipeline-tick.ts
-import path53 from "node:path";
+import path54 from "node:path";
 
 // src/pipeline-dispatch.ts
 var RESERVED_REVIEW_STARTS = 1;
@@ -8709,10 +8924,10 @@ function resolvePipelineMaxStarts(resourceGate, operatorTick) {
 }
 
 // src/box-resource-snapshot.ts
-import os6 from "node:os";
+import os8 from "node:os";
 function buildBoxResourceSnapshotFromGate(gate, input = {}) {
-  const boxKind = (input.boxKind ?? resolveBoxKindFromEnv()).trim().toLowerCase() || "forge";
-  const hostLabel = input.hostLabel ?? os6.hostname();
+  const boxKind = (input.boxKind ?? resolveBoxKindFromConfig(loadUserConfig())).trim().toLowerCase() || "forge";
+  const hostLabel = input.hostLabel ?? os8.hostname();
   const boxId = input.boxId ?? defaultBoxId(boxKind, hostLabel);
   return {
     boxId,
@@ -8787,7 +9002,8 @@ async function syncActiveWorkerPlanProgress(runId, args) {
 
 // src/workspace-runtime-config.ts
 function shouldApplyWorkspaceRuntimePreferences(env = process.env) {
-  return resolveBoxKindFromEnv(env) !== "forge";
+  const config = loadUserConfig();
+  return resolveBoxKindFromConfig(config, env) !== "forge";
 }
 function configuredMaxWorkersOverrideForBox(preferences, env = process.env) {
   if (!shouldApplyWorkspaceRuntimePreferences(env)) return void 0;
@@ -8814,7 +9030,7 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 }
 
 // src/cleanup.ts
-import path51 from "node:path";
+import path52 from "node:path";
 
 // src/cleanup-guards.ts
 import path39 from "node:path";
@@ -8985,11 +9201,11 @@ var LIVE_SKIP_REASONS = /* @__PURE__ */ new Set([
 function collectPreservedLivePaths(actions, skips) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const push = (path65, reason, detail) => {
-    const key = `${path65}\0${reason}`;
+  const push = (path67, reason, detail) => {
+    const key = `${path67}\0${reason}`;
     if (seen.has(key) || out.length >= MAX_PRESERVED_LIVE_PATH_SAMPLES) return;
     seen.add(key);
-    out.push({ path: path65, reason, ...detail ? { detail } : {} });
+    out.push({ path: path67, reason, ...detail ? { detail } : {} });
   };
   for (const skip2 of skips) {
     if (!LIVE_SKIP_REASONS.has(skip2.reason)) continue;
@@ -9118,8 +9334,7 @@ function scanStaleRunDirectoryCandidates(opts) {
 }
 
 // src/cleanup-execute.ts
-import { existsSync as existsSync32, rmSync as rmSync3 } from "node:fs";
-import path43 from "node:path";
+import { existsSync as existsSync33, rmSync as rmSync4 } from "node:fs";
 
 // src/cleanup-dir-size.ts
 import { execFileSync } from "node:child_process";
@@ -9172,50 +9387,232 @@ function directorySizeBytes(root, maxEntries = 5e4) {
   return total;
 }
 
-// src/cleanup-execute.ts
-function skipRunMetadataRemoval(candidate) {
-  const harnessRoot = candidate.harnessRoot;
-  if (!harnessRoot || !isHarnessRunMetadataPath(candidate.path, harnessRoot)) return null;
+// src/cleanup-remove-path.ts
+import { existsSync as existsSync32, rmSync as rmSync3 } from "node:fs";
+
+// src/cleanup-path-ownership.ts
+import { lstatSync as lstatSync2, readdirSync as readdirSync11 } from "node:fs";
+function readPathOwnership(targetPath) {
+  try {
+    const st = lstatSync2(targetPath);
+    const effectiveUid = typeof process.getuid === "function" ? process.getuid() : null;
+    const effectiveGid = typeof process.getgid === "function" ? process.getgid() : null;
+    const foreign = effectiveUid !== null && (st.uid !== effectiveUid || effectiveGid !== null && st.gid !== effectiveGid);
+    return { uid: st.uid, gid: st.gid, foreign };
+  } catch {
+    return null;
+  }
+}
+function pathHasForeignOwnedEntry(targetPath, maxEntries = 32) {
+  const root = readPathOwnership(targetPath);
+  if (!root) return false;
+  if (root.foreign) return true;
+  try {
+    const names = readdirSync11(targetPath);
+    let checked = 0;
+    for (const name of names) {
+      if (checked >= maxEntries) break;
+      const child = `${targetPath.replace(/\/$/, "")}/${name}`;
+      const info = readPathOwnership(child);
+      checked += 1;
+      if (info?.foreign) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/cleanup-privileged-remove.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import path44 from "node:path";
+
+// src/cleanup-harness-path-validate.ts
+import path43 from "node:path";
+function isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, cacheDirName) {
+  const resolved = path43.resolve(targetPath);
+  const suffix = `${path43.sep}${cacheDirName}`;
+  const cachePath = resolved.endsWith(suffix) ? resolved : null;
+  if (!cachePath) return "path_outside_harness";
+  const rel = path43.relative(worktreesDir, cachePath);
+  if (rel.startsWith("..") || path43.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path43.sep);
+  if (parts.length < 3 || parts[parts.length - 1] !== cacheDirName) return "path_outside_harness";
+  if (!resolved.startsWith(path43.resolve(harnessRoot))) return "path_outside_harness";
+  return null;
+}
+function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
+  return isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, "node_modules");
+}
+function isHarnessNextCachePath(targetPath, harnessRoot, worktreesDir) {
+  return isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, ".next");
+}
+function isHarnessBuildCachePath(targetPath, harnessRoot, worktreesDir) {
+  const resolved = path43.resolve(targetPath);
+  const relToWt = path43.relative(worktreesDir, resolved);
+  if (relToWt.startsWith("..") || path43.isAbsolute(relToWt)) return "path_outside_harness";
+  const parts = relToWt.split(path43.sep);
+  if (parts.length < 3) return "path_outside_harness";
+  if (!resolved.startsWith(path43.resolve(harnessRoot))) return "path_outside_harness";
+  return null;
+}
+function isHarnessGeneratedCachePath(targetPath, harnessRoot, worktreesDir) {
+  const resolved = path43.resolve(targetPath);
+  return isHarnessNodeModulesPath(resolved, harnessRoot, worktreesDir) === null || isHarnessNextCachePath(resolved, harnessRoot, worktreesDir) === null || isHarnessBuildCachePath(resolved, harnessRoot, worktreesDir) === null;
+}
+
+// src/cleanup-privileged-remove.ts
+function resolvePrivilegedCleanupMode() {
+  const raw = (process.env.KYNVER_CLEANUP_PRIVILEGED ?? "auto").trim().toLowerCase();
+  if (raw === "0" || raw === "false" || raw === "off" || raw === "no") return "off";
+  if (raw === "1" || raw === "true" || raw === "force" || raw === "yes") return "force";
+  return "auto";
+}
+function runSudoNonInteractive(argv) {
+  const res = spawnSync4("sudo", ["-n", ...argv], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
   return {
-    ...candidate,
-    executed: false,
-    skipped: true,
-    skipReason: "run_metadata_protected"
+    ok: res.status === 0,
+    stderr: `${res.stderr ?? ""}${res.stdout ?? ""}`.trim()
   };
 }
-function removeDependencyCache(candidate, execute) {
-  const metadataSkip = skipRunMetadataRemoval(candidate);
-  if (metadataSkip) return metadataSkip;
+function tryPrivilegedReclaimHarnessCache(targetPath, harnessRoot, worktreesDir) {
+  if (!isHarnessGeneratedCachePath(targetPath, harnessRoot, worktreesDir)) {
+    return { ok: false, error: "path is not an allowed harness generated cache" };
+  }
+  const effectiveUid = typeof process.getuid === "function" ? process.getuid() : null;
+  const effectiveGid = typeof process.getgid === "function" ? process.getgid() : null;
+  if (effectiveUid === null || effectiveGid === null) {
+    return { ok: false, error: "privileged reclaim requires POSIX uid/gid" };
+  }
+  const chown = runSudoNonInteractive([
+    "chown",
+    "-R",
+    `${effectiveUid}:${effectiveGid}`,
+    path44.resolve(targetPath)
+  ]);
+  if (chown.ok) {
+    return { ok: true, method: "chown_then_rm" };
+  }
+  const rm = runSudoNonInteractive(["rm", "-rf", path44.resolve(targetPath)]);
+  if (rm.ok) {
+    return { ok: true, method: "sudo_rm" };
+  }
+  const detail = chown.stderr || rm.stderr || "sudo -n failed (password required or not permitted)";
+  return {
+    ok: false,
+    error: detail
+  };
+}
+var HARNESS_ROOT_OWNED_CACHE_RUNBOOK = "Root-owned harness caches require operator reclaim: configure passwordless sudo for chown/rm under ~/.kynver/harness/worktrees, or run `node scripts/reclaim-harness-root-owned-cache.mjs --execute` as the harness owner with sudo available. See docs/runbooks/harness-root-owned-cache-reclaim.md.";
+
+// src/cleanup-remove-path.ts
+function permissionFailure(error) {
+  const code = error?.code;
+  return code === "EACCES" || code === "EPERM";
+}
+function removeHarnessGeneratedPath(candidate, execute, deps = {}) {
   if (!existsSync32(candidate.path)) {
-    return {
-      ...candidate,
-      executed: false,
-      skipped: true,
-      skipReason: "missing_worktree"
-    };
+    return { executed: false, skipped: true, skipReason: "missing_worktree" };
   }
   if (!execute) {
-    return { ...candidate, executed: false, skipped: true, skipReason: "dry_run" };
+    return { executed: false, skipped: true, skipReason: "dry_run" };
   }
+  const harnessRoot = candidate.harnessRoot;
+  const worktreesDir = harnessRoot ? harnessWorktreesDir(harnessRoot) : null;
+  const bytesBefore = candidate.bytes ?? directorySizeBytes(candidate.path);
+  const bytesReported = bytesBefore ?? void 0;
+  const removePath = deps.removePath ?? rmSync3;
+  const hasForeignOwnedEntry = deps.hasForeignOwnedEntry ?? pathHasForeignOwnedEntry;
   try {
-    const bytesBefore = candidate.bytes ?? directorySizeBytes(candidate.path);
-    rmSync3(candidate.path, { recursive: true, force: true });
-    return {
-      ...candidate,
-      bytes: bytesBefore,
-      executed: true,
-      skipped: false
-    };
+    removePath(candidate.path, { recursive: true, force: true });
+    return { executed: true, skipped: false, bytes: bytesReported };
   } catch (error) {
+    if (!permissionFailure(error) || !harnessRoot || !worktreesDir) {
+      return {
+        executed: false,
+        skipped: true,
+        skipReason: "remove_failed",
+        error: error.message
+      };
+    }
+    const foreign = hasForeignOwnedEntry(candidate.path);
+    const mode = resolvePrivilegedCleanupMode();
+    const shouldTryPrivileged = mode === "force" || mode === "auto" && foreign;
+    if (!shouldTryPrivileged) {
+      return foreign ? {
+        executed: false,
+        skipped: true,
+        skipReason: "foreign_owner",
+        error: `${error.message}; ${HARNESS_ROOT_OWNED_CACHE_RUNBOOK}`
+      } : {
+        executed: false,
+        skipped: true,
+        skipReason: "remove_failed",
+        error: error.message
+      };
+    }
+    const reclaim = tryPrivilegedReclaimHarnessCache(candidate.path, harnessRoot, worktreesDir);
+    if (reclaim.ok && reclaim.method === "sudo_rm") {
+      return {
+        executed: true,
+        skipped: false,
+        bytes: bytesReported,
+        privilegedReclaim: true
+      };
+    }
+    if (reclaim.ok) {
+      try {
+        removePath(candidate.path, { recursive: true, force: true });
+        return {
+          executed: true,
+          skipped: false,
+          bytes: bytesReported,
+          privilegedReclaim: true
+        };
+      } catch (retryError) {
+        return {
+          executed: false,
+          skipped: true,
+          skipReason: "foreign_owner",
+          error: `${retryError.message}; privileged chown succeeded but rm still failed`
+        };
+      }
+    }
     return {
-      ...candidate,
       executed: false,
       skipped: true,
-      skipReason: "remove_failed",
-      error: error.message
+      skipReason: "foreign_owner",
+      error: `${error.message}; privileged reclaim failed: ${reclaim.error}; ${HARNESS_ROOT_OWNED_CACHE_RUNBOOK}`
     };
   }
 }
+
+// src/cleanup-execute.ts
+function skipRunMetadataRemoval(candidate) {
+  const harnessRoot = candidate.harnessRoot;
+  if (!harnessRoot || !isHarnessRunMetadataPath(candidate.path, harnessRoot)) return null;
+  return {
+    ...candidate,
+    executed: false,
+    skipped: true,
+    skipReason: "run_metadata_protected"
+  };
+}
+function removeDependencyCache(candidate, execute) {
+  const metadataSkip = skipRunMetadataRemoval(candidate);
+  if (metadataSkip) return metadataSkip;
+  const outcome = removeHarnessGeneratedPath(candidate, execute);
+  return {
+    ...candidate,
+    bytes: outcome.bytes ?? candidate.bytes,
+    executed: outcome.executed,
+    skipped: outcome.skipped,
+    skipReason: outcome.skipReason,
+    error: outcome.error
+  };
+}
 function removeNodeModules(candidate, execute) {
   return removeDependencyCache(candidate, execute);
 }
@@ -9228,7 +9625,7 @@ function removeBuildCache(candidate, execute) {
 function removeRunDirectory(candidate, execute) {
   const metadataSkip = skipRunMetadataRemoval(candidate);
   if (metadataSkip) return metadataSkip;
-  if (!existsSync32(candidate.path)) {
+  if (!existsSync33(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -9241,7 +9638,7 @@ function removeRunDirectory(candidate, execute) {
   }
   try {
     const bytesBefore = candidate.bytes ?? directorySizeBytes(candidate.path);
-    rmSync3(candidate.path, { recursive: true, force: true });
+    rmSync4(candidate.path, { recursive: true, force: true });
     return {
       ...candidate,
       bytes: bytesBefore,
@@ -9261,7 +9658,7 @@ function removeRunDirectory(candidate, execute) {
 function removeWorktree(candidate, execute) {
   const metadataSkip = skipRunMetadataRemoval(candidate);
   if (metadataSkip) return metadataSkip;
-  if (!existsSync32(candidate.path)) {
+  if (!existsSync33(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -9278,8 +9675,8 @@ function removeWorktree(candidate, execute) {
     if (repo) {
       git(repo, ["worktree", "remove", "--force", candidate.path], { allowFailure: true });
     }
-    if (existsSync32(candidate.path)) {
-      rmSync3(candidate.path, { recursive: true, force: true });
+    if (existsSync33(candidate.path)) {
+      rmSync4(candidate.path, { recursive: true, force: true });
     }
     return {
       ...candidate,
@@ -9297,37 +9694,10 @@ function removeWorktree(candidate, execute) {
     };
   }
 }
-function isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, cacheDirName) {
-  const resolved = path43.resolve(targetPath);
-  const suffix = `${path43.sep}${cacheDirName}`;
-  const cachePath = resolved.endsWith(suffix) ? resolved : null;
-  if (!cachePath) return "path_outside_harness";
-  const rel = path43.relative(worktreesDir, cachePath);
-  if (rel.startsWith("..") || path43.isAbsolute(rel)) return "path_outside_harness";
-  const parts = rel.split(path43.sep);
-  if (parts.length < 3 || parts[parts.length - 1] !== cacheDirName) return "path_outside_harness";
-  if (!resolved.startsWith(path43.resolve(harnessRoot))) return "path_outside_harness";
-  return null;
-}
-function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
-  return isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, "node_modules");
-}
-function isHarnessNextCachePath(targetPath, harnessRoot, worktreesDir) {
-  return isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, ".next");
-}
-function isHarnessBuildCachePath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path43.resolve(targetPath);
-  const relToWt = path43.relative(worktreesDir, resolved);
-  if (relToWt.startsWith("..") || path43.isAbsolute(relToWt)) return "path_outside_harness";
-  const parts = relToWt.split(path43.sep);
-  if (parts.length < 3) return "path_outside_harness";
-  if (!resolved.startsWith(path43.resolve(harnessRoot))) return "path_outside_harness";
-  return null;
-}
 
 // src/cleanup-scan.ts
-import { existsSync as existsSync33, readdirSync as readdirSync11, statSync as statSync9 } from "node:fs";
-import path44 from "node:path";
+import { existsSync as existsSync34, readdirSync as readdirSync12, statSync as statSync9 } from "node:fs";
+import path45 from "node:path";
 function pathAgeMs2(target, now) {
   try {
     const mtime = statSync9(target).mtimeMs;
@@ -9337,16 +9707,16 @@ function pathAgeMs2(target, now) {
   }
 }
 function isPathInside(child, parent) {
-  const rel = path44.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path44.isAbsolute(rel);
+  const rel = path45.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path45.isAbsolute(rel);
 }
 function collectBuildCacheForWorktree(worktreePath, opts, seen, meta) {
   const out = [];
   for (const rel of HARNESS_BUILD_CACHE_RELATIVE_PATHS) {
     if (rel === ".next") continue;
-    const target = path44.join(worktreePath, rel);
-    if (!existsSync33(target)) continue;
-    const resolved = path44.resolve(target);
+    const target = path45.join(worktreePath, rel);
+    if (!existsSync34(target)) continue;
+    const resolved = path45.resolve(target);
     if (seen.has(resolved)) continue;
     if (!isPathInside(resolved, opts.harnessRoot)) continue;
     seen.add(resolved);
@@ -9375,13 +9745,13 @@ function scanBuildCacheCandidates(opts) {
       })
     );
   }
-  if (!opts.includeOrphans || !existsSync33(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync11(opts.worktreesDir, { withFileTypes: true })) {
+  if (!opts.includeOrphans || !existsSync34(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync12(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path44.join(opts.worktreesDir, runEntry.name);
-    for (const workerEntry of readdirSync11(runPath, { withFileTypes: true })) {
+    const runPath = path45.join(opts.worktreesDir, runEntry.name);
+    for (const workerEntry of readdirSync12(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path44.join(runPath, workerEntry.name);
+      const worktreePath = path45.join(runPath, workerEntry.name);
       candidates.push(
         ...collectBuildCacheForWorktree(worktreePath, opts, seen, {
           runId: runEntry.name,
@@ -9402,7 +9772,7 @@ function scanWorktreeCandidates(opts) {
     for (const entry of opts.index.values()) {
       if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
       const resolved = entry.worktreePath;
-      if (!existsSync33(resolved)) continue;
+      if (!existsSync34(resolved)) continue;
       if (seen.has(resolved)) continue;
       seen.add(resolved);
       candidates.push({
@@ -9416,24 +9786,24 @@ function scanWorktreeCandidates(opts) {
       });
     }
   }
-  if (!orphanEnabled || !existsSync33(opts.worktreesDir)) return candidates;
+  if (!orphanEnabled || !existsSync34(opts.worktreesDir)) return candidates;
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path44.resolve(entry.worktreePath));
+    indexedPaths.add(path45.resolve(entry.worktreePath));
   }
-  for (const runEntry of readdirSync11(opts.worktreesDir, { withFileTypes: true })) {
+  for (const runEntry of readdirSync12(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path44.join(opts.worktreesDir, runEntry.name);
+    const runPath = path45.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
-      workerEntries = readdirSync11(runPath, { withFileTypes: true });
+      workerEntries = readdirSync12(runPath, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path44.resolve(path44.join(runPath, workerEntry.name));
+      const worktreePath = path45.resolve(path45.join(runPath, workerEntry.name));
       if (seen.has(worktreePath)) continue;
       if (indexedPaths.has(worktreePath)) continue;
       if (!isPathInside(worktreePath, opts.harnessRoot)) continue;
@@ -9452,8 +9822,8 @@ function scanWorktreeCandidates(opts) {
 }
 
 // src/cleanup-dependency-scan.ts
-import { existsSync as existsSync34, readdirSync as readdirSync12, statSync as statSync10 } from "node:fs";
-import path45 from "node:path";
+import { existsSync as existsSync35, readdirSync as readdirSync13, statSync as statSync10 } from "node:fs";
+import path46 from "node:path";
 var DEPENDENCY_CACHE_DIRS = [
   { dirName: "node_modules", kind: "remove_node_modules" },
   { dirName: ".next", kind: "remove_next_cache" }
@@ -9467,12 +9837,12 @@ function pathAgeMs3(target, now) {
   }
 }
 function isPathInside2(child, parent) {
-  const rel = path45.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path45.isAbsolute(rel);
+  const rel = path46.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path46.isAbsolute(rel);
 }
 function pushCandidate2(candidates, seen, opts, targetPath, kind, meta) {
-  if (!existsSync34(targetPath)) return;
-  const resolved = path45.resolve(targetPath);
+  if (!existsSync35(targetPath)) return;
+  const resolved = path46.resolve(targetPath);
   if (seen.has(resolved)) return;
   if (!isPathInside2(resolved, opts.harnessRoot)) return;
   seen.add(resolved);
@@ -9489,7 +9859,7 @@ function pushCandidate2(candidates, seen, opts, targetPath, kind, meta) {
 }
 function scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, meta) {
   for (const entry of DEPENDENCY_CACHE_DIRS) {
-    pushCandidate2(candidates, seen, opts, path45.join(worktreePath, entry.dirName), entry.kind, meta);
+    pushCandidate2(candidates, seen, opts, path46.join(worktreePath, entry.dirName), entry.kind, meta);
   }
 }
 function scanDependencyCacheCandidates(opts) {
@@ -9503,20 +9873,20 @@ function scanDependencyCacheCandidates(opts) {
       repo: entry.run.repo
     });
   }
-  if (!opts.includeOrphans || !existsSync34(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync12(opts.worktreesDir, { withFileTypes: true })) {
+  if (!opts.includeOrphans || !existsSync35(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync13(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path45.join(opts.worktreesDir, runEntry.name);
+    const runPath = path46.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
-      workerEntries = readdirSync12(runPath, { withFileTypes: true });
+      workerEntries = readdirSync13(runPath, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path45.join(runPath, workerEntry.name);
+      const worktreePath = path46.join(runPath, workerEntry.name);
       scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, {
         runId: runEntry.name,
         worker: workerEntry.name
@@ -9527,8 +9897,8 @@ function scanDependencyCacheCandidates(opts) {
 }
 
 // src/cleanup-duplicate-worktrees.ts
-import { existsSync as existsSync35, statSync as statSync11 } from "node:fs";
-import path46 from "node:path";
+import { existsSync as existsSync36, statSync as statSync11 } from "node:fs";
+import path47 from "node:path";
 function pathAgeMs4(target, now) {
   try {
     const mtime = statSync11(target).mtimeMs;
@@ -9558,8 +9928,8 @@ function parseWorktreePorcelain(output) {
   return records;
 }
 function isUnderWorktreesDir(worktreePath, worktreesDir) {
-  const rel = path46.relative(path46.resolve(worktreesDir), path46.resolve(worktreePath));
-  return rel !== "" && !rel.startsWith("..") && !path46.isAbsolute(rel);
+  const rel = path47.relative(path47.resolve(worktreesDir), path47.resolve(worktreePath));
+  return rel !== "" && !rel.startsWith("..") && !path47.isAbsolute(rel);
 }
 function isCleanWorktree(worktreePath, repoRoot) {
   try {
@@ -9572,14 +9942,14 @@ function isCleanWorktree(worktreePath, repoRoot) {
   }
 }
 function scanDuplicateWorktreeCandidates(opts) {
-  if (!opts.includeOrphans || !existsSync35(opts.worktreesDir)) return [];
+  if (!opts.includeOrphans || !existsSync36(opts.worktreesDir)) return [];
   const repos = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    if (entry.run.repo) repos.add(path46.resolve(entry.run.repo));
+    if (entry.run.repo) repos.add(path47.resolve(entry.run.repo));
   }
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path46.resolve(entry.worktreePath));
+    indexedPaths.add(path47.resolve(entry.worktreePath));
   }
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -9592,15 +9962,15 @@ function scanDuplicateWorktreeCandidates(opts) {
     }
     const worktrees = parseWorktreePorcelain(porcelain);
     for (const wt of worktrees) {
-      const resolved = path46.resolve(wt.path);
-      if (resolved === path46.resolve(repoRoot)) continue;
+      const resolved = path47.resolve(wt.path);
+      if (resolved === path47.resolve(repoRoot)) continue;
       if (!isUnderWorktreesDir(resolved, opts.worktreesDir)) continue;
       if (indexedPaths.has(resolved)) continue;
       if (seen.has(resolved)) continue;
-      if (!existsSync35(resolved)) continue;
+      if (!existsSync36(resolved)) continue;
       if (!isCleanWorktree(resolved, repoRoot)) continue;
-      const rel = path46.relative(opts.worktreesDir, resolved);
-      const parts = rel.split(path46.sep);
+      const rel = path47.relative(opts.worktreesDir, resolved);
+      const parts = rel.split(path47.sep);
       const runId = parts[0];
       const worker = parts[1] ?? "unknown";
       seen.add(resolved);
@@ -9619,12 +9989,12 @@ function scanDuplicateWorktreeCandidates(opts) {
 }
 
 // src/cleanup-worktree-index.ts
-import path47 from "node:path";
+import path48 from "node:path";
 function buildWorktreeIndexAt(harnessRoot) {
   const index = /* @__PURE__ */ new Map();
   for (const run of listRunRecordsForHarnessRoot(harnessRoot)) {
     for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path47.join(
+      const workerPath = path48.join(
         runDirectoryAt(harnessRoot, run.id),
         "workers",
         safeSlug(name),
@@ -9632,9 +10002,9 @@ function buildWorktreeIndexAt(harnessRoot) {
       );
       const worker = readJson(workerPath, void 0);
       if (!worker?.worktreePath) continue;
-      index.set(path47.resolve(worker.worktreePath), {
+      index.set(path48.resolve(worker.worktreePath), {
         harnessRoot,
-        worktreePath: path47.resolve(worker.worktreePath),
+        worktreePath: path48.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -9703,15 +10073,15 @@ function resolvePipelineHarnessRetention(runId) {
 }
 
 // src/cleanup-orphan-safety.ts
-import { existsSync as existsSync36, statSync as statSync12 } from "node:fs";
-import path48 from "node:path";
+import { existsSync as existsSync37, statSync as statSync12 } from "node:fs";
+import path49 from "node:path";
 var DEFAULT_HEARTBEAT_FRESH_MS = 30 * 60 * 1e3;
 function assessOrphanWorktreeSafety(input) {
   const now = input.now ?? Date.now();
   const heartbeatFreshMs = input.heartbeatFreshMs ?? DEFAULT_HEARTBEAT_FRESH_MS;
-  if (!existsSync36(input.worktreePath)) return null;
+  if (!existsSync37(input.worktreePath)) return null;
   if (input.runId && input.workerName) {
-    const heartbeatPath = path48.join(
+    const heartbeatPath = path49.join(
       input.harnessRoot,
       "runs",
       input.runId,
@@ -9725,8 +10095,8 @@ function assessOrphanWorktreeSafety(input) {
     } catch {
     }
   }
-  const gitDir = path48.join(input.worktreePath, ".git");
-  if (!existsSync36(gitDir)) return null;
+  const gitDir = path49.join(input.worktreePath, ".git");
+  if (!existsSync37(gitDir)) return null;
   const porcelain = gitCapture(input.worktreePath, ["status", "--porcelain"]);
   if (porcelain.status !== 0) return "pr_or_unmerged_commits";
   const dirtyLines = porcelain.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
@@ -9755,14 +10125,14 @@ function assessOrphanWorktreeSafety(input) {
 }
 
 // src/harness-storage-snapshot.ts
-import { existsSync as existsSync37, readdirSync as readdirSync13, statSync as statSync13 } from "node:fs";
-import path49 from "node:path";
+import { existsSync as existsSync38, readdirSync as readdirSync14, statSync as statSync13 } from "node:fs";
+import path50 from "node:path";
 function harnessStorageSnapshot(opts = {}) {
   const harnessRoot = normalizeHarnessRoot(opts.harnessRoot ?? resolveHarnessRoot());
   const worktreesDir = harnessWorktreesDir(harnessRoot);
   const now = opts.now ?? Date.now();
   const scannedAt = new Date(now).toISOString();
-  if (!existsSync37(worktreesDir)) {
+  if (!existsSync38(worktreesDir)) {
     return {
       harnessRoot,
       worktreesDir,
@@ -9779,7 +10149,7 @@ function harnessStorageSnapshot(opts = {}) {
   let oldestMs = null;
   let entries;
   try {
-    entries = readdirSync13(worktreesDir, { withFileTypes: true });
+    entries = readdirSync14(worktreesDir, { withFileTypes: true });
   } catch {
     return {
       harnessRoot,
@@ -9794,14 +10164,14 @@ function harnessStorageSnapshot(opts = {}) {
   for (const runEntry of entries) {
     if (!runEntry.isDirectory()) continue;
     runCount += 1;
-    const runPath = path49.join(worktreesDir, runEntry.name);
+    const runPath = path50.join(worktreesDir, runEntry.name);
     try {
       const st = statSync13(runPath);
       oldestMs = oldestMs === null ? st.mtimeMs : Math.min(oldestMs, st.mtimeMs);
     } catch {
     }
     try {
-      for (const workerEntry of readdirSync13(runPath, { withFileTypes: true })) {
+      for (const workerEntry of readdirSync14(runPath, { withFileTypes: true })) {
         if (workerEntry.isDirectory()) workerCount += 1;
       }
     } catch {
@@ -9829,12 +10199,12 @@ function harnessStorageSnapshot(opts = {}) {
 }
 
 // src/cleanup-harness-roots.ts
-import { existsSync as existsSync38 } from "node:fs";
+import { existsSync as existsSync39 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import path50 from "node:path";
+import path51 from "node:path";
 var WELL_KNOWN_HARNESS_SCAN_ROOTS = [
   "/var/tmp/kynver-harness",
-  path50.join(homedir12(), ".openclaw", "harness")
+  path51.join(homedir12(), ".openclaw", "harness")
 ];
 function addRoot(seen, roots, candidate) {
   if (!candidate?.trim()) return;
@@ -9856,8 +10226,8 @@ function resolveHarnessScanRoots(options = {}) {
   for (const candidate of extra ?? []) addRoot(seen, roots, candidate);
   if (shouldScanWellKnownRoots(options)) {
     for (const candidate of WELL_KNOWN_HARNESS_SCAN_ROOTS) {
-      const resolved = path50.resolve(candidate);
-      if (!seen.has(resolved) && existsSync38(resolved)) addRoot(seen, roots, resolved);
+      const resolved = path51.resolve(candidate);
+      if (!seen.has(resolved) && existsSync39(resolved)) addRoot(seen, roots, resolved);
     }
   }
   return roots;
@@ -9887,11 +10257,19 @@ function observeCleanupDiskPressure(input = {}) {
 }
 function applyDiskPressureToRetention(retention, pressure) {
   if (!pressure.pressured) return retention;
-  const executeOnPressure = retention.execute || envFlag3("KYNVER_CLEANUP_EXECUTE_ON_PRESSURE");
+  const executeOnPressure = retention.execute || !envFlag3("KYNVER_CLEANUP_DRY_RUN_ON_PRESSURE");
   return {
     ...retention,
     execute: executeOnPressure,
     nodeModulesAgeMs: 0,
+    // Disk pressure means the current-run-only cleanup scope has already fallen
+    // behind. Expand the sweep to every known harness root/run, but keep the
+    // worktree salvage/PR/dirty/live-worker guards in the cleanup pipeline.
+    runIdFilter: void 0,
+    includeOrphans: true,
+    terminalWorktreesAgeMs: 0,
+    runDirectoriesAgeMs: 0,
+    worktreesAgeMs: retention.worktreesAgeMs > 0 ? retention.worktreesAgeMs : DEFAULT_WORKTREES_AGE_MS,
     diskPressure: true,
     diskGate: pressure.diskGate
   };
@@ -10003,9 +10381,9 @@ function mergeWorktreeIndexes(scanRoots) {
 }
 function worktreePathForCandidate(candidate, worktreesDir) {
   if (candidate.runId && candidate.worker) {
-    return path51.join(worktreesDir, candidate.runId, candidate.worker);
+    return path52.join(worktreesDir, candidate.runId, candidate.worker);
   }
-  return path51.resolve(candidate.path, "..");
+  return path52.resolve(candidate.path, "..");
 }
 function runHarnessCleanup(options = {}) {
   let retention = resolveHarnessRetention(options);
@@ -10030,7 +10408,7 @@ function runHarnessCleanup(options = {}) {
   for (const harnessRoot of paths.scanRoots) {
     if (atSweepCap()) break;
     emitCleanupProgress("root", harnessRoot);
-    const worktreesDir = path51.join(harnessRoot, "worktrees");
+    const worktreesDir = path52.join(harnessRoot, "worktrees");
     const scanOpts = {
       harnessRoot,
       worktreesDir,
@@ -10043,7 +10421,7 @@ function runHarnessCleanup(options = {}) {
     };
     for (const raw of scanDependencyCacheCandidates(scanOpts)) {
       if (atSweepCap()) break;
-      const resolved = path51.resolve(raw.path);
+      const resolved = path52.resolve(raw.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const candidate = { ...raw, path: resolved };
@@ -10054,7 +10432,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path51.resolve(worktreePath)) ?? null;
+      const indexed = index.get(path52.resolve(worktreePath)) ?? null;
       const guardReason = skipDependencyCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -10078,7 +10456,7 @@ function runHarnessCleanup(options = {}) {
     }
     for (const raw of scanBuildCacheCandidates(scanOpts)) {
       if (atSweepCap()) break;
-      const resolved = path51.resolve(raw.path);
+      const resolved = path52.resolve(raw.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const candidate = { ...raw, path: resolved };
@@ -10089,7 +10467,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path51.resolve(worktreePath)) ?? null;
+      const indexed = index.get(path52.resolve(worktreePath)) ?? null;
       const guardReason = skipBuildCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -10119,11 +10497,11 @@ function runHarnessCleanup(options = {}) {
     const worktreeSeen = /* @__PURE__ */ new Set();
     for (const raw of worktreeCandidates) {
       if (atSweepCap()) break;
-      const resolved = path51.resolve(raw.path);
+      const resolved = path52.resolve(raw.path);
       if (worktreeSeen.has(resolved)) continue;
       worktreeSeen.add(resolved);
       const candidate = { ...raw, path: resolved };
-      const indexed = index.get(path51.resolve(candidate.path)) ?? null;
+      const indexed = index.get(path52.resolve(candidate.path)) ?? null;
       const orphanSafety = indexed ? null : assessOrphanWorktreeSafety({
         worktreePath: candidate.path,
         harnessRoot,
@@ -10133,7 +10511,7 @@ function runHarnessCleanup(options = {}) {
       });
       const guardSkip = skipWorktreeRemoval({
         indexed,
-        worktreePath: path51.resolve(candidate.path),
+        worktreePath: path52.resolve(candidate.path),
         includeOrphans: retention.includeOrphans,
         worktreesAgeMs: retention.worktreesAgeMs,
         terminalWorktreesAgeMs: retention.terminalWorktreesAgeMs,
@@ -10165,11 +10543,11 @@ function runHarnessCleanup(options = {}) {
         now: paths.now
       })) {
         if (atSweepCap()) break;
-        const resolved = path51.resolve(raw.path);
+        const resolved = path52.resolve(raw.path);
         if (processedPaths.has(resolved)) continue;
         processedPaths.add(resolved);
         const candidate = { ...raw, path: resolved };
-        const runId = candidate.runId ?? path51.basename(resolved);
+        const runId = candidate.runId ?? path52.basename(resolved);
         const dirSkip = skipRunDirectoryRemoval({
           harnessRoot,
           runId,
@@ -10305,7 +10683,7 @@ function isPipelineCleanupEnabled() {
 // src/installed-package-versions.ts
 import { readFile } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
-import path52 from "node:path";
+import path53 from "node:path";
 var MANAGED_PACKAGES = [
   "@kynver-app/runtime",
   "@kynver-app/openclaw-agent-os",
@@ -10320,12 +10698,12 @@ function unique(values) {
 }
 function moduleRoots() {
   const home = homedir13();
-  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path52.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) ? path52.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path52.join(home, ".npm-global", "lib", "node_modules"));
+  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path53.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) ? path53.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path53.join(home, ".npm-global", "lib", "node_modules"));
   return unique([
-    path52.join(openClawPrefix, "lib", "node_modules"),
-    path52.join(openClawPrefix, "node_modules"),
-    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path52.join(npmGlobalRoot, "lib", "node_modules")
+    path53.join(openClawPrefix, "lib", "node_modules"),
+    path53.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path53.join(npmGlobalRoot, "lib", "node_modules")
   ]);
 }
 async function readVersion(packageJsonPath) {
@@ -10341,7 +10719,7 @@ async function collectInstalledPackageVersions(observedAt = (/* @__PURE__ */ new
   const out = {};
   for (const packageName of MANAGED_PACKAGES) {
     for (const root of roots) {
-      const packageJsonPath = path52.join(root, packageName, "package.json");
+      const packageJsonPath = path53.join(root, packageName, "package.json");
       const version = await readVersion(packageJsonPath);
       if (!version) continue;
       out[packageName] = { version, observedAt, path: packageJsonPath };
@@ -10357,7 +10735,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path53.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path54.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -10396,7 +10774,10 @@ async function postOperatorTick(agentOsId, runId, resourceGate, args, harnessCle
     ingestHarness: true,
     harnessBoardSnapshot: buildRunBoard(runId),
     resourceGate,
-    boxResourceSnapshot: buildBoxResourceSnapshotFromGate(resourceGate, { harnessRunId: runId }),
+    boxResourceSnapshot: buildBoxResourceSnapshotFromGate(resourceGate, {
+      harnessRunId: runId,
+      boxKind: resolveBoxKindFromConfig(loadUserConfig())
+    }),
     packageVersions,
     ...harnessCleanup ? { harnessCleanup } : {},
     runnerPresence: resolveRunnerPresencePayload({ runId }),
@@ -10514,7 +10895,30 @@ async function runDaemon(args) {
   process.on("SIGTERM", () => {
     stopping = true;
   });
-  console.error(JSON.stringify({ event: "daemon_start", runId, agentOsId, execute, intervalMs }));
+  const identity = validateDaemonInstallIdentity(loadUserConfig());
+  if (!identity.ok) {
+    console.error(
+      JSON.stringify({
+        event: "daemon_start_blocked",
+        runId,
+        agentOsId,
+        errors: identity.errors
+      })
+    );
+    process.exit(1);
+  }
+  console.error(
+    JSON.stringify({
+      event: "daemon_start",
+      runId,
+      agentOsId,
+      execute,
+      intervalMs,
+      boxKind: identity.box.boxKind,
+      workerCapSource: identity.workerCapSource,
+      maxConcurrentWorkers: identity.maxConcurrentWorkers
+    })
+  );
   const cronEnv = resolveKynverCronEnv();
   while (!stopping) {
     try {
@@ -10545,7 +10949,7 @@ async function runDaemon(args) {
 }
 
 // src/plan-progress.ts
-import path54 from "node:path";
+import path56 from "node:path";
 
 // src/bounded-build/constants.ts
 var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
@@ -10583,7 +10987,7 @@ function formatNodeOptionsFlag(mb = resolveNodeOldSpaceSizeMb()) {
 }
 
 // src/bounded-build/systemd-wrap.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
 var systemdAvailableCache;
 function isSystemdRunAvailable() {
   if (process.env.KYNVER_BUILD_SKIP_SYSTEMD === "1" || process.env.KYNVER_BUILD_SKIP_SYSTEMD === "true") {
@@ -10594,7 +10998,7 @@ function isSystemdRunAvailable() {
     systemdAvailableCache = false;
     return false;
   }
-  const res = spawnSync4("systemd-run", ["--version"], { encoding: "utf8", stdio: ["ignore", "ignore", "pipe"] });
+  const res = spawnSync5("systemd-run", ["--version"], { encoding: "utf8", stdio: ["ignore", "ignore", "pipe"] });
   systemdAvailableCache = res.status === 0;
   return systemdAvailableCache;
 }
@@ -10618,18 +11022,18 @@ function buildSystemdRunArgv(opts) {
 }
 
 // src/bounded-build/admission.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
-function positiveInt3(value, fallback) {
+import { spawnSync as spawnSync6 } from "node:child_process";
+function positiveInt4(value, fallback) {
   const n = Number(value);
   if (!Number.isFinite(n) || n <= 0) return fallback;
   return Math.floor(n);
 }
 function resolveBuildAdmissionConfig(config = loadUserConfig()) {
-  const envBudget = process.env.KYNVER_BUILD_MEM_BUDGET_BYTES ? positiveInt3(process.env.KYNVER_BUILD_MEM_BUDGET_BYTES, DEFAULT_BUILD_MEM_BUDGET_BYTES) : void 0;
-  const envReserve = process.env.KYNVER_BUILD_MEM_RESERVE_BYTES ? positiveInt3(process.env.KYNVER_BUILD_MEM_RESERVE_BYTES, DEFAULT_BUILD_MEM_RESERVE_BYTES) : void 0;
+  const envBudget = process.env.KYNVER_BUILD_MEM_BUDGET_BYTES ? positiveInt4(process.env.KYNVER_BUILD_MEM_BUDGET_BYTES, DEFAULT_BUILD_MEM_BUDGET_BYTES) : void 0;
+  const envReserve = process.env.KYNVER_BUILD_MEM_RESERVE_BYTES ? positiveInt4(process.env.KYNVER_BUILD_MEM_RESERVE_BYTES, DEFAULT_BUILD_MEM_RESERVE_BYTES) : void 0;
   return {
-    perBuildBudgetBytes: envBudget ?? positiveInt3(config.perWorkerMemBytes, DEFAULT_BUILD_MEM_BUDGET_BYTES),
-    reserveBytes: envReserve ?? positiveInt3(config.memReserveBytes, DEFAULT_BUILD_MEM_RESERVE_BYTES)
+    perBuildBudgetBytes: envBudget ?? positiveInt4(config.perWorkerMemBytes, DEFAULT_BUILD_MEM_BUDGET_BYTES),
+    reserveBytes: envReserve ?? positiveInt4(config.memReserveBytes, DEFAULT_BUILD_MEM_RESERVE_BYTES)
   };
 }
 var activeBuilds = 0;
@@ -10654,7 +11058,7 @@ function assessBuildAdmission(opts = {}) {
 }
 function sleepMs2(ms) {
   if (ms <= 0) return;
-  spawnSync5(process.execPath, ["-e", `const d=Date.now()+${Math.floor(ms)};while(Date.now()<d);`], {
+  spawnSync6(process.execPath, ["-e", `const d=Date.now()+${Math.floor(ms)};while(Date.now()<d);`], {
     stdio: "ignore"
   });
 }
@@ -10675,7 +11079,28 @@ function waitForBuildAdmission(timeoutMs, pollMs = 2e3, opts = {}) {
 }
 
 // src/bounded-build/exec.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
+
+// src/harness-worktree-build-guard.ts
+import path55 from "node:path";
+function isPathUnderHarnessWorktree(cwd) {
+  const worktreesDir = harnessWorktreesDir(resolveHarnessRoot());
+  const rel = path55.relative(worktreesDir, path55.resolve(cwd));
+  return rel.length > 0 && !rel.startsWith("..") && !path55.isAbsolute(rel);
+}
+function assessHarnessWorktreeBuildGuard(cwd) {
+  if (!isPathUnderHarnessWorktree(cwd)) return { ok: true };
+  const uid = typeof process.getuid === "function" ? process.getuid() : null;
+  if (uid === 0) {
+    return {
+      ok: false,
+      reason: "Refusing build/install as root inside a harness worktree \u2014 generated caches become root-owned and block daemon cleanup. Run kynver daemon and workers as the harness owner (never sudo kynver)."
+    };
+  }
+  return { ok: true };
+}
+
+// src/bounded-build/exec.ts
 function envArgv(env) {
   const out = [];
   for (const [key, value] of Object.entries(env)) {
@@ -10685,7 +11110,7 @@ function envArgv(env) {
   return out;
 }
 function runSpawn(argv, opts) {
-  const res = spawnSync6(argv[0], argv.slice(1), {
+  const res = spawnSync7(argv[0], argv.slice(1), {
     cwd: opts.cwd,
     env: opts.env,
     encoding: "utf8",
@@ -10715,6 +11140,20 @@ function runBoundedBuildCheck(input) {
       command: input.command
     };
   }
+  const worktreeGuard = assessHarnessWorktreeBuildGuard(input.cwd);
+  if (!worktreeGuard.ok) {
+    return {
+      ok: false,
+      exitCode: 1,
+      stdout: "",
+      stderr: worktreeGuard.reason,
+      admitted: true,
+      wrappedWithSystemd: false,
+      nodeOptionsFlag: formatNodeOptionsFlag(),
+      admission,
+      command: input.command
+    };
+  }
   const env = mergeNodeOptionsForBuildCheck({ ...process.env, ...input.env });
   const nodeOptionsFlag = formatNodeOptionsFlag();
   const useSystemd = isSystemdRunAvailable();
@@ -10832,7 +11271,7 @@ async function emitPlanProgress(args) {
 }
 function verifyPlanLocal(args) {
   const worktree = required(args.worktree ? String(args.worktree) : void 0, "worktree");
-  const cwd = path54.resolve(worktree);
+  const cwd = path56.resolve(worktree);
   const summary = runHarnessVerifyCommands(cwd);
   const emitJson = args.json === true || args.json === "true";
   const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
@@ -10881,9 +11320,9 @@ async function verifyPlan(args) {
 }
 
 // src/harness-verify-cli.ts
-import path55 from "node:path";
+import path57 from "node:path";
 function runHarnessVerifyCli(args) {
-  const cwd = path55.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const cwd = path57.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;
@@ -11090,7 +11529,7 @@ function formatMonitorTickNotice(tick) {
 }
 
 // src/monitor/monitor.service.ts
-import path57 from "node:path";
+import path59 from "node:path";
 
 // src/monitor/monitor.classify.ts
 function classifyWorkerHealth(input) {
@@ -11142,11 +11581,11 @@ function classifyWorkerHealth(input) {
 }
 
 // src/monitor/monitor.store.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync7, readdirSync as readdirSync14, unlinkSync as unlinkSync4 } from "node:fs";
-import path56 from "node:path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync7, readdirSync as readdirSync15, unlinkSync as unlinkSync4 } from "node:fs";
+import path58 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path56.join(harnessRoot, "monitors");
+  const dir = path58.join(harnessRoot, "monitors");
   mkdirSync7(dir, { recursive: true });
   return dir;
 }
@@ -11154,7 +11593,7 @@ function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path56.join(monitorsDir(), `${monitorId}.json`);
+  return path58.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -11164,18 +11603,18 @@ function saveMonitorSession(session) {
 }
 function deleteMonitorSession(monitorId) {
   const file = monitorPath(monitorId);
-  if (!existsSync39(file)) return false;
+  if (!existsSync40(file)) return false;
   unlinkSync4(file);
   return true;
 }
 function listMonitorSessions() {
   const dir = monitorsDir();
-  if (!existsSync39(dir)) return [];
+  if (!existsSync40(dir)) return [];
   const entries = [];
-  for (const name of readdirSync14(dir)) {
+  for (const name of readdirSync15(dir)) {
     if (!name.endsWith(".json")) continue;
     const session = readJson(
-      path56.join(dir, name),
+      path58.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -11266,7 +11705,7 @@ async function fetchTaskLeasesForWorkers(input) {
 // src/monitor/monitor.service.ts
 function workerRecord2(runId, name) {
   return readJson(
-    path57.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path59.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -11472,18 +11911,18 @@ async function runMonitorLoop(args) {
 
 // src/monitor/monitor-spawn.ts
 import { spawn as spawn6 } from "node:child_process";
-import { closeSync as closeSync7, existsSync as existsSync40, openSync as openSync7 } from "node:fs";
-import path58 from "node:path";
+import { closeSync as closeSync7, existsSync as existsSync41, openSync as openSync7 } from "node:fs";
+import path60 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path58.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
+  return path60.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
-  if (!existsSync40(cliPath)) return void 0;
+  if (!existsSync41(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path58.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path60.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
     logFd = openSync7(logPath, "a");
@@ -11603,13 +12042,13 @@ async function monitorTickCli(args) {
 }
 
 // src/package-version.ts
-import { existsSync as existsSync41, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync42, readFileSync as readFileSync13 } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function resolvePackageRoot(moduleUrl) {
   let dir = dirname(fileURLToPath4(moduleUrl));
   for (let depth = 0; depth < 6; depth += 1) {
-    if (existsSync41(join(dir, "package.json"))) return dir;
+    if (existsSync42(join(dir, "package.json"))) return dir;
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -11639,8 +12078,8 @@ function handleCliVersionFlag(argv, moduleUrl = import.meta.url, binName) {
 }
 
 // src/memory-cost-package-version-guard.ts
-import { existsSync as existsSync42, readFileSync as readFileSync14 } from "node:fs";
-import path59 from "node:path";
+import { existsSync as existsSync43, readFileSync as readFileSync14 } from "node:fs";
+import path61 from "node:path";
 var MEMORY_COST_PACKAGE_MIN_VERSIONS = {
   "@kynver-app/runtime": "0.1.83",
   "@kynver-app/openclaw-agent-os": "0.1.43",
@@ -11702,8 +12141,8 @@ function resolveRepoRoot(cwd, explicitRepoRoot) {
     (value) => Boolean(value?.trim())
   );
   for (const candidate of candidates) {
-    const resolved = path59.resolve(candidate);
-    if (existsSync42(path59.join(resolved, "packages/kynver-runtime/package.json")) && existsSync42(path59.join(resolved, "package.json"))) {
+    const resolved = path61.resolve(candidate);
+    if (existsSync43(path61.join(resolved, "packages/kynver-runtime/package.json")) && existsSync43(path61.join(resolved, "package.json"))) {
       return resolved;
     }
   }
@@ -11715,7 +12154,7 @@ function probeRepoPackageVersions(input = {}) {
   if (!repoRoot) return {};
   const out = {};
   for (const packageName of MEMORY_COST_MANAGED_PACKAGES) {
-    const packageJsonPath = path59.join(repoRoot, REPO_PACKAGE_JSON_RELATIVE[packageName]);
+    const packageJsonPath = path61.join(repoRoot, REPO_PACKAGE_JSON_RELATIVE[packageName]);
     const version = readPackageJsonVersion(packageJsonPath);
     if (!version) continue;
     out[packageName] = { version, source: "repo", path: packageJsonPath };
@@ -11867,7 +12306,7 @@ function shouldEnforceMemoryCostPackageGuardCli(scope, action) {
 }
 
 // src/post-restart-unblock.ts
-import path60 from "node:path";
+import path62 from "node:path";
 function skip(runId, worker, taskId, agentOsId, leaseOwner, reason) {
   return { runId, worker, taskId, agentOsId, leaseOwner, action: "skipped", reason };
 }
@@ -11880,7 +12319,7 @@ async function postRestartUnblock(args) {
   const errors = [];
   for (const run of listRunRecords()) {
     for (const name of Object.keys(run.workers ?? {})) {
-      const workerPath = path60.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path62.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker) {
         skipped.push(skip(run.id, name, "", "", "", "worker.json missing"));
@@ -11992,9 +12431,9 @@ async function postRestartUnblockCli(args) {
 }
 
 // src/default-repo-cli.ts
-import path61 from "node:path";
+import path63 from "node:path";
 import { homedir as homedir14 } from "node:os";
-var CONFIG_FILE2 = path61.join(homedir14(), ".kynver", "config.json");
+var CONFIG_FILE2 = path63.join(homedir14(), ".kynver", "config.json");
 function ensureDefaultRepo(opts) {
   const existing = loadUserConfig();
   const resolved = resolveDefaultRepo({ ...opts, config: existing });
@@ -12075,16 +12514,16 @@ function summarizeResolvedDefaultRepo(resolved) {
 }
 
 // src/doctor/runtime-takeover.ts
-import path63 from "node:path";
+import path65 from "node:path";
 
 // src/doctor/runtime-takeover.probes.ts
-import { accessSync, constants, existsSync as existsSync43, readFileSync as readFileSync15 } from "node:fs";
+import { accessSync, constants, existsSync as existsSync44, readFileSync as readFileSync15 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import path62 from "node:path";
-import { spawnSync as spawnSync7 } from "node:child_process";
+import path64 from "node:path";
+import { spawnSync as spawnSync8 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
-    const res = spawnSync7(bin, args, { encoding: "utf8" });
+    const res = spawnSync8(bin, args, { encoding: "utf8" });
     const stdout = (res.stdout || "").trim();
     const stderr = (res.stderr || "").trim();
     const ok = res.status === 0;
@@ -12109,7 +12548,7 @@ function tokenPrefix(token) {
   return trimmed.length <= 12 ? `${trimmed}\u2026` : `${trimmed.slice(0, 12)}\u2026`;
 }
 function isWritable(target) {
-  if (!existsSync43(target)) return false;
+  if (!existsSync44(target)) return false;
   try {
     accessSync(target, constants.W_OK);
     return true;
@@ -12122,11 +12561,11 @@ var defaultRuntimeTakeoverProbes = {
   commandOnPath: (bin) => captureCommand(process.platform === "win32" ? "where" : "which", [bin]),
   kynverVersion: (bin) => captureCommand(bin, ["--version"]),
   loadConfig: () => loadUserConfig(),
-  configFilePath: () => path62.join(homedir15(), ".kynver", "config.json"),
-  credentialsFilePath: () => path62.join(homedir15(), ".kynver", "credentials"),
+  configFilePath: () => path64.join(homedir15(), ".kynver", "config.json"),
+  credentialsFilePath: () => path64.join(homedir15(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path62.join(homedir15(), ".kynver", "credentials");
-    if (!existsSync43(credPath)) {
+    const credPath = path64.join(homedir15(), ".kynver", "credentials");
+    if (!existsSync44(credPath)) {
       return { hasApiKey: false };
     }
     try {
@@ -12160,8 +12599,8 @@ var defaultRuntimeTakeoverProbes = {
     })()
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path62.join(homedir15(), ".openclaw", "harness"),
-  pathExists: (target) => existsSync43(target),
+  legacyOpenclawHarnessRoot: () => path64.join(homedir15(), ".openclaw", "harness"),
+  pathExists: (target) => existsSync44(target),
   pathWritable: (target) => isWritable(target),
   vercelVersion: () => captureCommand("vercel", ["--version"]),
   vercelWhoami: () => captureCommand("vercel", ["whoami"])
@@ -12560,8 +12999,8 @@ function assessVercelCli(probes) {
 }
 function assessHarnessDirs(probes) {
   const harnessRoot = probes.harnessRoot();
-  const runsDir = path63.join(harnessRoot, "runs");
-  const worktreesDir = path63.join(harnessRoot, "worktrees");
+  const runsDir = path65.join(harnessRoot, "runs");
+  const worktreesDir = path65.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -12825,9 +13264,9 @@ function applySchedulerCutoverAttestation(config) {
 }
 
 // src/scheduler-cutover-cli.ts
-import path64 from "node:path";
+import path66 from "node:path";
 import { homedir as homedir16 } from "node:os";
-var CONFIG_FILE3 = path64.join(homedir16(), ".kynver", "config.json");
+var CONFIG_FILE3 = path66.join(homedir16(), ".kynver", "config.json");
 function runSchedulerCutoverCheckCli(json = false) {
   const config = loadUserConfig();
   const report = assessSchedulerCutover(config);
@@ -12980,7 +13419,7 @@ 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] [--discover-repo] [--max-workers N] [--provider claude|cursor]",
+      "  kynver setup [--api-base-url URL] [--agent-os-id ID] [--agent-os-slug SLUG] [--box-kind forge|ghost] [--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 list",