@kynver-app/runtime 0.1.76 → 0.1.79

package/dist/cli.js

@@ -746,23 +746,23 @@ function isWslHost() {
 function observeWslHostDisk(options = {}) {
   const wsl = options.forceWsl === void 0 ? isWslHost() : options.forceWsl;
   if (!wsl) return null;
-  const path59 = options.wslHostMount?.trim() || process.env.KYNVER_WSL_HOST_MOUNT?.trim() || DEFAULT_WSL_HOST_MOUNT;
+  const path62 = 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(path59);
+    stats = statfs(path62);
   } catch (error) {
     return {
       ok: false,
-      path: path59,
+      path: path62,
       freeBytes: 0,
       totalBytes: 0,
       usedPercent: 100,
       warnBelowBytes,
       criticalBelowBytes,
-      reason: `Windows host disk probe failed at ${path59}: ${error.message}`,
+      reason: `Windows host disk probe failed at ${path62}: ${error.message}`,
       probeError: error.message
     };
   }
@@ -776,11 +776,11 @@ function observeWslHostDisk(options = {}) {
   let reason = null;
   if (!ok) {
     const tag = criticalFree ? "critical" : "warning";
-    reason = `Windows host disk ${path59} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
+    reason = `Windows host disk ${path62} at ${tag}: ${freeGiB} GiB free (<${(criticalFree ? criticalBelowBytes : warnBelowBytes) / 1024 / 1024 / 1024} GiB); WSL VHDX cannot grow safely. ${summarizeWslRecoverySteps()}`;
   }
   return {
     ok,
-    path: path59,
+    path: path62,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -800,12 +800,12 @@ var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
 var DEFAULT_MAX_USED_PERCENT = 80;
 var DEFAULT_HARD_MAX_USED_PERCENT = 90;
 function observeRunnerDiskGate(input = {}) {
-  const path59 = input.diskPath?.trim() || "/";
+  const path62 = 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(path59);
+  const stats = statfsSync2(path62);
   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;
@@ -828,7 +828,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path59,
+    path: path62,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -1813,7 +1813,9 @@ function computeWorkerStatus(worker, options = {}) {
     finalResult,
     error,
     changedFiles,
-    gitAncestry
+    gitAncestry,
+    instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
+    instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null
   };
 }
 function isFinishedWorkerStatus(status) {
@@ -2578,7 +2580,9 @@ function resolveOrchestrationRouting(input) {
   const risk = classifyOrchestrationRisk(task);
   const inventory = resolveInventory({
     inventory: input.inventory,
-    codexBinding: input.codexBinding ?? resolveCodexOrchestrationAdapter()
+    // When callers pass a pre-built inventory (tests, CC snapshots), do not probe live
+    // Hermes/Codex bindings — that would overwrite mocked oauth_local with subscription_hermes.
+    codexBinding: input.codexBinding ?? (input.inventory ? null : resolveCodexOrchestrationAdapter())
   });
   const explicit = input.preferLowCost === false ? null : input.explicitProvider?.trim().toLowerCase();
   const explicitModel = input.explicitModel?.trim() || void 0;
@@ -3392,6 +3396,7 @@ function buildPrompt(input) {
     "",
     ...input.personaMarkdown?.trim() ? [input.personaMarkdown.trim(), ""] : [],
     ...input.instructionPolicyMarkdown?.trim() ? ["Operating rules (Lane A \u2014 from AgentOS memory policy):", input.instructionPolicyMarkdown.trim(), ""] : [],
+    ...input.memoryQualityMarkdown?.trim() ? [input.memoryQualityMarkdown.trim(), ""] : [],
     ...input.repairTargetPrUrl ? [
       ...repairTargetPromptLines({
         targetPrUrl: input.repairTargetPrUrl,
@@ -3600,6 +3605,21 @@ function persistCompletionAck(worker, runId, fields) {
   saveWorker(runId, worker);
 }
 
+// src/completion-replay.ts
+function trimBlocker(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+function shouldReplayHarnessCompletion(worker) {
+  if (trimBlocker(worker.completionBlocker)) return true;
+  if (worker.completionOutcome === "rejected") return true;
+  return false;
+}
+function hasTerminalCompletionAck(worker) {
+  return hasCompletionAck(worker) && !shouldReplayHarnessCompletion(worker);
+}
+
 // src/worker-ops.ts
 import path17 from "node:path";
 
@@ -4171,8 +4191,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 path59 = normalizeRelativePath(pathFromGitStatusLine(line));
-    return removedSet.has(path59);
+    const path62 = normalizeRelativePath(pathFromGitStatusLine(line));
+    return removedSet.has(path62);
   });
 }
 
@@ -4418,7 +4438,7 @@ async function tryCompleteWorker(args) {
     return { ok: true, skipped: true, reason: "worker-not-finished" };
   }
   const forceReplay = args.force === true || args.force === "true";
-  if (!forceReplay && hasCompletionAck(worker)) {
+  if (!forceReplay && hasTerminalCompletionAck(worker)) {
     return {
       ok: true,
       skipped: true,
@@ -4594,7 +4614,9 @@ async function completeWorker(args) {
   }
 }
 function workerStatus(args) {
-  const worker = loadWorker(String(args.run), String(args.name));
+  const runId = required(typeof args.run === "string" ? args.run : "", "--run");
+  const name = required(typeof args.name === "string" ? args.name : "", "--name");
+  const worker = loadWorker(runId, name);
   const run = loadRun(worker.runId);
   const status = computeWorkerStatus(worker, workerStatusOptions(run));
   writeJson(path17.join(worker.workerDir, "last-status.json"), status);
@@ -4810,7 +4832,7 @@ async function autoCompleteWorker(raw) {
       reason: "worker has no agentOsId/taskId \u2014 nothing to attribute completion to"
     };
   }
-  if (hasCompletionAck(worker)) {
+  if (hasTerminalCompletionAck(worker)) {
     return {
       worker: worker.name,
       runId: worker.runId,
@@ -4823,7 +4845,7 @@ async function autoCompleteWorker(raw) {
   const startMs = Date.now();
   while (true) {
     worker = loadWorker(args.run, args.name);
-    if (hasCompletionAck(worker)) {
+    if (hasTerminalCompletionAck(worker)) {
       return {
         worker: worker.name,
         runId: worker.runId,
@@ -5029,6 +5051,7 @@ function spawnWorkerProcess(run, opts) {
     planId: opts.planId,
     taskId: opts.taskId,
     instructionPolicyMarkdown: opts.instructionPolicyMarkdown,
+    memoryQualityMarkdown: opts.memoryQualityPromptMarkdown ?? opts.memoryQualityCapture?.promptMarkdown ?? null,
     personaMarkdown: opts.personaMarkdown,
     model: launchModel,
     repairTargetPrUrl: opts.repairTargetPrUrl,
@@ -5807,11 +5830,13 @@ function readHarnessWorkerContext(decision) {
   const personaEvidence = ctx.personaEvidence && typeof ctx.personaEvidence === "object" ? ctx.personaEvidence : null;
   const personaInjectionReady = ctx.personaInjectionReady === true;
   const memoryQualityCapture = ctx.memoryQualityCapture && typeof ctx.memoryQualityCapture === "object" ? ctx.memoryQualityCapture : null;
+  const memoryQualityPromptMarkdown = typeof ctx.memoryQualityPromptMarkdown === "string" ? ctx.memoryQualityPromptMarkdown : typeof memoryQualityCapture?.promptMarkdown === "string" ? memoryQualityCapture.promptMarkdown : null;
   return {
     instructionPolicyMarkdown: markdown,
     instructionPolicyFingerprint: fingerprint,
     instructionPolicyEvidence: evidence,
     memoryQualityCapture,
+    memoryQualityPromptMarkdown,
     personaMarkdown,
     personaSlug,
     personaEvidence,
@@ -6068,6 +6093,7 @@ async function dispatchRun(args) {
           instructionPolicyFingerprint: harnessContext?.instructionPolicyFingerprint ?? null,
           instructionPolicyEvidence: harnessContext?.instructionPolicyEvidence ?? null,
           memoryQualityCapture: harnessContext?.memoryQualityCapture ?? null,
+          memoryQualityPromptMarkdown: harnessContext?.memoryQualityPromptMarkdown ?? null,
           personaMarkdown: harnessContext?.personaMarkdown ?? null,
           personaSlug: harnessContext?.personaSlug ?? expectedPersona,
           personaEvidence: harnessContext?.personaEvidence ?? null,
@@ -6122,7 +6148,23 @@ async function dispatchRun(args) {
     for (const decision of result.started) {
       shouldContinueDispatch = await spawnClaimed(decision) && shouldContinueDispatch;
     }
-    skipped.push(...result.skipped ?? []);
+    skipped.push(
+      ...result.skipped ?? []
+    );
+    if (exactTargetMode) {
+      for (const skipDecision of skipped) {
+        const taskId = String(skipDecision.task.id);
+        if (!exactTargetIds.has(taskId)) continue;
+        outcomes.push({
+          taskId,
+          started: false,
+          error: `exact_target_not_started:${skipDecision.skipReason}`,
+          skipReason: skipDecision.skipReason,
+          detail: skipDecision.reason ?? null,
+          requestedTargetTaskIds: [...exactTargetIds]
+        });
+      }
+    }
     if (exactTargetMode) shouldContinueDispatch = false;
     while (shouldContinueDispatch && outcomes.length < cappedStarts) {
       if (exactTargetMode) break;
@@ -6235,15 +6277,15 @@ async function sweepRun(args) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync5 } from "node:fs";
-import path32 from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync5 } from "node:fs";
+import path33 from "node:path";
 
 // src/run-list.ts
-import { existsSync as existsSync22, readFileSync as readFileSync10 } from "node:fs";
-import path29 from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync10 } from "node:fs";
+import path31 from "node:path";
 
 // src/stale-reconcile.ts
-import path28 from "node:path";
+import path30 from "node:path";
 
 // src/finalize.ts
 import path25 from "node:path";
@@ -6304,8 +6346,8 @@ function finalizeStaleRuns() {
 }
 
 // src/worker-metadata-reconcile.ts
-import { existsSync as existsSync21, lstatSync, readdirSync as readdirSync5, readlinkSync, renameSync as renameSync2, rmSync } from "node:fs";
-import path27 from "node:path";
+import { existsSync as existsSync22, lstatSync, readdirSync as readdirSync6, readlinkSync, renameSync as renameSync2, rmSync } from "node:fs";
+import path29 from "node:path";
 
 // src/worker-metadata-paths.ts
 import path26 from "node:path";
@@ -6350,6 +6392,192 @@ function resolveWorkerJsonPath(input) {
   return canonical;
 }
 
+// src/run-metadata-retention.ts
+import { existsSync as existsSync21, readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
+import path28 from "node:path";
+
+// src/default-repo.ts
+import path27 from "node:path";
+function expandConfiguredRepo(value) {
+  return path27.resolve(resolveUserPath(value.trim()));
+}
+function fromConfigured(value, source, persistedInConfig) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  return {
+    repo: expandConfiguredRepo(trimmed),
+    source,
+    persistedInConfig
+  };
+}
+function resolveDefaultRepo(opts = {}) {
+  const env = opts.env ?? process.env;
+  const config = opts.config ?? loadUserConfig();
+  const fromConfig = fromConfigured(config.defaultRepo, "config", true);
+  if (fromConfig) return fromConfig;
+  const fromDefaultEnv = fromConfigured(env.KYNVER_DEFAULT_REPO, "env_default_repo", false);
+  if (fromDefaultEnv) return fromDefaultEnv;
+  const fromHarnessEnv = fromConfigured(env.KYNVER_HARNESS_REPO, "env_harness_repo", false);
+  if (fromHarnessEnv) return fromHarnessEnv;
+  const discovered = discoverDefaultRepo({
+    cwd: opts.cwd,
+    runtimeModuleUrl: opts.runtimeModuleUrl
+  });
+  if (!discovered) return null;
+  return {
+    repo: discovered.repo,
+    source: discovered.source,
+    persistedInConfig: false
+  };
+}
+function formatResolvedDefaultRepo(resolved) {
+  return {
+    defaultRepo: displayUserPath(resolved.repo),
+    source: resolved.source,
+    persistedInConfig: resolved.persistedInConfig
+  };
+}
+
+// src/run-metadata-retention.ts
+var RUN_METADATA_ACTIVE_SIGNAL_MS = 15 * 60 * 1e3;
+function isHarnessRunMetadataPath(targetPath, harnessRoot) {
+  const resolved = path28.resolve(targetPath);
+  const runsDir = path28.resolve(harnessRunsDir(harnessRoot));
+  const rel = path28.relative(runsDir, resolved);
+  return rel !== ".." && !rel.startsWith("..") && !path28.isAbsolute(rel);
+}
+function listRunDirIds(runsDir) {
+  if (!existsSync21(runsDir)) return [];
+  try {
+    return readdirSync5(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "runs").map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function listWorkerNamesOnDisk(runDir2) {
+  const workersDir = path28.join(runDir2, "workers");
+  if (!existsSync21(workersDir)) return [];
+  try {
+    return readdirSync5(workersDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function pathRecentlyTouched(target, now, windowMs) {
+  if (!existsSync21(target)) return false;
+  try {
+    const age = now - statSync4(target).mtimeMs;
+    return Number.isFinite(age) && age >= 0 && age < windowMs;
+  } catch {
+    return false;
+  }
+}
+function workerDirHasActiveRetentionSignals(workerDir, now = Date.now(), windowMs = RUN_METADATA_ACTIVE_SIGNAL_MS) {
+  if (!existsSync21(workerDir)) return false;
+  const artifacts = workerArtifactPaths(workerDir);
+  const worker = readJson(
+    artifacts.workerJsonPath,
+    void 0
+  );
+  if (worker?.status === "running" && isPidAlive(worker.pid)) return true;
+  const heartbeat = parseHeartbeat(artifacts.heartbeatPath);
+  if (heartbeat.lastHeartbeatAt) {
+    const age = now - Date.parse(heartbeat.lastHeartbeatAt);
+    if (Number.isFinite(age) && age >= 0 && age < windowMs) return true;
+  }
+  if (pathRecentlyTouched(artifacts.stdoutPath, now, windowMs)) return true;
+  if (pathRecentlyTouched(artifacts.heartbeatPath, now, windowMs)) return true;
+  return false;
+}
+function runDirHasActiveRetentionSignals(runDir2, now = Date.now(), windowMs = RUN_METADATA_ACTIVE_SIGNAL_MS) {
+  for (const name of listWorkerNamesOnDisk(runDir2)) {
+    if (workerDirHasActiveRetentionSignals(path28.join(runDir2, "workers", name), now, windowMs)) {
+      return true;
+    }
+  }
+  return false;
+}
+function inferRepoFields() {
+  const resolved = resolveDefaultRepo();
+  return {
+    repo: resolved?.repo ?? "",
+    base: "origin/main",
+    baseCommit: "unknown"
+  };
+}
+function synthesizeRunFromDisk(harnessRoot, runId) {
+  const runDir2 = path28.join(harnessRunsDir(harnessRoot), safeSlug(runId));
+  if (!existsSync21(runDir2)) return null;
+  const workerNames = listWorkerNamesOnDisk(runDir2);
+  if (workerNames.length === 0) return null;
+  let createdAt;
+  try {
+    createdAt = statSync4(runDir2).birthtime.toISOString();
+  } catch {
+    createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  const workers = {};
+  for (const name of workerNames) {
+    const canonicalDir = canonicalWorkerDir(harnessRoot, runId, name);
+    workers[name] = {
+      workerDir: canonicalDir,
+      statusPath: path28.join(canonicalDir, "worker.json")
+    };
+  }
+  const hasActive = runDirHasActiveRetentionSignals(runDir2);
+  return {
+    id: runId,
+    name: runId,
+    ...inferRepoFields(),
+    status: hasActive ? "running" : "needs_attention",
+    createdAt,
+    workers
+  };
+}
+function repairMissingRunMetadata(harnessRootInput) {
+  const harnessRoot = normalizeHarnessRoot(harnessRootInput ?? resolveHarnessRoot());
+  const runsDir = harnessRunsDir(harnessRoot);
+  const outcomes = [];
+  for (const runId of listRunDirIds(runsDir)) {
+    const runJsonPath = path28.join(runsDir, runId, "run.json");
+    if (existsSync21(runJsonPath)) {
+      outcomes.push({
+        runId,
+        action: "skipped",
+        reason: "run.json present"
+      });
+      continue;
+    }
+    const synthesized = synthesizeRunFromDisk(harnessRoot, runId);
+    if (!synthesized) {
+      outcomes.push({
+        runId,
+        action: "skipped",
+        reason: "no worker dirs on disk"
+      });
+      continue;
+    }
+    saveRun(synthesized);
+    outcomes.push({
+      runId,
+      action: "repaired_run_json",
+      reason: runDirHasActiveRetentionSignals(path28.join(runsDir, runId)) ? "synthesized run.json while worker artifacts still active" : "synthesized run.json from orphan worker metadata dirs"
+    });
+  }
+  return { runs: outcomes };
+}
+function collectFilesystemLiveRunKeys(harnessRoot, now = Date.now()) {
+  const keys = /* @__PURE__ */ new Set();
+  const runsDir = harnessRunsDir(harnessRoot);
+  for (const runId of listRunDirIds(runsDir)) {
+    const runDir2 = path28.join(runsDir, runId);
+    if (runDirHasActiveRetentionSignals(runDir2, now)) {
+      keys.add(`${harnessRoot}\0${runId}`);
+    }
+  }
+  return keys;
+}
+
 // src/worker-metadata-reconcile.ts
 function materializeSymlinkedRunDir(harnessRoot, runId) {
   const canonical = canonicalRunDir(harnessRoot, runId);
@@ -6360,7 +6588,10 @@ function materializeSymlinkedRunDir(harnessRoot, runId) {
     return null;
   }
   if (!stat.isSymbolicLink()) return null;
-  const linkedTarget = path27.resolve(path27.dirname(canonical), readlinkSync(canonical));
+  const linkedTarget = path29.resolve(path29.dirname(canonical), readlinkSync(canonical));
+  if (runDirHasActiveRetentionSignals(linkedTarget) || runDirHasActiveRetentionSignals(canonical)) {
+    return null;
+  }
   const staging = `${canonical}.materialize-${Date.now()}`;
   renameSync2(linkedTarget, staging);
   rmSync(canonical);
@@ -6370,9 +6601,9 @@ function materializeSymlinkedRunDir(harnessRoot, runId) {
 function relocateArtifacts(input) {
   const moved = [];
   for (const fileName of workerArtifactFileNames()) {
-    const from = path27.join(input.fromDir, fileName);
-    const to = path27.join(input.toDir, fileName);
-    if (!existsSync21(from) || existsSync21(to)) continue;
+    const from = path29.join(input.fromDir, fileName);
+    const to = path29.join(input.toDir, fileName);
+    if (!existsSync22(from) || existsSync22(to)) continue;
     renameSync2(from, to);
     moved.push(fileName);
   }
@@ -6411,8 +6642,8 @@ function deriveSynthesizedStatus(input) {
 function synthesizeWorkerFromArtifacts(input) {
   const artifacts = workerArtifactPaths(input.canonicalDir);
   const lastStatus = readJson(artifacts.lastStatusPath, void 0);
-  const stdoutExists = existsSync21(artifacts.stdoutPath);
-  const heartbeatExists = existsSync21(artifacts.heartbeatPath);
+  const stdoutExists = existsSync22(artifacts.stdoutPath);
+  const heartbeatExists = existsSync22(artifacts.heartbeatPath);
   const hasArtifacts = stdoutExists || heartbeatExists || lastStatus != null;
   if (!hasArtifacts) return null;
   const parsedStdout = stdoutExists ? parseHarnessStream(artifacts.stdoutPath) : { finalResult: null };
@@ -6428,7 +6659,7 @@ function synthesizeWorkerFromArtifacts(input) {
     runId: input.run.id,
     status,
     branch: typeof lastStatus?.branch === "string" ? lastStatus.branch : `agent/${input.run.id}/${input.workerName}`,
-    worktreePath: typeof lastStatus?.worktreePath === "string" ? lastStatus.worktreePath : path27.join(getPaths().worktreesDir, input.run.id, input.workerName),
+    worktreePath: typeof lastStatus?.worktreePath === "string" ? lastStatus.worktreePath : path29.join(getPaths().worktreesDir, input.run.id, input.workerName),
     workerDir: input.canonicalDir,
     stdoutPath: artifacts.stdoutPath,
     stderrPath: artifacts.stderrPath,
@@ -6455,7 +6686,7 @@ function repairRunWorkerIndex(run, harnessRoot) {
   const nextWorkers = { ...run.workers || {} };
   for (const [name, ref] of Object.entries(nextWorkers)) {
     const canonicalDir = canonicalWorkerDir(harnessRoot, run.id, name);
-    const canonicalStatus = path27.join(canonicalDir, "worker.json");
+    const canonicalStatus = path29.join(canonicalDir, "worker.json");
     const nested = hasNestedRunsSegment(ref.workerDir) || hasNestedRunsSegment(ref.statusPath) || ref.workerDir !== canonicalDir || ref.statusPath !== canonicalStatus;
     if (!nested) continue;
     nextWorkers[name] = { workerDir: canonicalDir, statusPath: canonicalStatus };
@@ -6488,7 +6719,7 @@ function reconcileOneWorker(input) {
     statusPath: input.statusPath
   });
   let worker = readJson(workerJsonPath, void 0);
-  if (!worker && existsSync21(canonicalArtifacts.workerJsonPath)) {
+  if (!worker && existsSync22(canonicalArtifacts.workerJsonPath)) {
     worker = readJson(canonicalArtifacts.workerJsonPath, void 0);
   }
   if (!worker) {
@@ -6508,15 +6739,15 @@ function reconcileOneWorker(input) {
       });
       return outcomes;
     }
-    const dirExists = existsSync21(canonicalDir);
-    const hasAnyArtifact = workerArtifactFileNames().some((f) => existsSync21(path27.join(canonicalDir, f)));
+    const dirExists = existsSync22(canonicalDir);
+    const hasAnyArtifact = workerArtifactFileNames().some((f) => existsSync22(path29.join(canonicalDir, f)));
     if (dirExists && !hasAnyArtifact) {
       const abandoned = {
         name: input.workerName,
         runId: input.run.id,
         status: "exited",
         branch: `agent/${input.run.id}/${input.workerName}`,
-        worktreePath: path27.join(getPaths().worktreesDir, input.run.id, input.workerName),
+        worktreePath: path29.join(getPaths().worktreesDir, input.run.id, input.workerName),
         workerDir: canonicalDir,
         stdoutPath: canonicalArtifacts.stdoutPath,
         stderrPath: canonicalArtifacts.stderrPath,
@@ -6563,11 +6794,11 @@ function reconcileOneWorker(input) {
   return outcomes;
 }
 function listOrphanWorkerNames(run, harnessRoot) {
-  const workersDir = path27.join(runDirectory(run.id), "workers");
-  if (!existsSync21(workersDir)) return [];
+  const workersDir = path29.join(runDirectory(run.id), "workers");
+  if (!existsSync22(workersDir)) return [];
   const indexed = new Set(Object.keys(run.workers || {}));
   const orphans = [];
-  for (const entry of readdirSync5(workersDir, { withFileTypes: true })) {
+  for (const entry of readdirSync6(workersDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     if (indexed.has(entry.name)) continue;
     orphans.push(entry.name);
@@ -6576,6 +6807,7 @@ function listOrphanWorkerNames(run, harnessRoot) {
 }
 function reconcileWorkerMetadata() {
   const { harnessRoot } = getPaths();
+  const runMetadataRetention = repairMissingRunMetadata(harnessRoot);
   const outcomes = [];
   for (const run of listRunRecords()) {
     const materializedFrom = materializeSymlinkedRunDir(harnessRoot, run.id);
@@ -6602,7 +6834,7 @@ function reconcileWorkerMetadata() {
         ...run.workers || {},
         [orphan]: {
           workerDir: canonicalWorkerDir(harnessRoot, run.id, orphan),
-          statusPath: path27.join(canonicalWorkerDir(harnessRoot, run.id, orphan), "worker.json")
+          statusPath: path29.join(canonicalWorkerDir(harnessRoot, run.id, orphan), "worker.json")
         }
       };
       saveRun(run);
@@ -6625,7 +6857,7 @@ function reconcileWorkerMetadata() {
       );
     }
   }
-  return { workers: outcomes };
+  return { workers: outcomes, runMetadataRetention };
 }
 
 // src/stale-reconcile.ts
@@ -6642,7 +6874,7 @@ function reconcileStaleWorkers() {
   const now = Date.now();
   for (const run of listRunRecords()) {
     for (const name of Object.keys(run.workers || {})) {
-      const workerPath = path28.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path30.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
       const worker = readJson(workerPath, void 0);
       if (!worker || worker.status !== "running") {
         outcomes.push({
@@ -6725,16 +6957,28 @@ function reconcileRunsCli() {
     acc[row.action] = (acc[row.action] ?? 0) + 1;
     return acc;
   }, {});
+  const runRetentionTotals = result.metadataReconcile.runMetadataRetention.runs.reduce((acc, row) => {
+    acc[row.action] = (acc[row.action] ?? 0) + 1;
+    return acc;
+  }, {});
   console.log(
     JSON.stringify(
       {
         ok: true,
         workers: { markedExited, killedStale, skipped, total: result.workers.length },
-        metadataReconcile: { totals: metadataTotals, total: result.metadataReconcile.workers.length },
+        metadataReconcile: {
+          totals: metadataTotals,
+          total: result.metadataReconcile.workers.length,
+          runMetadataRetention: {
+            totals: runRetentionTotals,
+            total: result.metadataReconcile.runMetadataRetention.runs.length
+          }
+        },
         finalizedRuns: result.finalizedRuns.length,
         details: {
           workers: result.workers,
           metadataReconcile: result.metadataReconcile.workers,
+          runMetadataRetention: result.metadataReconcile.runMetadataRetention.runs,
           finalizedRuns: result.finalizedRuns
         }
       },
@@ -6746,7 +6990,7 @@ function reconcileRunsCli() {
 
 // src/run-list.ts
 function heartbeatByteLength(heartbeatPath) {
-  if (!heartbeatPath || !existsSync22(heartbeatPath)) return 0;
+  if (!heartbeatPath || !existsSync23(heartbeatPath)) return 0;
   try {
     return readFileSync10(heartbeatPath, "utf8").trim().length;
   } catch {
@@ -6754,7 +6998,7 @@ function heartbeatByteLength(heartbeatPath) {
   }
 }
 function workerEvidence(run, workerName) {
-  const workerPath = path29.join(runDirectory(run.id), "workers", safeSlug(workerName), "worker.json");
+  const workerPath = path31.join(runDirectory(run.id), "workers", safeSlug(workerName), "worker.json");
   const worker = readJson(workerPath, void 0);
   if (!worker) {
     return {
@@ -6811,7 +7055,7 @@ function aggregateRunAttention(workers) {
 function countOpenWorkers(run) {
   let open = 0;
   for (const name of Object.keys(run.workers || {})) {
-    const workerPath = path29.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+    const workerPath = path31.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
     const worker = readJson(workerPath, void 0);
     if (!worker) continue;
     const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
@@ -6859,50 +7103,8 @@ function listRunsCli() {
   console.log(JSON.stringify(buildRunListRows(), null, 2));
 }
 
-// src/default-repo.ts
-import path30 from "node:path";
-function expandConfiguredRepo(value) {
-  return path30.resolve(resolveUserPath(value.trim()));
-}
-function fromConfigured(value, source, persistedInConfig) {
-  const trimmed = value?.trim();
-  if (!trimmed) return null;
-  return {
-    repo: expandConfiguredRepo(trimmed),
-    source,
-    persistedInConfig
-  };
-}
-function resolveDefaultRepo(opts = {}) {
-  const env = opts.env ?? process.env;
-  const config = opts.config ?? loadUserConfig();
-  const fromConfig = fromConfigured(config.defaultRepo, "config", true);
-  if (fromConfig) return fromConfig;
-  const fromDefaultEnv = fromConfigured(env.KYNVER_DEFAULT_REPO, "env_default_repo", false);
-  if (fromDefaultEnv) return fromDefaultEnv;
-  const fromHarnessEnv = fromConfigured(env.KYNVER_HARNESS_REPO, "env_harness_repo", false);
-  if (fromHarnessEnv) return fromHarnessEnv;
-  const discovered = discoverDefaultRepo({
-    cwd: opts.cwd,
-    runtimeModuleUrl: opts.runtimeModuleUrl
-  });
-  if (!discovered) return null;
-  return {
-    repo: discovered.repo,
-    source: discovered.source,
-    persistedInConfig: false
-  };
-}
-function formatResolvedDefaultRepo(resolved) {
-  return {
-    defaultRepo: displayUserPath(resolved.repo),
-    source: resolved.source,
-    persistedInConfig: resolved.persistedInConfig
-  };
-}
-
 // src/validate.ts
-import path31 from "node:path";
+import path32 from "node:path";
 var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 function validateRunId(runId) {
   const trimmed = runId.trim();
@@ -6910,7 +7112,7 @@ function validateRunId(runId) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path31.resolve(repo);
+  const resolved = path32.resolve(repo);
   if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
   return resolved;
 }
@@ -6929,7 +7131,7 @@ function createRun(args) {
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync23(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync24(dir)) failExists(`run already exists: ${id}`);
   mkdirSync5(dir, { recursive: true });
   const base = String(args.base || "origin/main");
   const baseCommit = git(repo, ["rev-parse", base]).trim();
@@ -6943,7 +7145,7 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path32.join(dir, "run.json"), run);
+  writeJson(path33.join(dir, "run.json"), run);
   console.log(JSON.stringify({ runId: id, runDir: dir, repo, base, baseCommit }, null, 2));
 }
 function listRuns() {
@@ -6955,8 +7157,8 @@ function failExists(message) {
 }
 
 // src/discard-disposable.ts
-import { existsSync as existsSync24, rmSync as rmSync2 } from "node:fs";
-import path33 from "node:path";
+import { existsSync as existsSync25, rmSync as rmSync2 } from "node:fs";
+import path34 from "node:path";
 function normalizeRelativePath2(value) {
   const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").trim();
   if (!normalized || normalized.startsWith("/") || normalized.includes("..")) {
@@ -6977,15 +7179,15 @@ function discardDisposableArtifacts(args) {
   if (paths.length === 0) {
     return { ok: false, removed: [], reason: "requires at least one --path" };
   }
-  const worktreeRoot = path33.resolve(worker.worktreePath);
+  const worktreeRoot = path34.resolve(worker.worktreePath);
   const removed = [];
   for (const raw of paths) {
     const rel = normalizeRelativePath2(raw);
-    const abs = path33.resolve(worktreeRoot, rel);
-    if (!abs.startsWith(worktreeRoot + path33.sep) && abs !== worktreeRoot) {
+    const abs = path34.resolve(worktreeRoot, rel);
+    if (!abs.startsWith(worktreeRoot + path34.sep) && abs !== worktreeRoot) {
       return { ok: false, removed, reason: `path escapes worktree: ${raw}` };
     }
-    if (!existsSync24(abs)) {
+    if (!existsSync25(abs)) {
       return { ok: false, removed, reason: `path not found: ${raw}` };
     }
     rmSync2(abs, { recursive: true, force: true });
@@ -7007,8 +7209,472 @@ function discardDisposableCli(args) {
   if (!result.ok) process.exit(1);
 }
 
+// src/cron/cron-env.ts
+import { existsSync as existsSync26 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import path35 from "node:path";
+function envFlag(name, defaultValue) {
+  const raw = process.env[name]?.trim().toLowerCase();
+  if (!raw) return defaultValue;
+  if (raw === "0" || raw === "false" || raw === "no" || raw === "off") return false;
+  if (raw === "1" || raw === "true" || raw === "yes" || raw === "on") return true;
+  return defaultValue;
+}
+function envInt(name, fallback, min = 1) {
+  const n = Number(process.env[name]);
+  if (!Number.isFinite(n) || n < min) return fallback;
+  return Math.floor(n);
+}
+function defaultKynverCronStorePath() {
+  const explicit = process.env.KYNVER_CRON_STORE_PATH?.trim() || process.env.OPENCLAW_CRON_STORE_PATH?.trim();
+  if (explicit) return explicit;
+  return path35.join(homedir11(), ".kynver", "agent-os-cron.json");
+}
+function defaultKynverCronStatePath(storePath = defaultKynverCronStorePath()) {
+  const explicit = process.env.KYNVER_CRON_TICK_STATE_PATH?.trim();
+  if (explicit) return explicit;
+  return `${storePath.replace(/\.json$/i, "")}.tick-state.json`;
+}
+function resolveKynverCronFireBaseUrl() {
+  const config = loadUserConfig();
+  return process.env.KYNVER_API_URL?.trim() || config.apiBaseUrl?.trim() || process.env.KYNVER_CRON_FIRE_BASE_URL?.trim() || process.env.OPENCLAW_CRON_FIRE_BASE_URL?.trim() || null;
+}
+function resolveKynverCronSecret() {
+  return process.env.KYNVER_CRON_SECRET?.trim() || process.env.OPENCLAW_CRON_SECRET?.trim() || process.env.KYNVER_RUNTIME_SECRET?.trim() || null;
+}
+function resolveKynverCronEnv() {
+  const storePath = defaultKynverCronStorePath();
+  const statePath = defaultKynverCronStatePath(storePath);
+  const fireBaseUrl = resolveKynverCronFireBaseUrl();
+  const secret = resolveKynverCronSecret();
+  const credsReady = Boolean(fireBaseUrl && secret);
+  const storeExists = existsSync26(storePath);
+  const defaultEnabled = credsReady && (storeExists || envFlag("KYNVER_CRON_TICK_FORCE", false));
+  return {
+    storePath,
+    statePath,
+    lockPath: `${statePath}.lock`,
+    fireBaseUrl,
+    secret,
+    tickEnabled: envFlag("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),
+    maxRetries: envInt("KYNVER_CRON_MAX_RETRIES", 3, 0),
+    retryBackoffMs: envInt("KYNVER_CRON_RETRY_BACKOFF_MS", 6e4, 1e3),
+    inflightLeaseMs: envInt("KYNVER_CRON_INFLIGHT_LEASE_MS", 12e4, 5e3)
+  };
+}
+function isKynverCronDaemonPrimary(env = resolveKynverCronEnv()) {
+  return env.tickEnabled && Boolean(env.fireBaseUrl && env.secret);
+}
+
+// src/cron/cron-fire.ts
+function trimTrailingSlash2(url) {
+  return url.replace(/\/+$/, "");
+}
+async function fireKynverCronJob(input) {
+  const doFetch = input.fetchFn ?? fetch;
+  const callbackPath = input.entry.spec.callbackPath.startsWith("/") ? input.entry.spec.callbackPath : `/${input.entry.spec.callbackPath}`;
+  const url = `${trimTrailingSlash2(input.baseUrl)}${callbackPath}`;
+  const jobId = input.jobId ?? input.entry.spec.dedupeKey ?? null;
+  const body = {
+    source: "kynver-cron",
+    jobId,
+    agentOsId: input.entry.spec.target.agentOsId,
+    kind: input.entry.spec.kind,
+    target: input.entry.spec.target,
+    ...input.entry.spec.payload !== void 0 && { payload: input.entry.spec.payload }
+  };
+  const res = await doFetch(url, {
+    method: "POST",
+    headers: buildHarnessCallbackHeaders(input.secret),
+    body: JSON.stringify(body)
+  });
+  let parsed = null;
+  try {
+    parsed = await res.json();
+  } catch {
+    parsed = null;
+  }
+  return { ok: res.ok, status: res.status, body: parsed };
+}
+
+// src/cron/cron-lock.ts
+import { closeSync as closeSync6, existsSync as existsSync27, openSync as openSync6, readFileSync as readFileSync11, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+var STALE_LOCK_MS = 10 * 6e4;
+function readLockInfo(lockPath) {
+  if (!existsSync27(lockPath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync11(lockPath, "utf8"));
+    if (typeof parsed.pid === "number" && typeof parsed.at === "string") return parsed;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function lockIsStale(lockPath) {
+  const info = readLockInfo(lockPath);
+  if (!info) return true;
+  if (!isPidAlive(info.pid)) return true;
+  const atMs = Date.parse(info.at);
+  if (Number.isNaN(atMs)) return true;
+  return Date.now() - atMs > STALE_LOCK_MS;
+}
+function tryAcquireCronTickLock(lockPath) {
+  if (existsSync27(lockPath) && !lockIsStale(lockPath)) {
+    const info = readLockInfo(lockPath);
+    return {
+      acquired: false,
+      reason: info ? `held by pid ${info.pid}` : "held by another process"
+    };
+  }
+  if (existsSync27(lockPath)) {
+    try {
+      unlinkSync2(lockPath);
+    } catch {
+    }
+  }
+  try {
+    const fd = openSync6(lockPath, "wx");
+    writeFileSync4(
+      fd,
+      JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() }),
+      "utf8"
+    );
+    closeSync6(fd);
+    return { acquired: true };
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      return { acquired: false, reason: "concurrent acquire" };
+    }
+    throw err;
+  }
+}
+function releaseCronTickLock(lockPath) {
+  try {
+    unlinkSync2(lockPath);
+  } catch {
+  }
+}
+
+// src/cron/cron-match.ts
+var CRON_RE = /^[\d*/,\-?LW#]+\s+[\d*/,\-?LW#]+\s+[\d*/,\-?LW#]+\s+[\d*/,\-?LW#]+\s+[\d*/,\-?LW#]+$/;
+function isCronExpression(value) {
+  return CRON_RE.test(value.trim());
+}
+function parseList(field, min, max) {
+  const out = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const token = part.trim();
+    if (!token) continue;
+    if (token === "*") {
+      for (let i = min; i <= max; i++) out.add(i);
+      continue;
+    }
+    const stepMatch = /^(.+)\/(\d+)$/.exec(token);
+    const base = stepMatch ? stepMatch[1] : token;
+    const step = stepMatch ? Math.max(1, Number(stepMatch[2])) : 1;
+    if (base === "*") {
+      for (let i = min; i <= max; i += step) out.add(i);
+      continue;
+    }
+    const rangeMatch = /^(\d+)-(\d+)$/.exec(base);
+    if (rangeMatch) {
+      const start = Math.max(min, Number(rangeMatch[1]));
+      const end = Math.min(max, Number(rangeMatch[2]));
+      for (let i = start; i <= end; i += step) out.add(i);
+      continue;
+    }
+    const n = Number(base);
+    if (Number.isInteger(n) && n >= min && n <= max) out.add(n);
+  }
+  return out;
+}
+function fieldMatches(field, value, min, max) {
+  const trimmed = field.trim();
+  if (trimmed === "*") return true;
+  return parseList(trimmed, min, max).has(value);
+}
+function cronMatchesUtc(expr, at) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) return false;
+  const [minF, hourF, domF, monF, dowF] = parts;
+  return fieldMatches(minF, at.getUTCMinutes(), 0, 59) && fieldMatches(hourF, at.getUTCHours(), 0, 23) && fieldMatches(domF, at.getUTCDate(), 1, 31) && fieldMatches(monF, at.getUTCMonth() + 1, 1, 12) && fieldMatches(dowF, at.getUTCDay(), 0, 6);
+}
+var MAX_LOOKAHEAD_MINUTES = 366 * 24 * 60;
+function truncateToUtcMinute(at) {
+  return new Date(
+    Date.UTC(
+      at.getUTCFullYear(),
+      at.getUTCMonth(),
+      at.getUTCDate(),
+      at.getUTCHours(),
+      at.getUTCMinutes(),
+      0,
+      0
+    )
+  );
+}
+function computeNextCronFireUtc(expr, after) {
+  if (!isCronExpression(expr)) return null;
+  let cursor = truncateToUtcMinute(after);
+  cursor = new Date(cursor.getTime() + 6e4);
+  for (let i = 0; i < MAX_LOOKAHEAD_MINUTES; i++) {
+    if (cronMatchesUtc(expr, cursor)) return cursor;
+    cursor = new Date(cursor.getTime() + 6e4);
+  }
+  return null;
+}
+function computeInitialNextFire(spec, now) {
+  if (spec.scheduleKind === "runAt" && spec.runAt) {
+    const ms = Date.parse(spec.runAt);
+    return Number.isNaN(ms) ? null : new Date(ms).toISOString();
+  }
+  if (spec.scheduleKind === "cron" && spec.cron) {
+    const next = computeNextCronFireUtc(spec.cron.trim(), now);
+    return next ? next.toISOString() : null;
+  }
+  return null;
+}
+function advanceRecurringNextFire(spec, fromInclusive) {
+  if (spec.scheduleKind !== "cron" || !spec.cron?.trim()) return null;
+  const next = computeNextCronFireUtc(spec.cron.trim(), fromInclusive);
+  return next ? next.toISOString() : null;
+}
+
+// src/cron/cron-store.ts
+import { promises as fs } from "node:fs";
+async function readFileIfExists(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function parseCronStore(raw) {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.entries) ? parsed.entries : [];
+  } catch {
+    return [];
+  }
+}
+async function loadCronJobs(storePath = defaultKynverCronStorePath()) {
+  const raw = await readFileIfExists(storePath);
+  return parseCronStore(raw);
+}
+
+// src/cron/cron-tick-state.ts
+import { randomBytes } from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import path36 from "node:path";
+var EMPTY = { version: 1, jobs: {} };
+async function readFileIfExists2(filePath) {
+  try {
+    return await fs2.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function parseCronTickState(raw) {
+  if (!raw) return { ...EMPTY, jobs: { ...EMPTY.jobs } };
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || typeof parsed.jobs !== "object" || !parsed.jobs) {
+      return { ...EMPTY, jobs: {} };
+    }
+    return parsed;
+  } catch {
+    return { ...EMPTY, jobs: {} };
+  }
+}
+async function loadCronTickState(statePath) {
+  const raw = await readFileIfExists2(statePath);
+  return parseCronTickState(raw);
+}
+async function writeStateAtomic(statePath, state) {
+  await fs2.mkdir(path36.dirname(statePath), { recursive: true });
+  const suffix = randomBytes(6).toString("hex");
+  const tmp = `${statePath}.tmp-${process.pid}-${Date.now()}-${suffix}`;
+  await fs2.writeFile(tmp, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  try {
+    await fs2.rename(tmp, statePath);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "EPERM" && code !== "EEXIST" && code !== "EACCES") throw err;
+    await fs2.unlink(tmp).catch(() => {
+    });
+  }
+}
+async function saveCronTickState(statePath, state) {
+  await writeStateAtomic(statePath, state);
+}
+function getOrCreateJobState(state, providerScheduleId) {
+  const existing = state.jobs[providerScheduleId];
+  if (existing) return existing;
+  const created = {
+    providerScheduleId,
+    nextFireAt: null,
+    lastFiredAt: null,
+    lastAttemptAt: null,
+    consecutiveFailures: 0,
+    completedAt: null,
+    inflightUntil: null
+  };
+  state.jobs[providerScheduleId] = created;
+  return created;
+}
+
+// src/cron/cron-tick.ts
+function isInflight(job, nowMs) {
+  if (!job.inflightUntil) return false;
+  const until = Date.parse(job.inflightUntil);
+  return !Number.isNaN(until) && until > nowMs;
+}
+function isCompleted(job) {
+  return Boolean(job.completedAt);
+}
+function backoffReady(job, env, nowMs) {
+  if (job.consecutiveFailures === 0) return true;
+  if (job.consecutiveFailures > env.maxRetries) return false;
+  if (!job.lastAttemptAt) return true;
+  const last = Date.parse(job.lastAttemptAt);
+  if (Number.isNaN(last)) return true;
+  return nowMs - last >= env.retryBackoffMs;
+}
+function ensureNextFire(entry, job, now) {
+  if (job.nextFireAt) return job.nextFireAt;
+  const initial = computeInitialNextFire(entry.spec, now);
+  job.nextFireAt = initial;
+  return initial;
+}
+function isDue(entry, job, nowMs, env) {
+  if (entry.paused || isCompleted(job) || isInflight(job, nowMs)) return false;
+  if (!backoffReady(job, env, nowMs)) return false;
+  const nextMs = job.nextFireAt ? Date.parse(job.nextFireAt) : NaN;
+  if (Number.isNaN(nextMs)) return false;
+  return nowMs >= nextMs;
+}
+function advanceRecurringBeforeFire(entry, job, now) {
+  if (entry.spec.scheduleKind !== "cron") return;
+  job.nextFireAt = advanceRecurringNextFire(entry.spec, now);
+}
+async function runKynverCronTick(opts = {}) {
+  const env = opts.env ?? resolveKynverCronEnv();
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  if (!env.tickEnabled) {
+    return { enabled: false, skipped: "tick_disabled", scanned: 0, due: 0, fired: 0, skippedJobs: 0, errors: 0 };
+  }
+  if (!env.fireBaseUrl || !env.secret) {
+    return {
+      enabled: true,
+      skipped: "missing_fire_credentials",
+      scanned: 0,
+      due: 0,
+      fired: 0,
+      skippedJobs: 0,
+      errors: 0
+    };
+  }
+  const lock = tryAcquireCronTickLock(env.lockPath);
+  if (!lock.acquired) {
+    return {
+      enabled: true,
+      skipped: lock.reason ?? "lock_not_acquired",
+      scanned: 0,
+      due: 0,
+      fired: 0,
+      skippedJobs: 0,
+      errors: 0,
+      lockHeld: true
+    };
+  }
+  try {
+    const entries = await loadCronJobs(env.storePath);
+    const filtered = opts.agentOsIdFilter ? entries.filter((e) => e.spec.target.agentOsId === opts.agentOsIdFilter) : entries;
+    const state = await loadCronTickState(env.statePath);
+    const dueEntries = [];
+    for (const entry of filtered) {
+      const job = getOrCreateJobState(state, entry.providerScheduleId);
+      ensureNextFire(entry, job, now);
+      if (isDue(entry, job, nowMs, env)) {
+        dueEntries.push({ entry, job });
+      }
+    }
+    dueEntries.sort((a, b) => {
+      const aMs = Date.parse(a.job.nextFireAt ?? "") || 0;
+      const bMs = Date.parse(b.job.nextFireAt ?? "") || 0;
+      return aMs - bMs;
+    });
+    let fired = 0;
+    let errors = 0;
+    let skippedJobs = 0;
+    let catchUpBudget = env.maxCatchUpPerTick;
+    for (const { entry, job } of dueEntries) {
+      if (env.missedRunPolicy === "skip" && entry.spec.scheduleKind === "cron") {
+        const next = Date.parse(job.nextFireAt ?? "");
+        if (!Number.isNaN(next) && next < nowMs - env.tickIntervalMs * 2) {
+          job.nextFireAt = advanceRecurringNextFire(entry.spec, now);
+          skippedJobs++;
+          continue;
+        }
+      }
+      if (catchUpBudget <= 0) {
+        skippedJobs++;
+        continue;
+      }
+      job.inflightUntil = new Date(nowMs + env.inflightLeaseMs).toISOString();
+      job.lastAttemptAt = now.toISOString();
+      advanceRecurringBeforeFire(entry, job, now);
+      try {
+        const result = await fireKynverCronJob({
+          entry,
+          baseUrl: env.fireBaseUrl,
+          secret: env.secret,
+          fetchFn: opts.fetchFn
+        });
+        job.inflightUntil = null;
+        if (result.ok) {
+          job.lastFiredAt = now.toISOString();
+          job.consecutiveFailures = 0;
+          if (entry.spec.scheduleKind === "runAt") {
+            job.completedAt = now.toISOString();
+            job.nextFireAt = null;
+          }
+          fired++;
+          catchUpBudget--;
+        } else {
+          job.consecutiveFailures += 1;
+          errors++;
+        }
+      } catch {
+        job.inflightUntil = null;
+        job.consecutiveFailures += 1;
+        errors++;
+      }
+    }
+    await saveCronTickState(env.statePath, state);
+    return {
+      enabled: true,
+      scanned: filtered.length,
+      due: dueEntries.length,
+      fired,
+      skippedJobs,
+      errors
+    };
+  } finally {
+    releaseCronTickLock(env.lockPath);
+  }
+}
+
 // src/pipeline-tick.ts
-import path49 from "node:path";
+import path52 from "node:path";
 
 // src/pipeline-dispatch.ts
 var RESERVED_REVIEW_STARTS = 1;
@@ -7074,30 +7740,67 @@ async function runPipelineDispatch(args, slots) {
   };
 }
 
+// src/pipeline-exact-targets.ts
+function operatorExactTargetTaskIds(operatorTick) {
+  if (!operatorTick || typeof operatorTick !== "object") return [];
+  const body = operatorTick;
+  const raw = body.response?.dispatch?.exactTargetTaskIds;
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of raw) {
+    if (typeof value !== "string") continue;
+    const id = value.trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+
 // src/pipeline-max-starts.ts
 function operatorDispatchFromTick(operatorTick) {
   const body = operatorTick;
   const dispatch = body.response?.dispatch;
   return dispatch && typeof dispatch === "object" ? dispatch : null;
 }
+function nonNegativeInt(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.max(0, Math.floor(value));
+}
 function resolvePipelineMaxStarts(resourceGate, operatorTick) {
   const dispatch = operatorDispatchFromTick(operatorTick);
-  const advised = typeof dispatch?.recommendedMaxStarts === "number" ? Math.max(0, dispatch.recommendedMaxStarts) : null;
+  const advised = nonNegativeInt(dispatch?.recommendedMaxStarts);
+  const actionableReady = nonNegativeInt(dispatch?.actionableReady);
+  const queuedTasks = nonNegativeInt(dispatch?.queuedTasks);
+  const boardAdvancedThisTick = nonNegativeInt(dispatch?.boardAdvancedThisTick) ?? 0;
+  const leaseReapedThisTick = nonNegativeInt(dispatch?.leaseReapedThisTick) ?? 0;
+  const hygieneAdvanced = boardAdvancedThisTick + leaseReapedThisTick;
+  const readyFloor = actionableReady ?? queuedTasks;
   let maxStarts = resourceGate.slotsAvailable;
-  if (advised !== null) {
+  if (readyFloor !== null) {
+    maxStarts = Math.min(maxStarts, readyFloor);
+  } else if (advised !== null) {
     maxStarts = Math.min(maxStarts, advised);
   }
-  const underutilized = dispatch?.underutilized === true;
-  const boardAdvancedThisTick = typeof dispatch?.boardAdvancedThisTick === "number" ? dispatch.boardAdvancedThisTick : 0;
-  if (underutilized && resourceGate.slotsAvailable > 0 && maxStarts === 0) {
-    const ready = dispatch?.actionableReady ?? dispatch?.queuedTasks ?? (boardAdvancedThisTick > 0 ? boardAdvancedThisTick : 1);
+  if (readyFloor === null && advised !== null) {
+    maxStarts = Math.max(maxStarts, Math.min(resourceGate.slotsAvailable, advised));
+  }
+  const underutilized = dispatch?.underutilized === true || (readyFloor ?? 0) > 0 && resourceGate.slotsAvailable > 0 && resourceGate.maxConcurrentWorkers > 0 && resourceGate.activeWorkers < resourceGate.maxConcurrentWorkers;
+  if (resourceGate.slotsAvailable > 0 && maxStarts === 0 && (underutilized || hygieneAdvanced > 0)) {
+    const ready = readyFloor ?? (hygieneAdvanced > 0 ? hygieneAdvanced : 1);
     maxStarts = Math.min(resourceGate.slotsAvailable, Math.max(1, ready));
   }
+  const nonDispatchableReady = queuedTasks !== null && actionableReady !== null ? Math.max(0, queuedTasks - actionableReady) : null;
   return {
     maxStarts: Math.max(0, maxStarts),
     underutilized,
     advisedStarts: advised,
-    boardAdvancedThisTick
+    actionableReady,
+    queuedTasks,
+    nonDispatchableReady,
+    boardAdvancedThisTick,
+    leaseReapedThisTick
   };
 }
 
@@ -7141,7 +7844,7 @@ function buildBoxResourceSnapshotFromGate(gate, input = {}) {
 }
 
 // src/plan-progress-daemon-sync.ts
-import path34 from "node:path";
+import path37 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -7165,7 +7868,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path34.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path37.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -7214,10 +7917,10 @@ async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
 }
 
 // src/cleanup.ts
-import path47 from "node:path";
+import path50 from "node:path";
 
 // src/cleanup-guards.ts
-import path35 from "node:path";
+import path38 from "node:path";
 
 // src/cleanup-run-liveness.ts
 function isWorkerProcessLive(indexed) {
@@ -7341,7 +8044,7 @@ function skipWorktreeRemoval(input) {
 function skipDependencyCacheRemoval(input) {
   const { indexed, nodeModulesAgeMs, ageMs, worktreePath, activeWorktreePaths, diskPressure } = input;
   if (!diskPressure && ageMs < nodeModulesAgeMs) return "below_age_threshold";
-  if (activeWorktreePaths.has(path35.resolve(worktreePath))) return "active_worker";
+  if (activeWorktreePaths.has(path38.resolve(worktreePath))) return "active_worker";
   if (indexed && isWorkerProcessLive(indexed)) return "active_worker";
   if (indexed && hasUnrestorableWorktreeChanges(indexed.status)) return "dirty_worktree";
   return null;
@@ -7368,11 +8071,11 @@ var LIVE_SKIP_REASONS = /* @__PURE__ */ new Set([
 function collectPreservedLivePaths(actions, skips) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const push = (path59, reason, detail) => {
-    const key = `${path59}\0${reason}`;
+  const push = (path62, reason, detail) => {
+    const key = `${path62}\0${reason}`;
     if (seen.has(key) || out.length >= MAX_PRESERVED_LIVE_PATH_SAMPLES) return;
     seen.add(key);
-    out.push({ path: path59, reason, ...detail ? { detail } : {} });
+    out.push({ path: path62, reason, ...detail ? { detail } : {} });
   };
   for (const skip2 of skips) {
     if (!LIVE_SKIP_REASONS.has(skip2.reason)) continue;
@@ -7387,11 +8090,11 @@ function collectPreservedLivePaths(actions, skips) {
 }
 
 // src/cleanup-run-directory.ts
-import { existsSync as existsSync25, readdirSync as readdirSync6, statSync as statSync4 } from "node:fs";
-import path37 from "node:path";
+import { existsSync as existsSync28, readdirSync as readdirSync7, statSync as statSync5 } from "node:fs";
+import path40 from "node:path";
 
 // src/cleanup-active-worktrees.ts
-import path36 from "node:path";
+import path39 from "node:path";
 function isActiveHarnessWorker2(worker, runBase, runBaseCommit) {
   const status = computeWorkerStatus(worker, { base: runBase, baseCommit: runBaseCommit });
   return status.alive && !status.finalResult && status.attention.state !== "done";
@@ -7404,17 +8107,20 @@ function collectActiveWorktreeGuards(harnessRoots) {
       let runHasLive = false;
       for (const name of Object.keys(run.workers || {})) {
         const worker = readJson(
-          path36.join(runDirectoryAt(harnessRoot, run.id), "workers", safeSlug(name), "worker.json"),
+          path39.join(runDirectoryAt(harnessRoot, run.id), "workers", safeSlug(name), "worker.json"),
           void 0
         );
         if (!worker?.worktreePath) continue;
-        const worktreePath = path36.resolve(worker.worktreePath);
+        const worktreePath = path39.resolve(worker.worktreePath);
         if (!isActiveHarnessWorker2(worker, run.base, run.baseCommit)) continue;
         runHasLive = true;
         activeWorktreePaths.add(worktreePath);
       }
       if (runHasLive) liveRunKeys.add(`${harnessRoot}\0${run.id}`);
     }
+    for (const key of collectFilesystemLiveRunKeys(harnessRoot)) {
+      liveRunKeys.add(key);
+    }
   }
   return { activeWorktreePaths, liveRunKeys };
 }
@@ -7426,20 +8132,20 @@ function isWorktreeOnLiveRun(worktreePath, harnessRoot, runId, liveRunKeys) {
 // src/cleanup-run-directory.ts
 function pathAgeMs(target, now) {
   try {
-    const mtime = statSync4(target).mtimeMs;
+    const mtime = statSync5(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
   }
 }
 function loadRunStatus(harnessRoot, runId) {
-  const runPath = path37.join(harnessRoot, "runs", runId, "run.json");
-  if (!existsSync25(runPath)) return null;
+  const runPath = path40.join(harnessRoot, "runs", runId, "run.json");
+  if (!existsSync28(runPath)) return null;
   return readJson(runPath, null);
 }
 function runDirectoryIsEmpty(runPath) {
   try {
-    const entries = readdirSync6(runPath);
+    const entries = readdirSync7(runPath);
     return entries.length === 0;
   } catch {
     return false;
@@ -7457,11 +8163,11 @@ function skipRunDirectoryRemoval(input) {
   return null;
 }
 function scanStaleRunDirectoryCandidates(opts) {
-  if (!existsSync25(opts.worktreesDir)) return [];
+  if (!existsSync28(opts.worktreesDir)) return [];
   const candidates = [];
   let entries;
   try {
-    entries = readdirSync6(opts.worktreesDir, { withFileTypes: true });
+    entries = readdirSync7(opts.worktreesDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -7469,7 +8175,7 @@ function scanStaleRunDirectoryCandidates(opts) {
     if (!runEntry.isDirectory()) continue;
     const runId = runEntry.name;
     if (opts.runIdFilter && runId !== opts.runIdFilter) continue;
-    const runPath = path37.join(opts.worktreesDir, runId);
+    const runPath = path40.join(opts.worktreesDir, runId);
     if (!runDirectoryIsEmpty(runPath)) continue;
     candidates.push({
       kind: "remove_run_directory",
@@ -7484,14 +8190,14 @@ function scanStaleRunDirectoryCandidates(opts) {
 }
 
 // src/cleanup-execute.ts
-import { existsSync as existsSync27, rmSync as rmSync3 } from "node:fs";
-import path39 from "node:path";
+import { existsSync as existsSync30, rmSync as rmSync3 } from "node:fs";
+import path42 from "node:path";
 
 // src/cleanup-dir-size.ts
-import { existsSync as existsSync26, readdirSync as readdirSync7, statSync as statSync5 } from "node:fs";
-import path38 from "node:path";
+import { existsSync as existsSync29, readdirSync as readdirSync8, statSync as statSync6 } from "node:fs";
+import path41 from "node:path";
 function directorySizeBytes(root, maxEntries = 5e4) {
-  if (!existsSync26(root)) return 0;
+  if (!existsSync29(root)) return 0;
   let total = 0;
   let seen = 0;
   const stack = [root];
@@ -7499,16 +8205,16 @@ function directorySizeBytes(root, maxEntries = 5e4) {
     const current = stack.pop();
     let entries;
     try {
-      entries = readdirSync7(current);
+      entries = readdirSync8(current);
     } catch {
       continue;
     }
     for (const name of entries) {
       if (seen++ > maxEntries) return null;
-      const full = path38.join(current, name);
+      const full = path41.join(current, name);
       let st;
       try {
-        st = statSync5(full);
+        st = statSync6(full);
       } catch {
         continue;
       }
@@ -7520,8 +8226,20 @@ function directorySizeBytes(root, maxEntries = 5e4) {
 }
 
 // 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) {
-  if (!existsSync27(candidate.path)) {
+  const metadataSkip = skipRunMetadataRemoval(candidate);
+  if (metadataSkip) return metadataSkip;
+  if (!existsSync30(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -7561,7 +8279,9 @@ function removeBuildCache(candidate, execute) {
   return removeDependencyCache(candidate, execute);
 }
 function removeRunDirectory(candidate, execute) {
-  if (!existsSync27(candidate.path)) {
+  const metadataSkip = skipRunMetadataRemoval(candidate);
+  if (metadataSkip) return metadataSkip;
+  if (!existsSync30(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -7592,7 +8312,9 @@ function removeRunDirectory(candidate, execute) {
   }
 }
 function removeWorktree(candidate, execute) {
-  if (!existsSync27(candidate.path)) {
+  const metadataSkip = skipRunMetadataRemoval(candidate);
+  if (metadataSkip) return metadataSkip;
+  if (!existsSync30(candidate.path)) {
     return {
       ...candidate,
       executed: false,
@@ -7609,7 +8331,7 @@ function removeWorktree(candidate, execute) {
     if (repo) {
       git(repo, ["worktree", "remove", "--force", candidate.path], { allowFailure: true });
     }
-    if (existsSync27(candidate.path)) {
+    if (existsSync30(candidate.path)) {
       rmSync3(candidate.path, { recursive: true, force: true });
     }
     return {
@@ -7629,15 +8351,15 @@ function removeWorktree(candidate, execute) {
   }
 }
 function isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, cacheDirName) {
-  const resolved = path39.resolve(targetPath);
-  const suffix = `${path39.sep}${cacheDirName}`;
+  const resolved = path42.resolve(targetPath);
+  const suffix = `${path42.sep}${cacheDirName}`;
   const cachePath = resolved.endsWith(suffix) ? resolved : null;
   if (!cachePath) return "path_outside_harness";
-  const rel = path39.relative(worktreesDir, cachePath);
-  if (rel.startsWith("..") || path39.isAbsolute(rel)) return "path_outside_harness";
-  const parts = rel.split(path39.sep);
+  const rel = path42.relative(worktreesDir, cachePath);
+  if (rel.startsWith("..") || path42.isAbsolute(rel)) return "path_outside_harness";
+  const parts = rel.split(path42.sep);
   if (parts.length < 3 || parts[parts.length - 1] !== cacheDirName) return "path_outside_harness";
-  if (!resolved.startsWith(path39.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path42.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 function isHarnessNodeModulesPath(targetPath, harnessRoot, worktreesDir) {
@@ -7647,37 +8369,37 @@ function isHarnessNextCachePath(targetPath, harnessRoot, worktreesDir) {
   return isHarnessDependencyCachePath(targetPath, harnessRoot, worktreesDir, ".next");
 }
 function isHarnessBuildCachePath(targetPath, harnessRoot, worktreesDir) {
-  const resolved = path39.resolve(targetPath);
-  const relToWt = path39.relative(worktreesDir, resolved);
-  if (relToWt.startsWith("..") || path39.isAbsolute(relToWt)) return "path_outside_harness";
-  const parts = relToWt.split(path39.sep);
+  const resolved = path42.resolve(targetPath);
+  const relToWt = path42.relative(worktreesDir, resolved);
+  if (relToWt.startsWith("..") || path42.isAbsolute(relToWt)) return "path_outside_harness";
+  const parts = relToWt.split(path42.sep);
   if (parts.length < 3) return "path_outside_harness";
-  if (!resolved.startsWith(path39.resolve(harnessRoot))) return "path_outside_harness";
+  if (!resolved.startsWith(path42.resolve(harnessRoot))) return "path_outside_harness";
   return null;
 }
 
 // src/cleanup-scan.ts
-import { existsSync as existsSync28, readdirSync as readdirSync8, statSync as statSync6 } from "node:fs";
-import path40 from "node:path";
+import { existsSync as existsSync31, readdirSync as readdirSync9, statSync as statSync7 } from "node:fs";
+import path43 from "node:path";
 function pathAgeMs2(target, now) {
   try {
-    const mtime = statSync6(target).mtimeMs;
+    const mtime = statSync7(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
   }
 }
 function isPathInside(child, parent) {
-  const rel = path40.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path40.isAbsolute(rel);
+  const rel = path43.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path43.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 = path40.join(worktreePath, rel);
-    if (!existsSync28(target)) continue;
-    const resolved = path40.resolve(target);
+    const target = path43.join(worktreePath, rel);
+    if (!existsSync31(target)) continue;
+    const resolved = path43.resolve(target);
     if (seen.has(resolved)) continue;
     if (!isPathInside(resolved, opts.harnessRoot)) continue;
     seen.add(resolved);
@@ -7706,13 +8428,13 @@ function scanBuildCacheCandidates(opts) {
       })
     );
   }
-  if (!opts.includeOrphans || !existsSync28(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync8(opts.worktreesDir, { withFileTypes: true })) {
+  if (!opts.includeOrphans || !existsSync31(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync9(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
-    const runPath = path40.join(opts.worktreesDir, runEntry.name);
-    for (const workerEntry of readdirSync8(runPath, { withFileTypes: true })) {
+    const runPath = path43.join(opts.worktreesDir, runEntry.name);
+    for (const workerEntry of readdirSync9(runPath, { withFileTypes: true })) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path40.join(runPath, workerEntry.name);
+      const worktreePath = path43.join(runPath, workerEntry.name);
       candidates.push(
         ...collectBuildCacheForWorktree(worktreePath, opts, seen, {
           runId: runEntry.name,
@@ -7733,7 +8455,7 @@ function scanWorktreeCandidates(opts) {
     for (const entry of opts.index.values()) {
       if (opts.runIdFilter && entry.runId !== opts.runIdFilter) continue;
       const resolved = entry.worktreePath;
-      if (!existsSync28(resolved)) continue;
+      if (!existsSync31(resolved)) continue;
       if (seen.has(resolved)) continue;
       seen.add(resolved);
       candidates.push({
@@ -7747,24 +8469,24 @@ function scanWorktreeCandidates(opts) {
       });
     }
   }
-  if (!orphanEnabled || !existsSync28(opts.worktreesDir)) return candidates;
+  if (!orphanEnabled || !existsSync31(opts.worktreesDir)) return candidates;
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path40.resolve(entry.worktreePath));
+    indexedPaths.add(path43.resolve(entry.worktreePath));
   }
-  for (const runEntry of readdirSync8(opts.worktreesDir, { withFileTypes: true })) {
+  for (const runEntry of readdirSync9(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path40.join(opts.worktreesDir, runEntry.name);
+    const runPath = path43.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
-      workerEntries = readdirSync8(runPath, { withFileTypes: true });
+      workerEntries = readdirSync9(runPath, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path40.resolve(path40.join(runPath, workerEntry.name));
+      const worktreePath = path43.resolve(path43.join(runPath, workerEntry.name));
       if (seen.has(worktreePath)) continue;
       if (indexedPaths.has(worktreePath)) continue;
       if (!isPathInside(worktreePath, opts.harnessRoot)) continue;
@@ -7783,27 +8505,27 @@ function scanWorktreeCandidates(opts) {
 }
 
 // src/cleanup-dependency-scan.ts
-import { existsSync as existsSync29, readdirSync as readdirSync9, statSync as statSync7 } from "node:fs";
-import path41 from "node:path";
+import { existsSync as existsSync32, readdirSync as readdirSync10, statSync as statSync8 } from "node:fs";
+import path44 from "node:path";
 var DEPENDENCY_CACHE_DIRS = [
   { dirName: "node_modules", kind: "remove_node_modules" },
   { dirName: ".next", kind: "remove_next_cache" }
 ];
 function pathAgeMs3(target, now) {
   try {
-    const mtime = statSync7(target).mtimeMs;
+    const mtime = statSync8(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
   }
 }
 function isPathInside2(child, parent) {
-  const rel = path41.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path41.isAbsolute(rel);
+  const rel = path44.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path44.isAbsolute(rel);
 }
 function pushCandidate2(candidates, seen, opts, targetPath, kind, meta) {
-  if (!existsSync29(targetPath)) return;
-  const resolved = path41.resolve(targetPath);
+  if (!existsSync32(targetPath)) return;
+  const resolved = path44.resolve(targetPath);
   if (seen.has(resolved)) return;
   if (!isPathInside2(resolved, opts.harnessRoot)) return;
   seen.add(resolved);
@@ -7820,7 +8542,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, path41.join(worktreePath, entry.dirName), entry.kind, meta);
+    pushCandidate2(candidates, seen, opts, path44.join(worktreePath, entry.dirName), entry.kind, meta);
   }
 }
 function scanDependencyCacheCandidates(opts) {
@@ -7834,20 +8556,20 @@ function scanDependencyCacheCandidates(opts) {
       repo: entry.run.repo
     });
   }
-  if (!existsSync29(opts.worktreesDir)) return candidates;
-  for (const runEntry of readdirSync9(opts.worktreesDir, { withFileTypes: true })) {
+  if (!existsSync32(opts.worktreesDir)) return candidates;
+  for (const runEntry of readdirSync10(opts.worktreesDir, { withFileTypes: true })) {
     if (!runEntry.isDirectory()) continue;
     if (opts.runIdFilter && runEntry.name !== opts.runIdFilter) continue;
-    const runPath = path41.join(opts.worktreesDir, runEntry.name);
+    const runPath = path44.join(opts.worktreesDir, runEntry.name);
     let workerEntries;
     try {
-      workerEntries = readdirSync9(runPath, { withFileTypes: true });
+      workerEntries = readdirSync10(runPath, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const workerEntry of workerEntries) {
       if (!workerEntry.isDirectory()) continue;
-      const worktreePath = path41.join(runPath, workerEntry.name);
+      const worktreePath = path44.join(runPath, workerEntry.name);
       scanWorktreeDependencyCaches(candidates, seen, opts, worktreePath, {
         runId: runEntry.name,
         worker: workerEntry.name
@@ -7858,11 +8580,11 @@ function scanDependencyCacheCandidates(opts) {
 }
 
 // src/cleanup-duplicate-worktrees.ts
-import { existsSync as existsSync30, statSync as statSync8 } from "node:fs";
-import path42 from "node:path";
+import { existsSync as existsSync33, statSync as statSync9 } from "node:fs";
+import path45 from "node:path";
 function pathAgeMs4(target, now) {
   try {
-    const mtime = statSync8(target).mtimeMs;
+    const mtime = statSync9(target).mtimeMs;
     return Math.max(0, now - mtime);
   } catch {
     return 0;
@@ -7889,8 +8611,8 @@ function parseWorktreePorcelain(output) {
   return records;
 }
 function isUnderWorktreesDir(worktreePath, worktreesDir) {
-  const rel = path42.relative(path42.resolve(worktreesDir), path42.resolve(worktreePath));
-  return rel !== "" && !rel.startsWith("..") && !path42.isAbsolute(rel);
+  const rel = path45.relative(path45.resolve(worktreesDir), path45.resolve(worktreePath));
+  return rel !== "" && !rel.startsWith("..") && !path45.isAbsolute(rel);
 }
 function isCleanWorktree(worktreePath, repoRoot) {
   try {
@@ -7903,14 +8625,14 @@ function isCleanWorktree(worktreePath, repoRoot) {
   }
 }
 function scanDuplicateWorktreeCandidates(opts) {
-  if (!opts.includeOrphans || !existsSync30(opts.worktreesDir)) return [];
+  if (!opts.includeOrphans || !existsSync33(opts.worktreesDir)) return [];
   const repos = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    if (entry.run.repo) repos.add(path42.resolve(entry.run.repo));
+    if (entry.run.repo) repos.add(path45.resolve(entry.run.repo));
   }
   const indexedPaths = /* @__PURE__ */ new Set();
   for (const entry of opts.index.values()) {
-    indexedPaths.add(path42.resolve(entry.worktreePath));
+    indexedPaths.add(path45.resolve(entry.worktreePath));
   }
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -7923,15 +8645,15 @@ function scanDuplicateWorktreeCandidates(opts) {
     }
     const worktrees = parseWorktreePorcelain(porcelain);
     for (const wt of worktrees) {
-      const resolved = path42.resolve(wt.path);
-      if (resolved === path42.resolve(repoRoot)) continue;
+      const resolved = path45.resolve(wt.path);
+      if (resolved === path45.resolve(repoRoot)) continue;
       if (!isUnderWorktreesDir(resolved, opts.worktreesDir)) continue;
       if (indexedPaths.has(resolved)) continue;
       if (seen.has(resolved)) continue;
-      if (!existsSync30(resolved)) continue;
+      if (!existsSync33(resolved)) continue;
       if (!isCleanWorktree(resolved, repoRoot)) continue;
-      const rel = path42.relative(opts.worktreesDir, resolved);
-      const parts = rel.split(path42.sep);
+      const rel = path45.relative(opts.worktreesDir, resolved);
+      const parts = rel.split(path45.sep);
       const runId = parts[0];
       const worker = parts[1] ?? "unknown";
       seen.add(resolved);
@@ -7950,12 +8672,12 @@ function scanDuplicateWorktreeCandidates(opts) {
 }
 
 // src/cleanup-worktree-index.ts
-import path43 from "node:path";
+import path46 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 = path43.join(
+      const workerPath = path46.join(
         runDirectoryAt(harnessRoot, run.id),
         "workers",
         safeSlug(name),
@@ -7964,9 +8686,9 @@ function buildWorktreeIndexAt(harnessRoot) {
       const worker = readJson(workerPath, void 0);
       if (!worker?.worktreePath) continue;
       const status = computeWorkerStatus(worker, { base: run.base, baseCommit: run.baseCommit });
-      index.set(path43.resolve(worker.worktreePath), {
+      index.set(path46.resolve(worker.worktreePath), {
         harnessRoot,
-        worktreePath: path43.resolve(worker.worktreePath),
+        worktreePath: path46.resolve(worker.worktreePath),
         runId: run.id,
         workerName: name,
         run,
@@ -7979,7 +8701,7 @@ function buildWorktreeIndexAt(harnessRoot) {
 }
 
 // src/cleanup-retention-config.ts
-function envFlag(name) {
+function envFlag2(name) {
   const v = process.env[name];
   return v === "1" || v === "true" || v === "yes";
 }
@@ -7990,17 +8712,17 @@ function envMs(name, fallback) {
   return Number.isFinite(n) && n >= 0 ? n : fallback;
 }
 function resolveHarnessRetention(options = {}) {
-  const execute = options.execute === true || options.execute !== false && envFlag("KYNVER_CLEANUP_EXECUTE");
-  const finalizeStaleRuns2 = options.finalizeStaleRuns !== false && !envFlag("KYNVER_CLEANUP_SKIP_FINALIZE");
+  const execute = options.execute === true || options.execute !== false && envFlag2("KYNVER_CLEANUP_EXECUTE");
+  const finalizeStaleRuns2 = options.finalizeStaleRuns !== false && !envFlag2("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 || envFlag("KYNVER_CLEANUP_INCLUDE_ORPHANS");
-  const scopeAll = envFlag("KYNVER_CLEANUP_SCOPE_ALL") || process.env.KYNVER_CLEANUP_SCOPE === "all";
+  const includeOrphans = options.includeOrphans === true || envFlag2("KYNVER_CLEANUP_INCLUDE_ORPHANS");
+  const scopeAll = envFlag2("KYNVER_CLEANUP_SCOPE_ALL") || process.env.KYNVER_CLEANUP_SCOPE === "all";
   const runIdFilter = scopeAll ? options.runIdFilter : options.runIdFilter ?? (process.env.KYNVER_CLEANUP_RUN_ID || void 0);
-  const accountBytes = options.accountBytes !== false && !envFlag("KYNVER_CLEANUP_SKIP_BYTE_ACCOUNTING");
+  const accountBytes = options.accountBytes !== false && !envFlag2("KYNVER_CLEANUP_SKIP_BYTE_ACCOUNTING");
   return {
     execute,
     finalizeStaleRuns: finalizeStaleRuns2,
@@ -8030,15 +8752,15 @@ function resolvePipelineHarnessRetention(runId) {
 }
 
 // src/cleanup-orphan-safety.ts
-import { existsSync as existsSync31, statSync as statSync9 } from "node:fs";
-import path44 from "node:path";
+import { existsSync as existsSync34, statSync as statSync10 } from "node:fs";
+import path47 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 (!existsSync31(input.worktreePath)) return null;
+  if (!existsSync34(input.worktreePath)) return null;
   if (input.runId && input.workerName) {
-    const heartbeatPath = path44.join(
+    const heartbeatPath = path47.join(
       input.harnessRoot,
       "runs",
       input.runId,
@@ -8047,13 +8769,13 @@ function assessOrphanWorktreeSafety(input) {
       "heartbeat.jsonl"
     );
     try {
-      const mtime = statSync9(heartbeatPath).mtimeMs;
+      const mtime = statSync10(heartbeatPath).mtimeMs;
       if (now - mtime < heartbeatFreshMs) return "active_worker";
     } catch {
     }
   }
-  const gitDir = path44.join(input.worktreePath, ".git");
-  if (!existsSync31(gitDir)) return null;
+  const gitDir = path47.join(input.worktreePath, ".git");
+  if (!existsSync34(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);
@@ -8082,14 +8804,14 @@ function assessOrphanWorktreeSafety(input) {
 }
 
 // src/harness-storage-snapshot.ts
-import { existsSync as existsSync32, readdirSync as readdirSync10, statSync as statSync10 } from "node:fs";
-import path45 from "node:path";
+import { existsSync as existsSync35, readdirSync as readdirSync11, statSync as statSync11 } from "node:fs";
+import path48 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 (!existsSync32(worktreesDir)) {
+  if (!existsSync35(worktreesDir)) {
     return {
       harnessRoot,
       worktreesDir,
@@ -8106,7 +8828,7 @@ function harnessStorageSnapshot(opts = {}) {
   let oldestMs = null;
   let entries;
   try {
-    entries = readdirSync10(worktreesDir, { withFileTypes: true });
+    entries = readdirSync11(worktreesDir, { withFileTypes: true });
   } catch {
     return {
       harnessRoot,
@@ -8121,14 +8843,14 @@ function harnessStorageSnapshot(opts = {}) {
   for (const runEntry of entries) {
     if (!runEntry.isDirectory()) continue;
     runCount += 1;
-    const runPath = path45.join(worktreesDir, runEntry.name);
+    const runPath = path48.join(worktreesDir, runEntry.name);
     try {
-      const st = statSync10(runPath);
+      const st = statSync11(runPath);
       oldestMs = oldestMs === null ? st.mtimeMs : Math.min(oldestMs, st.mtimeMs);
     } catch {
     }
     try {
-      for (const workerEntry of readdirSync10(runPath, { withFileTypes: true })) {
+      for (const workerEntry of readdirSync11(runPath, { withFileTypes: true })) {
         if (workerEntry.isDirectory()) workerCount += 1;
       }
     } catch {
@@ -8156,12 +8878,12 @@ function harnessStorageSnapshot(opts = {}) {
 }
 
 // src/cleanup-harness-roots.ts
-import { existsSync as existsSync33 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import path46 from "node:path";
+import { existsSync as existsSync36 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import path49 from "node:path";
 var WELL_KNOWN_HARNESS_SCAN_ROOTS = [
   "/var/tmp/kynver-harness",
-  path46.join(homedir11(), ".openclaw", "harness")
+  path49.join(homedir12(), ".openclaw", "harness")
 ];
 function addRoot(seen, roots, candidate) {
   if (!candidate?.trim()) return;
@@ -8183,15 +8905,15 @@ 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 = path46.resolve(candidate);
-      if (!seen.has(resolved) && existsSync33(resolved)) addRoot(seen, roots, resolved);
+      const resolved = path49.resolve(candidate);
+      if (!seen.has(resolved) && existsSync36(resolved)) addRoot(seen, roots, resolved);
     }
   }
   return roots;
 }
 
 // src/cleanup-disk-pressure.ts
-function envFlag2(name) {
+function envFlag3(name) {
   const v = process.env[name];
   return v === "1" || v === "true" || v === "yes";
 }
@@ -8214,7 +8936,7 @@ function observeCleanupDiskPressure(input = {}) {
 }
 function applyDiskPressureToRetention(retention, pressure) {
   if (!pressure.pressured) return retention;
-  const executeOnPressure = retention.execute || envFlag2("KYNVER_CLEANUP_EXECUTE_ON_PRESSURE");
+  const executeOnPressure = retention.execute || envFlag3("KYNVER_CLEANUP_EXECUTE_ON_PRESSURE");
   return {
     ...retention,
     execute: executeOnPressure,
@@ -8273,9 +8995,9 @@ function mergeWorktreeIndexes(scanRoots) {
 }
 function worktreePathForCandidate(candidate, worktreesDir) {
   if (candidate.runId && candidate.worker) {
-    return path47.join(worktreesDir, candidate.runId, candidate.worker);
+    return path50.join(worktreesDir, candidate.runId, candidate.worker);
   }
-  return path47.resolve(candidate.path, "..");
+  return path50.resolve(candidate.path, "..");
 }
 function runHarnessCleanup(options = {}) {
   let retention = resolveHarnessRetention(options);
@@ -8292,7 +9014,7 @@ function runHarnessCleanup(options = {}) {
   const atSweepCap = () => actions.length >= maxActions;
   for (const harnessRoot of paths.scanRoots) {
     if (atSweepCap()) break;
-    const worktreesDir = path47.join(harnessRoot, "worktrees");
+    const worktreesDir = path50.join(harnessRoot, "worktrees");
     const scanOpts = {
       harnessRoot,
       worktreesDir,
@@ -8306,7 +9028,7 @@ function runHarnessCleanup(options = {}) {
     for (const raw of scanDependencyCacheCandidates(scanOpts)) {
       if (atSweepCap()) break;
       const candidate = attachCandidateBytes(raw, retention.accountBytes);
-      const resolved = path47.resolve(candidate.path);
+      const resolved = path50.resolve(candidate.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const pathSkip = pathGuardForDependencyCache(candidate, harnessRoot, worktreesDir);
@@ -8316,7 +9038,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path47.resolve(worktreePath)) ?? null;
+      const indexed = index.get(path50.resolve(worktreePath)) ?? null;
       const guardReason = skipDependencyCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -8336,7 +9058,7 @@ function runHarnessCleanup(options = {}) {
     for (const raw of scanBuildCacheCandidates(scanOpts)) {
       if (atSweepCap()) break;
       const candidate = attachCandidateBytes(raw, retention.accountBytes);
-      const resolved = path47.resolve(candidate.path);
+      const resolved = path50.resolve(candidate.path);
       if (processedPaths.has(resolved)) continue;
       processedPaths.add(resolved);
       const pathSkip = isHarnessBuildCachePath(candidate.path, harnessRoot, worktreesDir);
@@ -8346,7 +9068,7 @@ function runHarnessCleanup(options = {}) {
         continue;
       }
       const worktreePath = worktreePathForCandidate(candidate, worktreesDir);
-      const indexed = index.get(path47.resolve(worktreePath)) ?? null;
+      const indexed = index.get(path50.resolve(worktreePath)) ?? null;
       const guardReason = skipBuildCacheRemoval({
         indexed,
         includeOrphans: true,
@@ -8370,11 +9092,11 @@ function runHarnessCleanup(options = {}) {
     const worktreeSeen = /* @__PURE__ */ new Set();
     for (const raw of worktreeCandidates) {
       if (atSweepCap()) break;
-      const resolved = path47.resolve(raw.path);
+      const resolved = path50.resolve(raw.path);
       if (worktreeSeen.has(resolved)) continue;
       worktreeSeen.add(resolved);
       const candidate = attachCandidateBytes({ ...raw, path: resolved }, retention.accountBytes);
-      const indexed = index.get(path47.resolve(candidate.path)) ?? null;
+      const indexed = index.get(path50.resolve(candidate.path)) ?? null;
       const orphanSafety = indexed ? null : assessOrphanWorktreeSafety({
         worktreePath: candidate.path,
         harnessRoot,
@@ -8384,7 +9106,7 @@ function runHarnessCleanup(options = {}) {
       });
       const guardSkip = skipWorktreeRemoval({
         indexed,
-        worktreePath: path47.resolve(candidate.path),
+        worktreePath: path50.resolve(candidate.path),
         includeOrphans: retention.includeOrphans,
         worktreesAgeMs: retention.worktreesAgeMs,
         terminalWorktreesAgeMs: retention.terminalWorktreesAgeMs,
@@ -8411,10 +9133,10 @@ function runHarnessCleanup(options = {}) {
       })) {
         if (atSweepCap()) break;
         const candidate = attachCandidateBytes(raw, retention.accountBytes);
-        const resolved = path47.resolve(candidate.path);
+        const resolved = path50.resolve(candidate.path);
         if (processedPaths.has(resolved)) continue;
         processedPaths.add(resolved);
-        const runId = candidate.runId ?? path47.basename(resolved);
+        const runId = candidate.runId ?? path50.basename(resolved);
         const dirSkip = skipRunDirectoryRemoval({
           harnessRoot,
           runId,
@@ -8503,8 +9225,8 @@ function isPipelineCleanupEnabled() {
 
 // src/installed-package-versions.ts
 import { readFile } from "node:fs/promises";
-import { homedir as homedir12 } from "node:os";
-import path48 from "node:path";
+import { homedir as homedir13 } from "node:os";
+import path51 from "node:path";
 var MANAGED_PACKAGES = [
   "@kynver-app/runtime",
   "@kynver-app/openclaw-agent-os",
@@ -8518,13 +9240,13 @@ function unique(values) {
   return [...new Set(values.filter((value) => Boolean(value)))];
 }
 function moduleRoots() {
-  const home = homedir12();
-  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path48.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) ? path48.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path48.join(home, ".npm-global", "lib", "node_modules"));
+  const home = homedir13();
+  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path51.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) ? path51.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path51.join(home, ".npm-global", "lib", "node_modules"));
   return unique([
-    path48.join(openClawPrefix, "lib", "node_modules"),
-    path48.join(openClawPrefix, "node_modules"),
-    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path48.join(npmGlobalRoot, "lib", "node_modules")
+    path51.join(openClawPrefix, "lib", "node_modules"),
+    path51.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path51.join(npmGlobalRoot, "lib", "node_modules")
   ]);
 }
 async function readVersion(packageJsonPath) {
@@ -8540,7 +9262,7 @@ async function collectInstalledPackageVersions(observedAt = (/* @__PURE__ */ new
   const out = {};
   for (const packageName of MANAGED_PACKAGES) {
     for (const root of roots) {
-      const packageJsonPath = path48.join(root, packageName, "package.json");
+      const packageJsonPath = path51.join(root, packageName, "package.json");
       const version = await readVersion(packageJsonPath);
       if (!version) continue;
       out[packageName] = { version, observedAt, path: packageJsonPath };
@@ -8556,11 +9278,11 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path49.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path52.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
-    if (hasCompletionAck(worker)) {
+    if (hasTerminalCompletionAck(worker)) {
       outcomes.push({ worker: name, ok: true, taskId: worker.taskId ?? null, skipped: true });
       continue;
     }
@@ -8629,24 +9351,51 @@ async function runPipelineTick(args) {
   let maxStarts = maxStartsAdvice.maxStarts;
   const sweep = await sweepRun({ run: runId, agentOsId, pipeline: true, ...args });
   let dispatch = null;
-  if (execute && maxStarts > 0) {
-    dispatch = await runPipelineDispatch(
+  let startedCount = 0;
+  const exactTargetTaskIds = operatorExactTargetTaskIds(operatorTick);
+  let remainingStarts = maxStarts;
+  if (execute && remainingStarts > 0 && exactTargetTaskIds.length > 0) {
+    const exactBudget = Math.min(remainingStarts, exactTargetTaskIds.length);
+    const exact = await runPipelineDispatch(
+      {
+        ...args,
+        run: runId,
+        agentOsId,
+        targetTaskIds: exactTargetTaskIds.join(",")
+      },
+      exactBudget
+    );
+    const exactStarted = countDispatchStarts(exact);
+    startedCount += exactStarted;
+    remainingStarts = Math.max(0, remainingStarts - exactStarted);
+    dispatch = { exactTargetTaskIds, exact, startedCount };
+  }
+  if (execute && remainingStarts > 0) {
+    const broad = await runPipelineDispatch(
       {
         ...args,
         run: runId,
         agentOsId
       },
-      maxStarts
+      remainingStarts
     );
-  } else {
-    dispatch = {
-      ok: true,
-      skipped: true,
-      reason: execute ? dispatchResourceGate.reason ?? "no slots or queued work" : "execute disabled",
-      maxStarts: 0
-    };
+    const broadStarted = countDispatchStarts(broad);
+    startedCount += broadStarted;
+    dispatch = dispatch && typeof dispatch === "object" ? { ...dispatch, broad, startedCount } : broad;
+  } else if (!execute || maxStarts <= 0) {
+    if (!dispatch) {
+      dispatch = {
+        ok: true,
+        skipped: true,
+        reason: execute ? dispatchResourceGate.reason ?? "no slots or queued work" : "execute disabled",
+        maxStarts: 0,
+        dispatchAdvice: maxStartsAdvice,
+        ...exactTargetTaskIds.length ? { exactTargetTaskIds, exactOnly: true } : {}
+      };
+    }
+  } else if (dispatch && typeof dispatch === "object") {
+    dispatch = { ...dispatch, broadSkipped: true, startedCount };
   }
-  const startedCount = dispatch?.startedCount ?? 0;
   const idle = !maxStartsAdvice.underutilized && maxStarts === 0 && completedWorkers.length === 0 && startedCount === 0;
   return {
     runId,
@@ -8662,6 +9411,7 @@ async function runPipelineTick(args) {
     completionAckSync,
     operatorTick,
     sweep,
+    dispatchAdvice: maxStartsAdvice,
     dispatch,
     idle
   };
@@ -8685,8 +9435,18 @@ async function runDaemon(args) {
     stopping = true;
   });
   console.error(JSON.stringify({ event: "daemon_start", runId, agentOsId, execute, intervalMs }));
+  const cronEnv = resolveKynverCronEnv();
   while (!stopping) {
     try {
+      if (cronEnv.tickEnabled) {
+        const cronTick = await runKynverCronTick({
+          env: cronEnv,
+          agentOsIdFilter: agentOsId
+        });
+        if (cronTick.enabled && (cronTick.fired > 0 || cronTick.errors > 0)) {
+          console.error(JSON.stringify({ event: "daemon_cron_tick", ...cronTick }));
+        }
+      }
       const tick = await runPipelineTick({ run: runId, agentOsId, execute, ...args });
       console.error(JSON.stringify({ event: "daemon_tick", ...tick }));
       if (tick.idle) {
@@ -8705,7 +9465,7 @@ async function runDaemon(args) {
 }
 
 // src/plan-progress.ts
-import path50 from "node:path";
+import path53 from "node:path";
 
 // src/bounded-build/constants.ts
 var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
@@ -8992,7 +9752,7 @@ async function emitPlanProgress(args) {
 }
 function verifyPlanLocal(args) {
   const worktree = required(args.worktree ? String(args.worktree) : void 0, "worktree");
-  const cwd = path50.resolve(worktree);
+  const cwd = path53.resolve(worktree);
   const summary = runHarnessVerifyCommands(cwd);
   const emitJson = args.json === true || args.json === "true";
   const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
@@ -9041,9 +9801,9 @@ async function verifyPlan(args) {
 }
 
 // src/harness-verify-cli.ts
-import path51 from "node:path";
+import path54 from "node:path";
 function runHarnessVerifyCli(args) {
-  const cwd = path51.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const cwd = path54.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;
@@ -9087,7 +9847,7 @@ function runHarnessVerifyCli(args) {
 }
 
 // src/plan-persist-cli.ts
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 var OPERATIONS = ["create", "add_version", "update_metadata"];
 var FAILURE_KINDS = [
   "approval_guard",
@@ -9099,7 +9859,7 @@ var FAILURE_KINDS = [
 function readBodyArg(args) {
   const bodyFile = args.bodyFile ? String(args.bodyFile) : void 0;
   if (bodyFile) {
-    return { body: readFileSync11(bodyFile, "utf8"), bodyPathHint: bodyFile };
+    return { body: readFileSync12(bodyFile, "utf8"), bodyPathHint: bodyFile };
   }
   const inline = args.body ? String(args.body) : void 0;
   if (inline) return { body: inline };
@@ -9243,7 +10003,7 @@ function formatMonitorTickNotice(tick) {
 }
 
 // src/monitor/monitor.service.ts
-import path53 from "node:path";
+import path56 from "node:path";
 
 // src/monitor/monitor.classify.ts
 function classifyWorkerHealth(input) {
@@ -9295,11 +10055,11 @@ function classifyWorkerHealth(input) {
 }
 
 // src/monitor/monitor.store.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync6, readdirSync as readdirSync11, unlinkSync as unlinkSync2 } from "node:fs";
-import path52 from "node:path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync6, readdirSync as readdirSync12, unlinkSync as unlinkSync3 } from "node:fs";
+import path55 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path52.join(harnessRoot, "monitors");
+  const dir = path55.join(harnessRoot, "monitors");
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
@@ -9307,7 +10067,7 @@ function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path52.join(monitorsDir(), `${monitorId}.json`);
+  return path55.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -9317,18 +10077,18 @@ function saveMonitorSession(session) {
 }
 function deleteMonitorSession(monitorId) {
   const file = monitorPath(monitorId);
-  if (!existsSync34(file)) return false;
-  unlinkSync2(file);
+  if (!existsSync37(file)) return false;
+  unlinkSync3(file);
   return true;
 }
 function listMonitorSessions() {
   const dir = monitorsDir();
-  if (!existsSync34(dir)) return [];
+  if (!existsSync37(dir)) return [];
   const entries = [];
-  for (const name of readdirSync11(dir)) {
+  for (const name of readdirSync12(dir)) {
     if (!name.endsWith(".json")) continue;
     const session = readJson(
-      path52.join(dir, name),
+      path55.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -9419,7 +10179,7 @@ async function fetchTaskLeasesForWorkers(input) {
 // src/monitor/monitor.service.ts
 function workerRecord2(runId, name) {
   return readJson(
-    path53.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path56.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -9625,21 +10385,21 @@ async function runMonitorLoop(args) {
 
 // src/monitor/monitor-spawn.ts
 import { spawn as spawn6 } from "node:child_process";
-import { closeSync as closeSync6, existsSync as existsSync35, openSync as openSync6 } from "node:fs";
-import path54 from "node:path";
+import { closeSync as closeSync7, existsSync as existsSync38, openSync as openSync7 } from "node:fs";
+import path57 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path54.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
+  return path57.join(fileURLToPath3(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
-  if (!existsSync35(cliPath)) return void 0;
+  if (!existsSync38(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path54.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path57.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
-    logFd = openSync6(logPath, "a");
+    logFd = openSync7(logPath, "a");
   } catch {
     logFd = void 0;
   }
@@ -9679,7 +10439,7 @@ function spawnMonitorSidecar(opts) {
         env: process.env
       })
     );
-    if (logFd !== void 0) closeSync6(logFd);
+    if (logFd !== void 0) closeSync7(logFd);
     child.unref();
     const session = {
       monitorId,
@@ -9696,7 +10456,7 @@ function spawnMonitorSidecar(opts) {
   } catch {
     if (logFd !== void 0) {
       try {
-        closeSync6(logFd);
+        closeSync7(logFd);
       } catch {
       }
     }
@@ -9756,13 +10516,13 @@ async function monitorTickCli(args) {
 }
 
 // src/package-version.ts
-import { existsSync as existsSync36, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync39, 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 (existsSync36(join(dir, "package.json"))) return dir;
+    if (existsSync39(join(dir, "package.json"))) return dir;
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -9771,7 +10531,7 @@ function resolvePackageRoot(moduleUrl) {
 }
 function readOwnPackageVersion(moduleUrl = import.meta.url) {
   const pkgPath = join(resolvePackageRoot(moduleUrl), "package.json");
-  const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
   if (typeof pkg.version !== "string" || !pkg.version.trim()) {
     throw new Error(`Missing package.json version at ${pkgPath}`);
   }
@@ -9792,7 +10552,7 @@ function handleCliVersionFlag(argv, moduleUrl = import.meta.url, binName) {
 }
 
 // src/post-restart-unblock.ts
-import path55 from "node:path";
+import path58 from "node:path";
 function skip(runId, worker, taskId, agentOsId, leaseOwner, reason) {
   return { runId, worker, taskId, agentOsId, leaseOwner, action: "skipped", reason };
 }
@@ -9805,7 +10565,7 @@ async function postRestartUnblock(args) {
   const errors = [];
   for (const run of listRunRecords()) {
     for (const name of Object.keys(run.workers ?? {})) {
-      const workerPath = path55.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json");
+      const workerPath = path58.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"));
@@ -9917,12 +10677,12 @@ async function postRestartUnblockCli(args) {
 }
 
 // src/doctor/runtime-takeover.ts
-import path57 from "node:path";
+import path60 from "node:path";
 
 // src/doctor/runtime-takeover.probes.ts
-import { accessSync, constants, existsSync as existsSync37, readFileSync as readFileSync13 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import path56 from "node:path";
+import { accessSync, constants, existsSync as existsSync40, readFileSync as readFileSync14 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
+import path59 from "node:path";
 import { spawnSync as spawnSync7 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
@@ -9951,7 +10711,7 @@ function tokenPrefix(token) {
   return trimmed.length <= 12 ? `${trimmed}\u2026` : `${trimmed.slice(0, 12)}\u2026`;
 }
 function isWritable(target) {
-  if (!existsSync37(target)) return false;
+  if (!existsSync40(target)) return false;
   try {
     accessSync(target, constants.W_OK);
     return true;
@@ -9964,15 +10724,15 @@ var defaultRuntimeTakeoverProbes = {
   commandOnPath: (bin) => captureCommand(process.platform === "win32" ? "where" : "which", [bin]),
   kynverVersion: (bin) => captureCommand(bin, ["--version"]),
   loadConfig: () => loadUserConfig(),
-  configFilePath: () => path56.join(homedir13(), ".kynver", "config.json"),
-  credentialsFilePath: () => path56.join(homedir13(), ".kynver", "credentials"),
+  configFilePath: () => path59.join(homedir14(), ".kynver", "config.json"),
+  credentialsFilePath: () => path59.join(homedir14(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path56.join(homedir13(), ".kynver", "credentials");
-    if (!existsSync37(credPath)) {
+    const credPath = path59.join(homedir14(), ".kynver", "credentials");
+    if (!existsSync40(credPath)) {
       return { hasApiKey: false };
     }
     try {
-      const parsed = JSON.parse(readFileSync13(credPath, "utf8"));
+      const parsed = JSON.parse(readFileSync14(credPath, "utf8"));
       return {
         hasApiKey: Boolean(parsed.apiKey?.trim()),
         runnerTokenPrefix: tokenPrefix(parsed.runnerToken),
@@ -9991,7 +10751,10 @@ var defaultRuntimeTakeoverProbes = {
     kynverHarnessRoot: process.env.KYNVER_HARNESS_ROOT?.trim() || void 0,
     opusHarnessRoot: process.env.OPUS_HARNESS_ROOT?.trim() || void 0,
     kynverSchedulerProvider: process.env.KYNVER_SCHEDULER_PROVIDER?.trim() || void 0,
-    openclawCronStorePath: Boolean(process.env.OPENCLAW_CRON_STORE_PATH?.trim()),
+    openclawCronStorePath: Boolean(
+      process.env.KYNVER_CRON_STORE_PATH?.trim() || process.env.OPENCLAW_CRON_STORE_PATH?.trim()
+    ),
+    kynverCronDaemonPrimary: isKynverCronDaemonPrimary(),
     qstashTokenPresent: Boolean(process.env.QSTASH_TOKEN?.trim()),
     kynverHostedDeployment: (() => {
       const v = process.env.KYNVER_HOSTED_DEPLOYMENT?.trim().toLowerCase();
@@ -9999,8 +10762,8 @@ var defaultRuntimeTakeoverProbes = {
     })()
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path56.join(homedir13(), ".openclaw", "harness"),
-  pathExists: (target) => existsSync37(target),
+  legacyOpenclawHarnessRoot: () => path59.join(homedir14(), ".openclaw", "harness"),
+  pathExists: (target) => existsSync40(target),
   pathWritable: (target) => isWritable(target),
   vercelVersion: () => captureCommand("vercel", ["--version"]),
   vercelWhoami: () => captureCommand("vercel", ["whoami"])
@@ -10020,8 +10783,10 @@ function assessRuntimeTakeoverScheduler(env, ctx) {
   const schedulerDetails = {
     schedulerProvider: env.kynverSchedulerProvider ?? null,
     deploymentSchedulerProvider: ctx.deploymentSchedulerProvider ?? null,
-    openclawCronStorePath: Boolean(env.openclawCronStorePath)
+    openclawCronStorePath: Boolean(env.openclawCronStorePath),
+    kynverCronDaemonPrimary: Boolean(env.kynverCronDaemonPrimary)
   };
+  const daemonDispatchReady = Boolean(ctx.agentOsId?.trim()) && Boolean(ctx.apiBaseUrl?.trim()) && ctx.hasScopedRunnerToken;
   if (hasQstashCutover(env, ctx) && !hasLocalOpenClawDependency(env, ctx)) {
     const source = env.kynverSchedulerProvider === "qstash" ? "KYNVER_SCHEDULER_PROVIDER=qstash on this host" : "deploymentSchedulerProvider=qstash in ~/.kynver/config.json";
     return check({
@@ -10033,6 +10798,19 @@ function assessRuntimeTakeoverScheduler(env, ctx) {
     });
   }
   if (hasLocalOpenClawDependency(env, ctx)) {
+    if (env.kynverCronDaemonPrimary && daemonDispatchReady) {
+      return check({
+        id: "hotspot_openclaw_scheduler",
+        label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
+        status: "pass",
+        summary: "Kynver Cron local store present; `kynver daemon` owns schedule fires (kynver-cron tick loop)",
+        details: {
+          ...schedulerDetails,
+          dispatchPath: "kynver-daemon-cron-tick",
+          kynverCronDaemonPrimary: true
+        }
+      });
+    }
     const parts = [];
     if (env.kynverSchedulerProvider === "openclaw-cron") {
       parts.push("KYNVER_SCHEDULER_PROVIDER=openclaw-cron");
@@ -10041,21 +10819,20 @@ function assessRuntimeTakeoverScheduler(env, ctx) {
       parts.push("deploymentSchedulerProvider=openclaw-cron in config");
     }
     if (env.openclawCronStorePath) {
-      parts.push("OPENCLAW_CRON_STORE_PATH set (local cron bridge)");
+      parts.push("KYNVER_CRON_STORE_PATH or OPENCLAW_CRON_STORE_PATH set (local cron store)");
     }
     return check({
       id: "hotspot_openclaw_scheduler",
       label: "Scheduler provider (runtime daemon vs OpenClaw cron)",
       status: "warn",
-      summary: `OpenClaw local cron still active (${parts.join("; ")})`,
-      remediation: "On the Kynver deployment: set KYNVER_SCHEDULER_PROVIDER=qstash with QSTASH_TOKEN configured. On user runners: unset KYNVER_SCHEDULER_PROVIDER and OPENCLAW_CRON_STORE_PATH; after Vercel env is updated run `kynver scheduler attest-cutover`.",
+      summary: `Local cron store without daemon tick (${parts.join("; ")})`,
+      remediation: "Run `kynver daemon` with KYNVER_CRON_SECRET + KYNVER_API_URL (or KYNVER_CRON_FIRE_BASE_URL) so the daemon-owned cron tick fires schedules. On hosted deploys use QStash (KYNVER_SCHEDULER_PROVIDER=qstash). Legacy OpenClaw cron env aliases still work during cutover.",
       details: schedulerDetails
     });
   }
   const runnerOpenclaw = env.kynverSchedulerProvider === "openclaw-cron";
   const runnerQstash = env.kynverSchedulerProvider === "qstash";
   const hostedDeployment = Boolean(env.qstashTokenPresent) || Boolean(env.kynverHostedDeployment);
-  const daemonDispatchReady = Boolean(ctx.agentOsId?.trim()) && Boolean(ctx.apiBaseUrl?.trim()) && ctx.hasScopedRunnerToken;
   const hostedSchedulerProcess = hostedDeployment && !daemonDispatchReady;
   const deploymentNeedsQstash = hostedSchedulerProcess && !env.qstashTokenPresent && env.kynverSchedulerProvider !== "qstash";
   const deploymentOpenclaw = hostedSchedulerProcess && env.kynverSchedulerProvider === "openclaw-cron";
@@ -10328,8 +11105,8 @@ function assessVercelCli(probes) {
 }
 function assessHarnessDirs(probes) {
   const harnessRoot = probes.harnessRoot();
-  const runsDir = path57.join(harnessRoot, "runs");
-  const worktreesDir = path57.join(harnessRoot, "worktrees");
+  const runsDir = path60.join(harnessRoot, "runs");
+  const worktreesDir = path60.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -10532,6 +11309,11 @@ var RUNNER_SCHEDULER_CUTOVER_STEPS = [
 function readSchedulerCutoverEnv(env = process.env) {
   return {
     kynverSchedulerProvider: env.KYNVER_SCHEDULER_PROVIDER?.trim() || null,
+    kynverCronStorePath: env.KYNVER_CRON_STORE_PATH?.trim() || env.OPENCLAW_CRON_STORE_PATH?.trim() || null,
+    kynverCronSecret: Boolean(
+      env.KYNVER_CRON_SECRET?.trim() || env.OPENCLAW_CRON_SECRET?.trim()
+    ),
+    kynverCronFireBaseUrl: env.KYNVER_CRON_FIRE_BASE_URL?.trim() || env.OPENCLAW_CRON_FIRE_BASE_URL?.trim() || null,
     openclawCronStorePath: env.OPENCLAW_CRON_STORE_PATH?.trim() || null,
     openclawCronSecret: Boolean(env.OPENCLAW_CRON_SECRET?.trim()),
     openclawCronFireBaseUrl: env.OPENCLAW_CRON_FIRE_BASE_URL?.trim() || null
@@ -10542,8 +11324,13 @@ function assessSchedulerCutover(config, env = readSchedulerCutoverEnv()) {
   if (env.kynverSchedulerProvider === "openclaw-cron") {
     blockers.push("Runner still has KYNVER_SCHEDULER_PROVIDER=openclaw-cron");
   }
-  if (env.openclawCronStorePath) {
-    blockers.push("Runner still has OPENCLAW_CRON_STORE_PATH");
+  if (env.kynverCronStorePath && env.kynverSchedulerProvider !== "kynver-cron") {
+    blockers.push(
+      "Runner has KYNVER_CRON_STORE_PATH but KYNVER_SCHEDULER_PROVIDER is not kynver-cron \u2014 use `kynver daemon` cron tick or unset the store for QStash-only runners"
+    );
+  }
+  if (env.openclawCronStorePath && !env.kynverCronStorePath) {
+    blockers.push("Runner still has legacy OPENCLAW_CRON_STORE_PATH (prefer KYNVER_CRON_STORE_PATH)");
   }
   if (config.deploymentSchedulerProvider === "openclaw-cron") {
     blockers.push("~/.kynver/config.json deploymentSchedulerProvider is still openclaw-cron");
@@ -10565,9 +11352,9 @@ function applySchedulerCutoverAttestation(config) {
 }
 
 // src/scheduler-cutover-cli.ts
-import path58 from "node:path";
-import { homedir as homedir14 } from "node:os";
-var CONFIG_FILE2 = path58.join(homedir14(), ".kynver", "config.json");
+import path61 from "node:path";
+import { homedir as homedir15 } from "node:os";
+var CONFIG_FILE2 = path61.join(homedir15(), ".kynver", "config.json");
 function runSchedulerCutoverCheckCli(json = false) {
   const config = loadUserConfig();
   const report = assessSchedulerCutover(config);
@@ -10595,7 +11382,10 @@ function runSchedulerCutoverCheckCli(json = false) {
     `  KYNVER_SCHEDULER_PROVIDER: ${report.runnerEnv.kynverSchedulerProvider ?? "(unset)"}`
   );
   console.log(
-    `  OPENCLAW_CRON_STORE_PATH: ${report.runnerEnv.openclawCronStorePath ?? "(unset)"}`
+    `  KYNVER_CRON_STORE_PATH: ${report.runnerEnv.kynverCronStorePath ?? "(unset)"}`
+  );
+  console.log(
+    `  OPENCLAW_CRON_STORE_PATH (legacy): ${report.runnerEnv.openclawCronStorePath ?? "(unset)"}`
   );
   if (report.blockers.length) {
     console.log("\nBlockers:");
@@ -10642,6 +11432,65 @@ function runSchedulerAttestCutoverCli(json = false) {
   console.log(`  config: ${payload.configPath}`);
 }
 
+// src/cron/cron-status.ts
+async function buildKynverCronStatusReport(env = resolveKynverCronEnv()) {
+  const jobs = await loadCronJobs(env.storePath).catch(() => []);
+  const state = await loadCronTickState(env.statePath).catch(() => ({ version: 1, jobs: {} }));
+  const credentialsReady = Boolean(env.fireBaseUrl && env.secret);
+  const daemonPrimary = isKynverCronDaemonPrimary(env);
+  let primary = "disabled";
+  if (daemonPrimary) primary = "kynver-cron-daemon";
+  else if (process.env.QSTASH_TOKEN?.trim()) primary = "qstash";
+  return {
+    primary,
+    env: {
+      storePath: env.storePath,
+      statePath: env.statePath,
+      tickEnabled: env.tickEnabled,
+      fireBaseUrl: env.fireBaseUrl,
+      missedRunPolicy: env.missedRunPolicy,
+      maxCatchUpPerTick: env.maxCatchUpPerTick,
+      maxRetries: env.maxRetries
+    },
+    jobCount: jobs.length,
+    stateJobCount: Object.keys(state.jobs).length,
+    credentialsReady,
+    daemonPrimary
+  };
+}
+
+// src/cron/cron-tick-cli.ts
+async function runCronStatusCli(json) {
+  const report = await buildKynverCronStatusReport();
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  console.log(`Kynver Cron primary: ${report.primary}`);
+  console.log(`  store: ${report.env.storePath} (${report.jobCount} jobs)`);
+  console.log(`  tick state: ${report.env.statePath} (${report.stateJobCount} tracked)`);
+  console.log(`  tick enabled: ${report.env.tickEnabled}`);
+  console.log(`  fire base URL: ${report.env.fireBaseUrl ?? "(unset)"}`);
+  console.log(`  credentials ready: ${report.credentialsReady}`);
+  console.log(`  daemon-owned primary: ${report.daemonPrimary}`);
+}
+async function runCronTickCli(args) {
+  const agentOsId = typeof args.agentOsId === "string" ? args.agentOsId : void 0;
+  const result = await runKynverCronTick({
+    agentOsIdFilter: agentOsId ?? null
+  });
+  if (args.json === true) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(
+    JSON.stringify({
+      event: "kynver_cron_tick",
+      ...result
+    })
+  );
+}
+
 // src/cli.ts
 function isHelpFlag(arg) {
   return arg === "help" || arg === "--help" || arg === "-h";
@@ -10692,6 +11541,8 @@ function usage(code = 0) {
       "  kynver doctor runtime-takeover",
       "  kynver scheduler cutover-check [--json]",
       "  kynver scheduler attest-cutover [--json]",
+      "  kynver cron status [--json]",
+      "  kynver cron tick [--agent-os-id AOS_ID] [--json]",
       "  kynver board contract [--agent-os-id ID] [--base-url URL] [--since ISO] [--limit N]"
     ].join("\n")
   );
@@ -10703,7 +11554,7 @@ async function main(argv = process.argv.slice(2)) {
   const scope = argv.shift();
   let action;
   let rest;
-  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner" || scope === "harness" || scope === "monitor" || scope === "doctor" || scope === "scheduler" || scope === "board") {
+  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner" || scope === "harness" || scope === "monitor" || scope === "doctor" || scope === "scheduler" || scope === "cron" || scope === "board") {
     action = argv.shift();
     rest = argv;
   } else {
@@ -10736,6 +11587,12 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "scheduler" && action === "attest-cutover") {
     return runSchedulerAttestCutoverCli(args.json === true);
   }
+  if (scope === "cron" && action === "status") {
+    return void await runCronStatusCli(args.json === true);
+  }
+  if (scope === "cron" && action === "tick") {
+    return void await runCronTickCli(args);
+  }
   if (scope === "board" && action === "contract") {
     return void await runCommandCenterContractCli(args);
   }