@kynver-app/runtime 0.1.108 → 0.1.112

package/dist/cli.js

@@ -175,7 +175,11 @@ function scrubWorkerEnv(env) {
 
 // src/git.ts
 function git(cwd, args, options = {}) {
-  const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+  const res = spawnSync(
+    "git",
+    args,
+    hiddenSpawnOptions({ cwd, encoding: "utf8" })
+  );
   if (res.status !== 0 && !options.allowFailure) {
     const message = `git ${args.join(" ")} failed: ${res.stderr || res.stdout}`;
     if (options.throwError) throw new Error(message);
@@ -191,7 +195,11 @@ function gitStatusShort(worktreePath) {
 }
 function gitCapture(cwd, args) {
   try {
-    const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+    const res = spawnSync(
+      "git",
+      args,
+      hiddenSpawnOptions({ cwd, encoding: "utf8" })
+    );
     return {
       status: res.status,
       stdout: res.stdout || "",
@@ -5648,32 +5656,98 @@ function workerStatus(args) {
   writeJson(path19.join(worker.workerDir, "last-status.json"), status);
   console.log(JSON.stringify(status, null, 2));
 }
+function buildWorkerListDrilldownCommands(runId) {
+  return {
+    full: `kynver worker list --run ${runId} --full`,
+    blocked: `kynver worker list --run ${runId} --blocked`,
+    running: `kynver worker list --run ${runId} --running`,
+    task: `kynver worker list --run ${runId} --task <task-id>`,
+    worker: `kynver worker list --run ${runId} --worker <worker>`,
+    runFull: `kynver run status --run ${runId} --full`,
+    workerFull: `kynver worker status --run ${runId} --name <worker>`,
+    workerTail: `kynver worker tail --run ${runId} --name <worker> --lines 80`
+  };
+}
+function asOptionalArg(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : void 0;
+}
+function activeWorkerFilters(args) {
+  const filters = {};
+  if (args.blocked === true || args.blocked === "true") filters.blocked = true;
+  if (args.running === true || args.running === "true") filters.running = true;
+  const task = asOptionalArg(args.task ?? args.taskId);
+  if (task) filters.task = task;
+  const worker = asOptionalArg(args.worker ?? args.name);
+  if (worker) filters.worker = worker;
+  const status = asOptionalArg(args.status);
+  if (status) filters.status = status;
+  return filters;
+}
+function workerMatchesFilters(worker, filters) {
+  if (filters.blocked) {
+    const attention = typeof worker.attention === "string" ? worker.attention : "";
+    const status = typeof worker.status === "string" ? worker.status : "";
+    if (!(attention === "blocked" || attention === "needs_attention" || attention === "stale" || status === "blocked")) {
+      return false;
+    }
+  }
+  if (filters.running) {
+    if (!(worker.status === "running" && worker.attention !== "blocked" && worker.attention !== "needs_attention")) {
+      return false;
+    }
+  }
+  if (typeof filters.task === "string" && worker.taskId !== filters.task) return false;
+  if (typeof filters.worker === "string" && worker.worker !== filters.worker) return false;
+  if (typeof filters.status === "string" && worker.status !== filters.status) return false;
+  return true;
+}
+function applyWorkerFilters(board, args) {
+  const filters = activeWorkerFilters(args);
+  if (Object.keys(filters).length === 0) return board;
+  const workers = board.workers.filter((worker) => workerMatchesFilters(worker, filters));
+  const filtered = {
+    ...board,
+    workerCount: workers.length,
+    needsAttention: workers.filter((w) => w.attention && w.attention !== "ok" && w.attention !== "done").map((w) => w.worker),
+    workers,
+    activeFilters: filters
+  };
+  if (board.summary) {
+    filtered.summary = {
+      statusCounts: countBy(workers, "status"),
+      attentionCounts: countBy(workers, "attention"),
+      lifecycleCounts: countBy(workers, "lifecycleStage")
+    };
+  }
+  if (board.controller) filtered.controller = buildControllerSummary(workers);
+  return filtered;
+}
 function workerList(args) {
   const runId = resolveRunTargetArg(args);
-  const explicitCompact = args.compact === true || args.compact === "true";
   const explicitFull = args.full === true || args.full === "true";
-  const run = loadRun(runId);
-  const workerCount = Object.keys(run.workers || {}).length;
-  const compact = explicitCompact || !explicitFull && workerCount > 100;
-  const board = compact ? buildCompactRunBoard(runId) : buildRunBoard(runId);
-  const autoCompact = compact && !explicitCompact;
-  const outputWorkers = autoCompact ? board.workers.filter((worker) => worker.attention && worker.attention !== "done" && worker.attention !== "ok") : board.workers;
+  const board = applyWorkerFilters(explicitFull ? buildRunBoard(runId) : buildCompactRunBoard(runId), args);
+  const outputWorkers = board.workers;
   console.log(
     JSON.stringify(
       {
         runId: board.runId,
         status: board.status,
+        projection: explicitFull ? "full" : "compact",
         workerCount: board.workerCount,
-        ...autoCompact ? {
-          compact: true,
-          compactReason: "large-worker-board",
-          omittedWorkerCount: board.workers.length - outputWorkers.length,
-          fullCommand: `kynver worker list --run ${runId} --json --full`,
-          compactCommand: `kynver worker list --run ${runId} --json --compact`
+        ...board.activeFilters ? { activeFilters: board.activeFilters } : {},
+        ...!explicitFull ? {
+          resultContract: {
+            projection: "compact",
+            rawWorkerPayloadsOmitted: true,
+            deepDetailAvailableVia: ["--full", "worker status", "worker tail", "run status --full"]
+          },
+          drilldownCommands: buildWorkerListDrilldownCommands(runId)
         } : {},
         needsAttention: board.needsAttention,
-        ...compact && "summary" in board ? { summary: board.summary } : {},
-        ...compact && "controller" in board ? { controller: board.controller } : {},
+        ..."summary" in board ? { summary: board.summary } : {},
+        ..."controller" in board ? { controller: board.controller } : {},
         workers: outputWorkers
       },
       null,
@@ -5941,9 +6015,33 @@ async function publishHarnessBoardSnapshot(args, source) {
     authRefreshFailure: res.authRefreshFailure
   };
 }
+function buildRunStatusDrilldownCommands(runId) {
+  return {
+    full: `kynver run status --run ${runId} --full`,
+    blocked: `kynver status --run ${runId} --blocked`,
+    running: `kynver status --run ${runId} --running`,
+    task: `kynver status --run ${runId} --task <task-id>`,
+    worker: `kynver status --run ${runId} --worker <worker>`,
+    workersFull: `kynver worker list --run ${runId} --full`,
+    workerFull: `kynver worker status --run ${runId} --name <worker>`,
+    workerTail: `kynver worker tail --run ${runId} --name <worker> --lines 80`,
+    monitorTick: `kynver monitor status --run ${runId} --tick`
+  };
+}
 function runStatus(args) {
-  const compact = args.compact === true || args.compact === "true";
-  const board = compact ? buildCompactRunBoard(resolveRunTargetArg(args)) : buildRunBoard(resolveRunTargetArg(args));
+  const runId = resolveRunTargetArg(args);
+  const explicitFull = args.full === true || args.full === "true";
+  const board = applyWorkerFilters(explicitFull ? buildRunBoard(runId) : buildCompactRunBoard(runId), args);
+  board.projection = explicitFull ? "full" : "compact";
+  if (!explicitFull) {
+    board.resultContract = {
+      projection: "compact",
+      rawWorkerPayloadsOmitted: true,
+      omittedWorkerFields: ["finalResult", "changedFiles", "gitAncestry", "completionResponse", "stdout/stderr tails"],
+      deepDetailAvailableVia: ["--full", "worker status", "worker tail", "monitor status --tick"]
+    };
+    board.drilldownCommands = buildRunStatusDrilldownCommands(runId);
+  }
   console.log(JSON.stringify(board, null, 2));
 }
 function tailWorker(args) {
@@ -7081,6 +7179,10 @@ var READY_MERGE_STATES = /* @__PURE__ */ new Set(["CLEAN", "HAS_HOOKS"]);
 function repoArgs(repo) {
   return repo?.trim() ? ["--repo", repo.trim()] : [];
 }
+function repoFromPrUrl(prUrl) {
+  const m = /github\.com\/([^/]+)\/([^/]+)\/pull\/\d+/i.exec(prUrl.trim());
+  return m ? `${m[1]}/${m[2]}` : null;
+}
 function ghJson(exec, cwd, args) {
   const res = exec.gh(cwd, args);
   if (res.status !== 0) {
@@ -7136,14 +7238,21 @@ var STRUCTURED_SECTION_RE = /^##\s*(test\s*plan|verification|test\s*evidence|ver
 var LOCAL_VERIFICATION_RE = /typecheck|npm run (test|build|typecheck)|vitest|tsc\b|verify-pr-local|local verify|local-verify|tests? (pass|green)|build green|node --test/i;
 var DOCS_TITLE_RE = /^docs[(:]/i;
 var DOCS_BODY_RE = /docs[- ]only|documentation only|no[- ]code change|no code changes|low[- ]risk|plan tracker only|markdown only/i;
-function assertVerificationEvidence(pr) {
-  const title = typeof pr.title === "string" ? pr.title : "";
-  const body = typeof pr.body === "string" ? pr.body : "";
+function runtimeVerificationEvidenceSufficient(input) {
+  const title = typeof input.title === "string" ? input.title : "";
+  const body = typeof input.body === "string" ? input.body : "";
   const docsLowRisk = DOCS_TITLE_RE.test(title) || DOCS_BODY_RE.test(body);
   const structuredSection = STRUCTURED_SECTION_RE.test(body);
   const localVerification = LOCAL_VERIFICATION_RE.test(body);
-  const vercelOk = vercelCheckSuccess(pr.statusCheckRollup);
-  if (docsLowRisk || structuredSection || localVerification || vercelOk) return;
+  return docsLowRisk || structuredSection || localVerification || input.vercelCheckSuccess === true;
+}
+function assertVerificationEvidence(pr) {
+  const sufficient = runtimeVerificationEvidenceSufficient({
+    title: pr.title,
+    body: pr.body,
+    vercelCheckSuccess: vercelCheckSuccess(pr.statusCheckRollup)
+  });
+  if (sufficient) return;
   throw new Error(
     `PR #${pr.number} lacks landing verification evidence \u2014 add ## Test plan / ## Verification with local commands, Vercel preview, or docs/no-code rationale`
   );
@@ -7244,6 +7353,14 @@ async function executeLandPrMerge(input) {
       "mergeCommit"
     ].join(",")
   ]);
+  if (before.state === "MERGED" || before.mergedAt) {
+    return {
+      prUrl: before.url || prTarget,
+      outcome: "skipped",
+      mergeCommit: before.mergeCommit?.oid ?? null,
+      reason: `PR #${before.number} is already merged \u2014 land_pr no-op (redelivery)`
+    };
+  }
   const notReadyReason = landingReadinessError(before);
   if (notReadyReason) {
     if (input.skipNotReady) {
@@ -7598,7 +7715,11 @@ async function dispatchRun(args) {
         return abortClaimedSpawn(task, "land_pr task missing prUrl");
       }
       try {
-        const report = await executeLandPrMerge({ prUrl, cwd: process.cwd() });
+        const report = await executeLandPrMerge({
+          prUrl,
+          repo: repoFromPrUrl(prUrl),
+          cwd: run.repo
+        });
         const post = await postLandPrHarnessCompletion({
           baseUrl: base,
           secret,
@@ -7625,6 +7746,27 @@ async function dispatchRun(args) {
         return abortClaimedSpawn(task, error.message);
       }
     }
+    async function releaseDuplicateLocalClaim(task) {
+      const error = "duplicate_dispatch_prevented: live local worker already owns this task";
+      const release = await releaseDispatchClaimAfterSpawnFailure({
+        baseUrl: base,
+        secret,
+        agentOsId,
+        taskId: String(task.id),
+        leaseOwner,
+        failureDetail: error
+      });
+      outcomes.push({
+        taskId: task.id,
+        started: false,
+        error,
+        alreadyRunning: true,
+        nonFatal: true,
+        released: release.released,
+        releaseResponse: release.releaseResponse
+      });
+      return false;
+    }
     async function spawnClaimed(decision) {
       const task = decision.task;
       const harnessContext = readHarnessWorkerContext(decision);
@@ -7646,10 +7788,7 @@ async function dispatchRun(args) {
         );
       }
       if (hasLiveWorkerForTask(run.id, taskId)) {
-        return abortClaimedSpawn(
-          task,
-          "duplicate_dispatch_prevented: live local worker already owns this task"
-        );
+        return releaseDuplicateLocalClaim(task);
       }
       const attempt = Number(task.attempt) || 1;
       if (attempt > retryLimits.maxTaskAttempts) {
@@ -7819,11 +7958,12 @@ async function dispatchRun(args) {
       diskGate: result.diskGate,
       resourceGate: result.resourceGate
     };
+    const fatalOutcome = (outcome) => !outcome.started && outcome.nonFatal !== true;
     if (pipeline) {
-      return { ok: !outcomes.some((o) => !o.started), ...summary };
+      return { ok: !outcomes.some(fatalOutcome), ...summary };
     }
     console.log(JSON.stringify(summary, null, 2));
-    if (outcomes.some((o) => !o.started)) process.exit(1);
+    if (outcomes.some(fatalOutcome)) process.exit(1);
   } catch (error) {
     if (pipeline) return { ok: false, error: error.message };
     console.error(`run dispatch failed: ${error.message}`);
@@ -9057,11 +9197,29 @@ function validateDaemonInstallIdentity(config = loadUserConfig(), env = process.
   };
 }
 
+// src/daemon-platform-guard.ts
+function envFlag(name) {
+  const raw = process.env[name]?.trim().toLowerCase();
+  return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
+}
+function assertNativeDaemonAllowed() {
+  if (process.platform !== "win32") return;
+  if (envFlag("KYNVER_DAEMON_ALLOW_NATIVE_WINDOWS")) return;
+  console.error(
+    JSON.stringify({
+      event: "daemon_start_blocked",
+      reason: "native_windows_console_flash",
+      remedy: "Run the daemon inside WSL: .\\scripts\\start-tier2-wsl.ps1 \u2014 or set KYNVER_DAEMON_ALLOW_NATIVE_WINDOWS=1 to override (flashes visible consoles)."
+    })
+  );
+  process.exit(1);
+}
+
 // src/cron/cron-env.ts
 import { existsSync as existsSync27 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import path37 from "node:path";
-function envFlag(name, defaultValue) {
+function envFlag2(name, defaultValue) {
   const raw = process.env[name]?.trim().toLowerCase();
   if (!raw) return defaultValue;
   if (raw === "0" || raw === "false" || raw === "no" || raw === "off") return false;
@@ -9097,14 +9255,14 @@ function resolveKynverCronEnv() {
   const secret = resolveKynverCronSecret();
   const credsReady = Boolean(fireBaseUrl && secret);
   const storeExists = existsSync27(storePath);
-  const defaultEnabled = credsReady && (storeExists || envFlag("KYNVER_CRON_TICK_FORCE", false));
+  const defaultEnabled = credsReady && (storeExists || envFlag2("KYNVER_CRON_TICK_FORCE", false));
   return {
     storePath,
     statePath,
     lockPath: `${statePath}.lock`,
     fireBaseUrl,
     secret,
-    tickEnabled: envFlag("KYNVER_CRON_TICK_ENABLED", defaultEnabled),
+    tickEnabled: envFlag2("KYNVER_CRON_TICK_ENABLED", defaultEnabled),
     tickIntervalMs: envInt("KYNVER_CRON_TICK_INTERVAL_MS", 6e4, 5e3),
     missedRunPolicy: process.env.KYNVER_CRON_MISSED_RUN_POLICY?.trim().toLowerCase() === "skip" ? "skip" : "catch_up",
     maxCatchUpPerTick: envInt("KYNVER_CRON_MAX_CATCH_UP_PER_TICK", 3, 0),
@@ -9791,23 +9949,6 @@ function materialWorktreeChanges2(changedFiles) {
   });
 }
 
-// src/cleanup-index-status.ts
-function indexedWorktreeStatus(entry) {
-  if (!entry.status) {
-    entry.status = computeWorkerStatus(entry.worker, {
-      base: entry.run.base,
-      baseCommit: entry.run.baseCommit
-    });
-  }
-  return entry.status;
-}
-function indexedWorktreeHasMaterialChanges(entry) {
-  if (entry.status) {
-    return materialWorktreeChanges2(entry.status.changedFiles).length > 0;
-  }
-  return materialWorktreeChanges2(gitStatusShort(entry.worktreePath)).length > 0;
-}
-
 // src/cleanup-worktree-salvage.ts
 function prUrlFromFinalResult(finalResult) {
   if (typeof finalResult === "string") {
@@ -9834,6 +9975,83 @@ function isPrOrUnmergedWork(status) {
   return false;
 }
 
+// src/cleanup-index-status.ts
+function indexedWorktreeStatus(entry) {
+  if (!entry.status) {
+    entry.status = computeWorkerStatus(entry.worker, {
+      base: entry.run.base,
+      baseCommit: entry.run.baseCommit
+    });
+  }
+  return entry.status;
+}
+function indexedWorktreeHasMaterialChanges(entry, gitStatusCache) {
+  if (entry.status) {
+    return materialWorktreeChanges2(entry.status.changedFiles).length > 0;
+  }
+  const porcelain = gitStatusCache ? gitStatusCache.porcelain(entry.worktreePath) : gitStatusShort(entry.worktreePath);
+  return materialWorktreeChanges2(porcelain).length > 0;
+}
+function finalResultFromWorkerJson(entry) {
+  const snapshot = entry.worker.completionSnapshot?.finalResult;
+  if (snapshot !== void 0 && snapshot !== null) return snapshot;
+  if (entry.worker.taskPrUrl) {
+    return { prUrl: entry.worker.taskPrUrl };
+  }
+  return null;
+}
+function resolveWorktreeGuardStatus(entry, ctx) {
+  if (entry.status) return entry.status;
+  const worker = entry.worker;
+  const completionAcknowledged = typeof worker.completionReportedAt === "string" && worker.completionReportedAt.trim().length > 0;
+  const workerJsonTerminal = Boolean(worker.status && ["done", "exited", "blocked", "failed", "abandoned"].includes(worker.status)) || completionAcknowledged;
+  const finalResult = finalResultFromWorkerJson(entry);
+  if (workerJsonTerminal && !isPidAlive(worker.pid)) {
+    const changedFiles = ctx?.gitStatusCache ? ctx.gitStatusCache.porcelain(entry.worktreePath) : gitStatusShort(entry.worktreePath);
+    const baseLabel = entry.run.baseCommit?.trim() || entry.run.base?.trim() || "origin/main";
+    const ahead = ctx?.gitRevCache?.countAheadOfMain(entry.worktreePath, baseLabel);
+    const gitAncestry = ahead === 0 ? {
+      checked: true,
+      base: baseLabel,
+      relation: "synced"
+    } : computeGitAncestry(entry.worktreePath, {
+      base: entry.run.base,
+      baseCommit: entry.run.baseCommit
+    });
+    const status = {
+      runId: entry.runId,
+      worker: entry.workerName,
+      pid: worker.pid,
+      alive: false,
+      status: worker.status ?? (completionAcknowledged ? "done" : "exited"),
+      attention: { state: completionAcknowledged ? "done" : "stale" },
+      branch: worker.branch,
+      worktreePath: entry.worktreePath,
+      ownedPaths: worker.ownedPaths,
+      stdoutBytes: 0,
+      stderrBytes: 0,
+      heartbeatBytes: 0,
+      firstEventAt: null,
+      lastEventAt: null,
+      lastActivityAt: worker.completionReportedAt ?? null,
+      currentTool: null,
+      heartbeatCount: 0,
+      lastHeartbeatAt: null,
+      lastHeartbeatPhase: null,
+      lastHeartbeatSummary: null,
+      heartbeatBlocker: null,
+      changedFiles,
+      gitAncestry,
+      finalResult,
+      completionBlocker: typeof worker.completionBlocker === "string" ? worker.completionBlocker.trim() || null : null,
+      prUrl: worker.repairTargetPrUrl ?? worker.taskPrUrl ?? prUrlFromFinalResult(finalResult)
+    };
+    entry.status = status;
+    return status;
+  }
+  return indexedWorktreeStatus(entry);
+}
+
 // src/cleanup-completion-blocker.ts
 function completionBlockerBlocksWorktreeRemoval(indexed, status) {
   const blocker = typeof indexed.worker.completionBlocker === "string" ? indexed.worker.completionBlocker.trim() : "";
@@ -9854,13 +10072,28 @@ function completionBlockerBlocksWorktreeRemoval(indexed, status) {
 }
 
 // src/cleanup-run-liveness.ts
+var TERMINAL_WORKER_JSON_STATUSES = /* @__PURE__ */ new Set([
+  "done",
+  "exited",
+  "blocked",
+  "failed",
+  "abandoned"
+]);
 function deriveRunTerminal(indexed, ctx) {
   if (ctx) return ctx.runTerminalCache.derive(indexed.run);
   return deriveTerminalRunStatus(indexed.run);
 }
 function isWorkerProcessLive(indexed) {
   if (isPidAlive(indexed.worker.pid)) return true;
-  if (!indexed.worker.pid) return indexedWorktreeStatus(indexed).alive;
+  if (typeof indexed.worker.completionReportedAt === "string" && indexed.worker.completionReportedAt.trim().length > 0) {
+    return false;
+  }
+  const workerStatus2 = indexed.worker.status;
+  if (workerStatus2 && TERMINAL_WORKER_JSON_STATUSES.has(workerStatus2)) return false;
+  if (!indexed.worker.pid) {
+    if (workerStatus2 !== "running") return false;
+    return indexedWorktreeStatus(indexed).alive;
+  }
   return false;
 }
 function isRunStaleActive(indexed, ctx) {
@@ -9869,6 +10102,10 @@ function isRunStaleActive(indexed, ctx) {
 }
 function runBlocksWorktreeRemoval(indexed, ctx) {
   if (isWorkerProcessLive(indexed)) return true;
+  const workerStatus2 = indexed.worker.status;
+  if (workerStatus2 && TERMINAL_WORKER_JSON_STATUSES.has(workerStatus2) && !indexed.worker.completionBlocker) {
+    return false;
+  }
   const status = indexedWorktreeStatus(indexed);
   if (completionBlockerBlocksWorktreeRemoval(indexed, status)) return true;
   if (isFinishedWorkerStatus(status)) return false;
@@ -9887,7 +10124,7 @@ function effectiveWorktreeAgeMs(input) {
   if (input.liveness && isRunStaleActive(indexed, input.liveness)) {
     return terminalWorktreesAgeMs;
   }
-  if (input.liveness && isFinishedWorkerStatus(indexedWorktreeStatus(indexed)) && !isWorkerProcessLive(indexed)) {
+  if (input.liveness && isFinishedWorkerStatus(resolveWorktreeGuardStatus(indexed, input.liveness)) && !isWorkerProcessLive(indexed)) {
     return terminalWorktreesAgeMs;
   }
   return worktreesAgeMs;
@@ -9901,8 +10138,13 @@ function skipWorktreeRemoval(input) {
   const ageThresholdMs = effectiveWorktreeAgeMs(input);
   if (worktreesAgeMs <= 0 && !includeOrphans && ageThresholdMs <= 0) return "worktrees_disabled";
   if (ageThresholdMs > 0 && ageMs < ageThresholdMs) return "below_age_threshold";
-  const status = indexedWorktreeStatus(indexed);
   if (isWorkerProcessLive(indexed)) return "active_worker";
+  if (indexedWorktreeHasMaterialChanges(indexed, input.liveness?.gitStatusCache)) {
+    return "dirty_worktree";
+  }
+  const ahead = input.liveness?.gitRevCache?.countAheadOfMain(input.worktreePath);
+  if (ahead !== null && ahead !== void 0 && ahead > 0) return "pr_or_unmerged_commits";
+  const status = resolveWorktreeGuardStatus(indexed, input.liveness);
   if (completionBlockerBlocksWorktreeRemoval(indexed, status)) return "completion_blocked";
   if (runBlocksWorktreeRemoval(indexed, input.liveness)) return "run_still_active";
   if (!isFinishedWorkerStatus(status)) return "run_still_active";
@@ -9933,7 +10175,9 @@ function skipDependencyCacheRemoval(input) {
   if (!diskPressure && ageMs < nodeModulesAgeMs) return "below_age_threshold";
   if (activeWorktreePaths.has(path40.resolve(worktreePath))) return "active_worker";
   if (indexed && isWorkerProcessLive(indexed)) return "active_worker";
-  if (indexed && indexedWorktreeHasMaterialChanges(indexed)) return "dirty_worktree";
+  if (indexed && indexedWorktreeHasMaterialChanges(indexed, input.gitStatusCache)) {
+    return "dirty_worktree";
+  }
   return null;
 }
 function skipBuildCacheRemoval(input) {
@@ -10775,7 +11019,7 @@ function buildWorktreeIndexAt(harnessRoot) {
 }
 
 // src/cleanup-retention-config.ts
-function envFlag2(name) {
+function envFlag3(name) {
   const v = process.env[name];
   return v === "1" || v === "true" || v === "yes";
 }
@@ -10786,17 +11030,17 @@ function envMs(name, fallback) {
   return Number.isFinite(n) && n >= 0 ? n : fallback;
 }
 function resolveHarnessRetention(options = {}) {
-  const execute = options.execute === true || options.execute !== false && envFlag2("KYNVER_CLEANUP_EXECUTE");
-  const finalizeStaleRuns2 = options.finalizeStaleRuns !== false && !envFlag2("KYNVER_CLEANUP_SKIP_FINALIZE");
+  const execute = options.execute === true || options.execute !== false && envFlag3("KYNVER_CLEANUP_EXECUTE");
+  const finalizeStaleRuns2 = options.finalizeStaleRuns !== false && !envFlag3("KYNVER_CLEANUP_SKIP_FINALIZE");
   const nodeModulesAgeMs = options.nodeModulesAgeMs ?? envMs("KYNVER_CLEANUP_NODE_MODULES_AGE_MS", DEFAULT_NODE_MODULES_AGE_MS);
   const worktreesAgeMs = options.worktreesAgeMs ?? envMs("KYNVER_CLEANUP_WORKTREES_AGE_MS", 0);
   const terminalWorktreesAgeMs = options.terminalWorktreesAgeMs ?? envMs("KYNVER_CLEANUP_TERMINAL_WORKTREES_AGE_MS", DEFAULT_TERMINAL_WORKTREES_AGE_MS);
   const runDirectoriesAgeMs = options.runDirectoriesAgeMs ?? envMs("KYNVER_CLEANUP_RUN_DIRECTORIES_AGE_MS", DEFAULT_RUN_DIRECTORIES_AGE_MS);
   const maxActionsPerSweep = options.maxActionsPerSweep ?? envMs("KYNVER_CLEANUP_MAX_ACTIONS_PER_SWEEP", DEFAULT_MAX_ACTIONS_PER_SWEEP);
-  const includeOrphans = options.includeOrphans === true || envFlag2("KYNVER_CLEANUP_INCLUDE_ORPHANS");
-  const scopeAll = envFlag2("KYNVER_CLEANUP_SCOPE_ALL") || process.env.KYNVER_CLEANUP_SCOPE === "all";
+  const includeOrphans = options.includeOrphans === true || envFlag3("KYNVER_CLEANUP_INCLUDE_ORPHANS");
+  const scopeAll = envFlag3("KYNVER_CLEANUP_SCOPE_ALL") || process.env.KYNVER_CLEANUP_SCOPE === "all";
   const runIdFilter = scopeAll ? options.runIdFilter : options.runIdFilter ?? (process.env.KYNVER_CLEANUP_RUN_ID || void 0);
-  const accountBytes = options.accountBytes !== false && !envFlag2("KYNVER_CLEANUP_SKIP_BYTE_ACCOUNTING");
+  const accountBytes = options.accountBytes !== false && !envFlag3("KYNVER_CLEANUP_SKIP_BYTE_ACCOUNTING");
   const storageCapEnv = envMs("KYNVER_CLEANUP_STORAGE_ENTRY_CAP", 2e3);
   const storagePerRunEntryCap = options.storagePerRunEntryCap !== void 0 ? options.storagePerRunEntryCap : accountBytes ? storageCapEnv > 0 ? storageCapEnv : null : null;
   const byteCapEnv = envMs("KYNVER_CLEANUP_BYTE_ENTRY_CAP", 2e3);
@@ -10993,7 +11237,7 @@ function resolveHarnessScanRoots(options = {}) {
 }
 
 // src/cleanup-disk-pressure.ts
-function envFlag3(name) {
+function envFlag4(name) {
   const v = process.env[name];
   return v === "1" || v === "true" || v === "yes";
 }
@@ -11016,7 +11260,7 @@ function observeCleanupDiskPressure(input = {}) {
 }
 function applyDiskPressureToRetention(retention, pressure) {
   if (!pressure.pressured) return retention;
-  const executeOnPressure = retention.execute || !envFlag3("KYNVER_CLEANUP_DRY_RUN_ON_PRESSURE");
+  const executeOnPressure = retention.execute || !envFlag4("KYNVER_CLEANUP_DRY_RUN_ON_PRESSURE");
   return {
     ...retention,
     execute: executeOnPressure,
@@ -11041,6 +11285,37 @@ function emitCleanupProgress(phase, detail) {
   console.error(`[kynver cleanup] ${phase}${suffix}`);
 }
 
+// src/cleanup-git-rev-cache.ts
+var CleanupGitRevCache = class {
+  aheadOfMain = /* @__PURE__ */ new Map();
+  countAheadOfMain(worktreePath, base = "origin/main") {
+    const key = `${worktreePath}\0${base}`;
+    if (this.aheadOfMain.has(key)) return this.aheadOfMain.get(key) ?? null;
+    const result = gitCapture(worktreePath, ["rev-list", "--count", `${base}..HEAD`]);
+    if (result.status !== 0) {
+      this.aheadOfMain.set(key, null);
+      return null;
+    }
+    const count = Number(result.stdout.trim());
+    const parsed = Number.isFinite(count) ? count : null;
+    this.aheadOfMain.set(key, parsed);
+    return parsed;
+  }
+};
+
+// src/cleanup-git-status-cache.ts
+var CleanupGitStatusCache = class {
+  cache = /* @__PURE__ */ new Map();
+  porcelain(worktreePath) {
+    const resolved = worktreePath;
+    const cached = this.cache.get(resolved);
+    if (cached !== void 0) return cached;
+    const lines = gitStatusShort(resolved);
+    this.cache.set(resolved, lines);
+    return lines;
+  }
+};
+
 // src/cleanup-run-terminal-cache.ts
 var CleanupRunTerminalCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -11158,7 +11433,11 @@ function runHarnessCleanup(options = {}) {
   emitCleanupProgress("index", "building worktree index");
   const index = mergeWorktreeIndexes(paths.scanRoots);
   emitCleanupProgress("index", `${index.size} indexed worktree(s)`);
-  const liveness = { runTerminalCache: new CleanupRunTerminalCache() };
+  const liveness = {
+    runTerminalCache: new CleanupRunTerminalCache(),
+    gitStatusCache: new CleanupGitStatusCache(),
+    gitRevCache: new CleanupGitRevCache()
+  };
   const skips = [];
   const actions = [];
   const processedPaths = /* @__PURE__ */ new Set();
@@ -11178,8 +11457,15 @@ function runHarnessCleanup(options = {}) {
       index,
       now: paths.now
     };
-    for (const raw of scanDependencyCacheCandidates(scanOpts)) {
+    const dependencyCandidates = scanDependencyCacheCandidates(scanOpts);
+    emitCleanupProgress("dependency", `${dependencyCandidates.length} cache candidate(s) at ${harnessRoot}`);
+    let dependencyProcessed = 0;
+    for (const raw of dependencyCandidates) {
       if (atSweepCap()) break;
+      dependencyProcessed += 1;
+      if (dependencyProcessed % 50 === 0) {
+        emitCleanupProgress("dependency", `${dependencyProcessed}/${dependencyCandidates.length} evaluated`);
+      }
       const resolved = path53.resolve(raw.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
@@ -11199,7 +11485,8 @@ function runHarnessCleanup(options = {}) {
         ageMs: candidate.ageMs,
         worktreePath,
         activeWorktreePaths: activeGuards.activeWorktreePaths,
-        diskPressure: retention.diskPressure
+        diskPressure: retention.diskPressure,
+        gitStatusCache: liveness.gitStatusCache
       });
       if (guardReason) {
         recordSkip(skips, candidate.path, guardReason);
@@ -11234,7 +11521,8 @@ function runHarnessCleanup(options = {}) {
         ageMs: candidate.ageMs,
         worktreePath,
         activeWorktreePaths: activeGuards.activeWorktreePaths,
-        diskPressure: retention.diskPressure
+        diskPressure: retention.diskPressure,
+        gitStatusCache: liveness.gitStatusCache
       });
       if (guardReason) {
         recordSkip(skips, candidate.path, guardReason);
@@ -11254,8 +11542,13 @@ function runHarnessCleanup(options = {}) {
     ];
     emitCleanupProgress("worktrees", `${worktreeCandidates.length} candidate(s) at ${harnessRoot}`);
     const worktreeSeen = /* @__PURE__ */ new Set();
+    let worktreeProcessed = 0;
     for (const raw of worktreeCandidates) {
       if (atSweepCap()) break;
+      worktreeProcessed += 1;
+      if (worktreeProcessed % 50 === 0) {
+        emitCleanupProgress("worktrees", `${worktreeProcessed}/${worktreeCandidates.length} evaluated`);
+      }
       const resolved = path53.resolve(raw.path);
       if (worktreeSeen.has(resolved)) continue;
       worktreeSeen.add(resolved);
@@ -11851,6 +12144,7 @@ async function awaitDaemonBackoff(ms, isStopping) {
   }
 }
 async function runDaemon(args) {
+  assertNativeDaemonAllowed();
   const runId = String(required(String(args.run || ""), "--run"));
   const agentOsId = String(required(String(args.agentOsId || loadUserConfig().agentOsId || ""), "--agent-os-id"));
   const execute = args.execute !== false && args.execute !== "false";
@@ -13831,12 +14125,12 @@ function assessRuntimeTakeoverScheduler(env, ctx) {
     return check({
       id: "hotspot_openclaw_scheduler",
       label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
-      status: "pass",
-      summary: "KYNVER_SCHEDULER_PROVIDER unset on hosted deployment; scheduler resolves to kynver-cron (Kynver-owned, not OpenClaw)",
-      remediation: "For production hosted AgentOS schedules, set QSTASH_TOKEN and KYNVER_SCHEDULER_PROVIDER=qstash on the Kynver server. Dev/harness hosts may rely on kynver-cron or `kynver daemon` without OpenClaw.",
+      status: "warn",
+      summary: "Hosted deployment with no QSTASH_TOKEN and no KYNVER_SCHEDULER_PROVIDER \u2014 kynver-cron is an in-process stub here and will NOT fire; no firing scheduler is configured",
+      remediation: "Set QSTASH_TOKEN + KYNVER_SCHEDULER_PROVIDER=qstash on the Kynver server for hosted AgentOS schedules. Only use kynver-cron when a `kynver daemon` (or local cron store) actually owns firing on this box.",
       details: {
         schedulerProvider: null,
-        resolvedFallback: "kynver-cron",
+        resolvedFallback: "none",
         qstashTokenPresent: false,
         hostedDeployment
       }
@@ -14638,14 +14932,15 @@ function usage(code = 0) {
       "  kynver runner credential [--agent-os-id ID] [--base-url URL]",
       "  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 status --run RUN_ID [--blocked] [--running] [--task TASK_ID] [--worker WORKER] [--full]  # top-level compact run status",
       "  kynver run create [--repo /path/repo] [--name name] [--base origin/main]",
       "  kynver run list",
       "  kynver run resolve --name RUN_NAME",
-      "  kynver run status --run RUN_ID [--json] [--compact]",
+      "  kynver run status --run RUN_ID [--full]  # defaults to compact shallow map with drill-down commands",
       "  kynver run dispatch --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--execute] [--lane any|implementation|review|landing] [--target-task-id TASK_ID] [--executor harness] [--max-starts 1] [--lease-ms MS] [--owned path[,path]] [--model claude-opus-4-8] [--disk-path /] [--reconcile-stale-blockers]",
       "  kynver run sweep --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--grace-ms MS]",
       '  kynver worker start --run RUN_ID --name worker --task "..." [--owned path[,path]] [--model MODEL] [--provider claude|cursor] [--agent-os-id AOS_ID] [--task-id TASK_ID] [--wait]',
-      "  kynver worker list --run RUN_ID [--json] [--compact] [--full]",
+      "  kynver worker list --run RUN_ID [--full]  # defaults to compact shallow map with drill-down commands",
       "  kynver worker status --run RUN_ID --name worker",
       "  kynver worker tail --run RUN_ID --name worker [--lines 40] [--raw]",
       "  kynver worker stop --run RUN_ID --name worker",
@@ -14699,6 +14994,9 @@ async function main(argv = process.argv.slice(2)) {
   const { runsDir, worktreesDir } = getPaths();
   mkdirSync10(runsDir, { recursive: true });
   mkdirSync10(worktreesDir, { recursive: true });
+  if (scope === "daemon") {
+    assertNativeDaemonAllowed();
+  }
   if (shouldEnforceMemoryCostPackageGuardCli(scope, action)) {
     let repoRoot;
     const runId = args.run ? String(args.run).trim() : "";
@@ -14715,6 +15013,7 @@ async function main(argv = process.argv.slice(2)) {
     });
   }
   if (scope === "login") return void await runLogin(args);
+  if (scope === "status") return runStatus(args);
   if (scope === "runner" && action === "credential") return void await mintRunnerCredential(args);
   if (scope === "setup") return void await runSetup(args);
   if (scope === "daemon") return void await runDaemon(args);