@kynver-app/runtime 0.1.10 → 0.1.13

package/dist/index.js

@@ -381,12 +381,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 path14 = input.diskPath?.trim() || "/";
+  const path15 = input.diskPath?.trim() || "/";
   const warnBelowBytes = input.diskFreeWarnBytes ?? DEFAULT_WARN_FREE_BYTES;
   const criticalBelowBytes = input.diskFreeCriticalBytes ?? DEFAULT_CRITICAL_FREE_BYTES;
   const maxUsedPercent = input.diskMaxUsedPercent ?? DEFAULT_MAX_USED_PERCENT;
   const hardMaxUsedPercent = input.diskHardMaxUsedPercent ?? DEFAULT_HARD_MAX_USED_PERCENT;
-  const stats = statfsSync(path14);
+  const stats = statfsSync(path15);
   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;
@@ -406,7 +406,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path14,
+    path: path15,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -419,10 +419,12 @@ function observeRunnerDiskGate(input = {}) {
 }
 
 // src/resource-gate.ts
+import { readFileSync as readFileSync5 } from "node:fs";
 import os from "node:os";
 import path5 from "node:path";
 
 // src/run-store.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2 } from "node:fs";
 import path4 from "node:path";
 
 // src/paths.ts
@@ -458,6 +460,20 @@ function loadRun(id) {
   const { runsDir } = getPaths();
   return readJson(path4.join(runDir(runsDir, safeSlug(id)), "run.json"));
 }
+function listRunRecords() {
+  const { runsDir } = getPaths();
+  if (!existsSync4(runsDir)) return [];
+  const runs = [];
+  for (const entry of readdirSync2(runsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const run = readJson(
+      path4.join(runsDir, entry.name, "run.json"),
+      void 0
+    );
+    if (run?.id) runs.push(run);
+  }
+  return runs;
+}
 function loadWorker(runId, name) {
   const { runsDir } = getPaths();
   return readJson(
@@ -478,7 +494,7 @@ function runDirectory(id) {
 }
 
 // src/heartbeat.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
 function parseHeartbeat(file) {
   const result = {
     heartbeatCount: 0,
@@ -487,7 +503,7 @@ function parseHeartbeat(file) {
     lastHeartbeatSummary: null,
     heartbeatBlocker: null
   };
-  if (!existsSync4(file)) return result;
+  if (!existsSync5(file)) return result;
   const lines = readFileSync3(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const entry = safeJson(line);
@@ -503,7 +519,7 @@ function parseHeartbeat(file) {
 }
 
 // src/stream.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
 function parseClaudeStream(file) {
   const result = {
     firstEventAt: null,
@@ -512,7 +528,7 @@ function parseClaudeStream(file) {
     finalResult: null,
     error: null
   };
-  if (!existsSync5(file)) return result;
+  if (!existsSync6(file)) return result;
   const lines = readFileSync4(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const event = safeJson(line);
@@ -594,6 +610,92 @@ function ensureGitRepo(repo) {
 function gitStatusShort(worktreePath) {
   return git(worktreePath, ["status", "--short"], { allowFailure: true }).split("\n").map((line) => line.trim()).filter(Boolean);
 }
+function gitCapture(cwd, args) {
+  try {
+    const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+    return {
+      status: res.status,
+      stdout: res.stdout || "",
+      stderr: res.stderr || "",
+      error: res.error ? res.error.message : null
+    };
+  } catch (error) {
+    return {
+      status: null,
+      stdout: "",
+      stderr: "",
+      error: error.message
+    };
+  }
+}
+function gitIsAncestor(cwd, ancestor, descendant) {
+  const res = gitCapture(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
+  if (res.status === 0) return { isAncestor: true, error: null };
+  if (res.status === 1) return { isAncestor: false, error: null };
+  return { isAncestor: null, error: res.error || res.stderr || res.stdout || `git exited ${res.status}` };
+}
+function computeGitAncestry(worktreePath, base = "origin/main") {
+  if (!worktreePath) {
+    return unknownAncestry(base, "missing worktree path");
+  }
+  const head = gitCapture(worktreePath, ["rev-parse", "HEAD"]);
+  if (head.status !== 0) return unknownAncestry(base, head.error || head.stderr || head.stdout || "failed to resolve HEAD");
+  const baseHead = gitCapture(worktreePath, ["rev-parse", base]);
+  if (baseHead.status !== 0) {
+    return unknownAncestry(base, baseHead.error || baseHead.stderr || baseHead.stdout || `failed to resolve ${base}`, head.stdout.trim());
+  }
+  const headSha = head.stdout.trim();
+  const baseSha = baseHead.stdout.trim();
+  if (headSha === baseSha) {
+    return {
+      checked: true,
+      base,
+      head: headSha,
+      baseHead: baseSha,
+      baseIsAncestorOfHead: true,
+      headIsAncestorOfBase: true,
+      relation: "synced"
+    };
+  }
+  const baseIsAncestorOfHead = gitIsAncestor(worktreePath, baseSha, headSha);
+  const headIsAncestorOfBase = gitIsAncestor(worktreePath, headSha, baseSha);
+  const error = baseIsAncestorOfHead.error || headIsAncestorOfBase.error || void 0;
+  if (baseIsAncestorOfHead.isAncestor == null || headIsAncestorOfBase.isAncestor == null) {
+    return {
+      checked: false,
+      base,
+      head: headSha,
+      baseHead: baseSha,
+      baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
+      headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
+      relation: "unknown",
+      ...error ? { error } : {}
+    };
+  }
+  const relation = baseIsAncestorOfHead.isAncestor ? "ahead" : headIsAncestorOfBase.isAncestor ? "merged" : "diverged";
+  return {
+    checked: true,
+    base,
+    head: headSha,
+    baseHead: baseSha,
+    baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
+    headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
+    relation,
+    ...error ? { error } : {}
+  };
+}
+function unknownAncestry(base, error, head = null) {
+  return {
+    checked: false,
+    base,
+    head,
+    baseHead: null,
+    baseIsAncestorOfHead: null,
+    headIsAncestorOfBase: null,
+    relation: "unknown",
+    error
+  };
+}
 function scrubClaudeEnv(env) {
   const next = { ...env };
   delete next.ANTHROPIC_API_KEY;
@@ -620,7 +722,7 @@ function computeAttention(input) {
   }
   return { state: "ok", reason: "recent activity" };
 }
-function computeWorkerStatus(worker) {
+function computeWorkerStatus(worker, options = {}) {
   const parsed = parseClaudeStream(worker.stdoutPath);
   const heartbeat = parseHeartbeat(worker.heartbeatPath);
   const alive = isPidAlive(worker.pid);
@@ -628,6 +730,7 @@ function computeWorkerStatus(worker) {
   const stderrBytes = fileSize(worker.stderrPath);
   const heartbeatBytes = fileSize(worker.heartbeatPath);
   const changedFiles = gitStatusShort(worker.worktreePath);
+  const gitAncestry = computeGitAncestry(worker.worktreePath, options.base);
   const lastActivityAt = latestIso([
     parsed.lastEventAt,
     heartbeat.lastHeartbeatAt,
@@ -669,7 +772,8 @@ function computeWorkerStatus(worker) {
     heartbeatBlocker: heartbeat.heartbeatBlocker,
     finalResult: parsed.finalResult,
     error: parsed.error || (!alive && !parsed.finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0),
-    changedFiles
+    changedFiles,
+    gitAncestry
   };
 }
 function isFinishedWorkerStatus(status) {
@@ -717,13 +821,23 @@ function computeAutoMaxWorkers(totalMemBytes, opts = {}) {
   const raw = Math.max(1, Math.floor(budgetBytes / perWorkerMemBytes));
   return Math.min(raw, AUTO_MAX_WORKERS_CEILING);
 }
-function countActiveWorkers(runId) {
-  const run = loadRun(runId);
+function readAvailableMemBytes() {
+  if (process.platform === "linux") {
+    try {
+      const meminfo = readFileSync5("/proc/meminfo", "utf8");
+      const match = meminfo.match(/^MemAvailable:\s+(\d+)\s*kB/m);
+      if (match) return Number(match[1]) * 1024;
+    } catch {
+    }
+  }
+  return os.freemem();
+}
+function countActiveWorkersForRun(run) {
   let active = 0;
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
       path5.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-      null
+      void 0
     );
     if (!worker) continue;
     const status = computeWorkerStatus(worker);
@@ -733,14 +847,19 @@ function countActiveWorkers(runId) {
   }
   return active;
 }
+function countActiveWorkersGlobal() {
+  let active = 0;
+  for (const run of listRunRecords()) active += countActiveWorkersForRun(run);
+  return active;
+}
 function observeRunnerResourceGate(input) {
   const { perWorkerMemBytes, memReserveBytes, memUtilization, configuredMaxWorkers } = resolveResourceConfig(
     input.config,
     input.configuredMaxWorkersOverride
   );
   const totalMemBytes = input.totalMemBytes ?? os.totalmem();
-  const freeMemBytes = input.freeMemBytes ?? os.freemem();
-  const activeWorkers = input.activeWorkers ?? countActiveWorkers(input.runId);
+  const freeMemBytes = input.freeMemBytes ?? readAvailableMemBytes();
+  const activeWorkers = input.activeWorkers ?? countActiveWorkersGlobal();
   const budgetBytes = Math.max(0, Math.floor(totalMemBytes * memUtilization) - memReserveBytes);
   const capacityFromTotal = Math.max(0, Math.floor(budgetBytes / perWorkerMemBytes));
   const capacityFromFree = Math.max(0, Math.floor(Math.max(0, freeMemBytes - memReserveBytes) / perWorkerMemBytes));
@@ -748,13 +867,13 @@ function observeRunnerResourceGate(input) {
   const targetCap = configuredMaxWorkers ?? autoCap;
   const maxConcurrentWorkers = Math.max(0, Math.min(targetCap, capacityFromTotal));
   const slotsByCapacity = Math.max(0, maxConcurrentWorkers - activeWorkers);
-  const slotsByFreeMem = Math.max(0, capacityFromFree - activeWorkers);
+  const slotsByFreeMem = capacityFromFree;
   const slotsAvailable = Math.min(slotsByCapacity, slotsByFreeMem);
   let reason = null;
   if (slotsAvailable <= 0) {
     if (activeWorkers >= maxConcurrentWorkers) {
       reason = `at worker limit (${activeWorkers}/${maxConcurrentWorkers} running)`;
-    } else if (capacityFromFree <= activeWorkers) {
+    } else if (capacityFromFree <= 0) {
       reason = "insufficient free memory \u2014 waiting for workers to finish";
     } else {
       reason = "no worker slots available";
@@ -777,7 +896,7 @@ function observeRunnerResourceGate(input) {
 }
 
 // src/supervisor.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3 } from "node:fs";
 import path7 from "node:path";
 
 // src/prompt.ts
@@ -850,19 +969,19 @@ var claudeProvider = {
 };
 
 // src/providers/cursor.ts
-import { closeSync as closeSync2, existsSync as existsSync6, openSync as openSync2, readdirSync as readdirSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync7, openSync as openSync2, readdirSync as readdirSync3 } from "node:fs";
 import { spawn as spawn2 } from "node:child_process";
 import path6 from "node:path";
 var DEFAULT_CURSOR_MODEL = "composer-2.5";
 function latestVersionDir(versionsRoot) {
-  if (!existsSync6(versionsRoot)) return null;
-  const versions = readdirSync2(versionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^\d{4}\.\d/.test(entry.name)).map((entry) => entry.name).sort((a, b) => b.localeCompare(a));
+  if (!existsSync7(versionsRoot)) return null;
+  const versions = readdirSync3(versionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^\d{4}\.\d/.test(entry.name)).map((entry) => entry.name).sort((a, b) => b.localeCompare(a));
   return versions[0] ? path6.join(versionsRoot, versions[0]) : null;
 }
 function resolveBundledCursor(versionDir) {
   const nodeExe = path6.join(versionDir, "node.exe");
   const indexJs = path6.join(versionDir, "index.js");
-  if (!existsSync6(nodeExe) || !existsSync6(indexJs)) return null;
+  if (!existsSync7(nodeExe) || !existsSync7(indexJs)) return null;
   return { executable: nodeExe, prefixArgs: [indexJs], shell: false, detached: true };
 }
 function resolveWindowsCursorSpawn(agentBin) {
@@ -885,7 +1004,7 @@ function resolveAgentBin() {
   if (configured) return configured;
   if (process.platform === "win32") {
     const localAgent = path6.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
-    if (existsSync6(localAgent)) return localAgent;
+    if (existsSync7(localAgent)) return localAgent;
   }
   return "agent";
 }
@@ -954,8 +1073,11 @@ function resolveWorkerProvider(name) {
 
 // src/supervisor.ts
 function spawnWorkerProcess(run, opts) {
-  const name = safeSlug(opts.name);
-  if (!opts.name) throw new Error("worker name is required");
+  const rawName = typeof opts.name === "string" ? opts.name.trim() : "";
+  if (!rawName || rawName === "undefined" || rawName === "null") {
+    throw new Error(`worker name is required and must be a real identifier (got: ${JSON.stringify(opts.name)})`);
+  }
+  const name = safeSlug(rawName);
   if (run.workers?.[name]) throw new Error(`worker already exists in run ${run.id}: ${name}`);
   if (!opts.task) throw new Error(`missing task text for worker ${name}`);
   const { worktreesDir } = getPaths();
@@ -963,7 +1085,7 @@ function spawnWorkerProcess(run, opts) {
   mkdirSync3(workerDir, { recursive: true });
   const worktreePath = path7.join(worktreesDir, run.id, name);
   const branch = opts.branch || `agent/${run.id}/${name}`;
-  if (existsSync7(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
+  if (existsSync8(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
   git(run.repo, ["fetch", "origin", "--prune"], { allowFailure: true });
   git(run.repo, ["worktree", "add", "-b", branch, worktreePath, run.baseCommit], { throwError: true });
   const stdoutPath = path7.join(workerDir, "stdout.jsonl");
@@ -1025,6 +1147,11 @@ function spawnWorkerProcess(run, opts) {
 }
 function startWorker(args) {
   const run = loadRun(String(args.run));
+  const name = typeof args.name === "string" ? args.name.trim() : "";
+  if (!name) {
+    console.error("worker start failed: --name is required");
+    process.exit(1);
+  }
   const task = args.task ? String(args.task) : readMaybeFile(args.taskFile ? String(args.taskFile) : void 0);
   if (!task) {
     console.error("missing --task or --task-file");
@@ -1032,7 +1159,7 @@ function startWorker(args) {
   }
   try {
     const worker = spawnWorkerProcess(run, {
-      name: String(args.name),
+      name,
       task,
       ownedPaths: args.owned ? String(args.owned).split(",").map((s) => s.trim()).filter(Boolean) : [],
       model: args.model ? String(args.model) : void 0,
@@ -1259,14 +1386,14 @@ function validateTailLines(lines) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4 } from "node:fs";
 import path9 from "node:path";
 function createRun(args) {
   const repo = validateRepo(required(String(args.repo || ""), "--repo"));
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync8(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync9(dir)) failExists(`run already exists: ${id}`);
   mkdirSync4(dir, { recursive: true });
   const base = String(args.base || "origin/main");
   const baseCommit = git(repo, ["rev-parse", base]).trim();
@@ -1285,7 +1412,7 @@ function createRun(args) {
 }
 function listRuns() {
   const { runsDir } = getPaths();
-  const rows = listRunIds(runsDir).map((id) => readJson(path9.join(runDirectory(id), "run.json"), null)).filter(Boolean).map((run) => ({
+  const rows = listRunIds(runsDir).map((id) => readJson(path9.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
     id: run.id,
     name: run.name,
     status: run.status,
@@ -1313,7 +1440,7 @@ async function sweepRun(args) {
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
         path10.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-        null
+        void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
       const status = computeWorkerStatus(worker);
@@ -1453,12 +1580,12 @@ function runStatus(args) {
   const workers = names.map((name) => {
     const worker = readJson(
       path11.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-      null
+      void 0
     );
     if (!worker) {
       return { worker: name, status: "missing", attention: "needs_attention", attentionReason: "worker.json not found" };
     }
-    const status = computeWorkerStatus(worker);
+    const status = computeWorkerStatus(worker, { base: run.base });
     return {
       worker: status.worker,
       status: status.status,
@@ -1472,7 +1599,9 @@ function runStatus(args) {
       lastHeartbeatSummary: status.lastHeartbeatSummary,
       heartbeatBlocker: status.heartbeatBlocker,
       changedFileCount: status.changedFiles.length,
-      branch: status.branch
+      branch: status.branch,
+      ancestry: status.gitAncestry.relation,
+      ancestryChecked: status.gitAncestry.checked
     };
   });
   const board = {
@@ -1521,10 +1650,48 @@ import { mkdirSync as mkdirSync5, realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
 // src/pipeline-tick.ts
-import path13 from "node:path";
+import path14 from "node:path";
 
-// src/plan-progress-daemon-sync.ts
+// src/finalize.ts
 import path12 from "node:path";
+var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set(["running", "dispatching", "pending", "queued"]);
+function terminalStatusFor(run) {
+  const names = Object.keys(run.workers || {});
+  if (names.length === 0) return "failed";
+  let anyAlive = false;
+  let anyResult = false;
+  for (const name of names) {
+    const worker = readJson(
+      path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
+    );
+    if (!worker) continue;
+    const status = computeWorkerStatus(worker);
+    if (status.alive && !status.finalResult) {
+      anyAlive = true;
+      break;
+    }
+    if (status.finalResult) anyResult = true;
+  }
+  if (anyAlive) return null;
+  return anyResult ? "completed" : "failed";
+}
+function finalizeStaleRuns() {
+  const finalized = [];
+  for (const run of listRunRecords()) {
+    if (!ACTIVE_RUN_STATUSES.has(run.status)) continue;
+    const next = terminalStatusFor(run);
+    if (!next || next === run.status) continue;
+    const from = run.status;
+    run.status = next;
+    saveRun(run);
+    finalized.push({ runId: run.id, from, to: next });
+  }
+  return finalized;
+}
+
+// src/plan-progress-daemon-sync.ts
+import path13 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -1548,8 +1715,8 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-      null
+      path13.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
     const status = computeWorkerStatus(worker);
@@ -1602,13 +1769,12 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path13.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-      null
+      path14.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
     const status = computeWorkerStatus(worker);
     if (!isFinishedWorkerStatus(status)) continue;
-    if (!status.finalResult) continue;
     const result = await tryCompleteWorker({
       run: runId,
       name,
@@ -1636,6 +1802,7 @@ async function runPipelineTick(args) {
   const agentOsId = String(required(String(args.agentOsId || ""), "--agent-os-id"));
   const execute = args.execute !== false && args.execute !== "false";
   runStatus({ run: runId });
+  const finalizedStaleRuns = finalizeStaleRuns();
   const completedWorkers = await completeFinishedWorkers(runId, args);
   const planProgressSync = await syncActiveWorkerPlanProgress(runId, args);
   const workspacePrefs = await fetchWorkspaceRuntimePreferences(agentOsId, args);
@@ -1677,6 +1844,7 @@ async function runPipelineTick(args) {
     execute,
     resourceGate,
     completedWorkers,
+    finalizedStaleRuns,
     planProgressSync,
     operatorTick,
     sweep,