@kynver-app/runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,1529 @@
+// src/config.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir } from "node:os";
+import path2 from "node:path";
+
+// src/util.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+function required(value, name) {
+  if (!value) fail(`missing ${name}`);
+  return value;
+}
+function safeJson(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    if (arguments.length > 1) return fallback;
+    fail(`failed to read ${file}: ${error.message}`);
+  }
+}
+function writeJson(file, value) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(value, null, 2)}
+`);
+}
+function safeSlug(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "worker";
+}
+function timestampSlug(name) {
+  return safeSlug(`${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\..+/, "Z")}-${name}`);
+}
+function trimTrailingSlash(url) {
+  return String(url).replace(/\/+$/, "");
+}
+function oneLine(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+function fileSize(file) {
+  try {
+    return statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+function fileMtime(file) {
+  try {
+    return statSync(file).mtime.toISOString();
+  } catch {
+    return null;
+  }
+}
+function tailFile(file, lines) {
+  if (!existsSync(file)) return "";
+  const data = readFileSync(file, "utf8");
+  return data.split("\n").slice(-lines).join("\n");
+}
+function readMaybeFile(file) {
+  return file ? readFileSync(path.resolve(file), "utf8") : "";
+}
+function listRunIds(runsDir) {
+  if (!existsSync(runsDir)) return [];
+  return readdirSync(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+function sleepMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function isPidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killWorkerProcess(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    process.kill(pid, signal);
+  }
+}
+function latestIso(values) {
+  let best = null;
+  let bestMs = -Infinity;
+  for (const value of values) {
+    if (!value) continue;
+    const ms = Date.parse(value);
+    if (Number.isFinite(ms) && ms > bestMs) {
+      bestMs = ms;
+      best = value;
+    }
+  }
+  return best;
+}
+function secsAgo(ms) {
+  return Math.max(0, Math.round((Date.now() - ms) / 1e3));
+}
+
+// src/config.ts
+var CONFIG_DIR = path2.join(homedir(), ".kynver");
+var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
+var CREDENTIALS_FILE = path2.join(CONFIG_DIR, "credentials");
+function loadUserConfig() {
+  if (!existsSync2(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync2(CONFIG_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveUserConfig(config) {
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  writeFileSync2(CONFIG_FILE, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+function saveApiKey(apiKey) {
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  writeFileSync2(CREDENTIALS_FILE, `${JSON.stringify({ apiKey }, null, 2)}
+`, { mode: 384 });
+}
+function resolveBaseUrl(argsBaseUrl) {
+  const baseUrl = argsBaseUrl || process.env.KYNVER_API_URL || process.env.OPENCLAW_CRON_FIRE_BASE_URL || loadUserConfig().apiBaseUrl;
+  if (!baseUrl) failConfig("requires --base-url, KYNVER_API_URL, OPENCLAW_CRON_FIRE_BASE_URL, or ~/.kynver/config.json apiBaseUrl");
+  return trimTrailingSlash(String(baseUrl));
+}
+function resolveCallbackSecret(argsSecret) {
+  const secret = argsSecret || process.env.KYNVER_RUNTIME_SECRET || process.env.OPENCLAW_CRON_SECRET;
+  if (!secret) failConfig("requires --secret, KYNVER_RUNTIME_SECRET, or OPENCLAW_CRON_SECRET");
+  return String(secret);
+}
+function failConfig(message) {
+  console.error(message);
+  process.exit(1);
+}
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const item = argv[i];
+    if (!item.startsWith("--")) continue;
+    const key = item.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) args[key] = true;
+    else {
+      args[key] = next;
+      i++;
+    }
+  }
+  return args;
+}
+async function runSetup(args) {
+  const existing = loadUserConfig();
+  const maxWorkersRaw = typeof args.maxWorkers === "string" ? args.maxWorkers : typeof args.maxConcurrentWorkers === "string" ? args.maxConcurrentWorkers : void 0;
+  const config = {
+    ...existing,
+    ...typeof args.apiBaseUrl === "string" ? { apiBaseUrl: args.apiBaseUrl } : {},
+    ...typeof args.agentOsSlug === "string" ? { agentOsSlug: args.agentOsSlug } : {},
+    ...typeof args.agentOsId === "string" ? { agentOsId: args.agentOsId } : {},
+    ...typeof args.repo === "string" ? { defaultRepo: args.repo } : {},
+    ...typeof args.harnessRoot === "string" ? { harnessRoot: args.harnessRoot } : {},
+    ...maxWorkersRaw ? { maxConcurrentWorkers: Math.max(1, Math.floor(Number(maxWorkersRaw))) } : {},
+    workerProvider: typeof args.provider === "string" ? args.provider : existing.workerProvider || "claude"
+  };
+  saveUserConfig(config);
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        configPath: CONFIG_FILE,
+        config,
+        note: "Set worker limit once with --max-workers N (or omit to auto-size from RAM). Advanced RAM tuning stays internal."
+      },
+      null,
+      2
+    )
+  );
+}
+async function runLogin(args) {
+  const apiKey = typeof args.apiKey === "string" ? args.apiKey : process.env.KYNVER_API_KEY;
+  if (!apiKey) failConfig("kynver login requires --api-key or KYNVER_API_KEY");
+  saveApiKey(apiKey);
+  console.log(JSON.stringify({ ok: true, credentialsPath: CREDENTIALS_FILE }, null, 2));
+}
+
+// src/callbacks.ts
+async function postJson(url, secret, body) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-OpenClaw-Cron-Secret": String(secret),
+      "X-Kynver-Runtime-Secret": String(secret)
+    },
+    body: JSON.stringify(body)
+  });
+  let response = null;
+  try {
+    response = await res.json();
+  } catch {
+    response = null;
+  }
+  return { ok: res.ok, status: res.status, response };
+}
+async function getJson(url, secret) {
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      "X-OpenClaw-Cron-Secret": String(secret),
+      "X-Kynver-Runtime-Secret": String(secret)
+    }
+  });
+  let response = null;
+  try {
+    response = await res.json();
+  } catch {
+    response = null;
+  }
+  return { ok: res.ok, status: res.status, response };
+}
+
+// src/disk-gate.ts
+import { statfsSync } from "node:fs";
+var DEFAULT_WARN_FREE_BYTES = 30 * 1024 * 1024 * 1024;
+var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
+var DEFAULT_MAX_USED_PERCENT = 80;
+var DEFAULT_HARD_MAX_USED_PERCENT = 90;
+function observeRunnerDiskGate(input = {}) {
+  const path13 = 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(path13);
+  const freeBytes = Number(stats.bavail) * Number(stats.bsize);
+  const totalBytes = Number(stats.blocks) * Number(stats.bsize);
+  const usedPercent = totalBytes > 0 ? (totalBytes - freeBytes) / totalBytes * 100 : 100;
+  const lowFree = freeBytes < warnBelowBytes;
+  const criticalFree = freeBytes < criticalBelowBytes;
+  const highUse = usedPercent > maxUsedPercent;
+  const hardHighUse = usedPercent > hardMaxUsedPercent;
+  const ok = !lowFree && !criticalFree && !highUse && !hardHighUse;
+  let reason = null;
+  if (!ok) {
+    reason = [
+      criticalFree ? `free space below critical ${criticalBelowBytes} bytes` : null,
+      lowFree ? `free space below warning ${warnBelowBytes} bytes` : null,
+      hardHighUse ? `used percent above hard cap ${hardMaxUsedPercent}%` : null,
+      highUse ? `used percent above cap ${maxUsedPercent}%` : null
+    ].filter(Boolean).join("; ");
+  }
+  return {
+    ok,
+    path: path13,
+    freeBytes,
+    totalBytes,
+    usedPercent,
+    warnBelowBytes,
+    criticalBelowBytes,
+    maxUsedPercent,
+    hardMaxUsedPercent,
+    reason
+  };
+}
+
+// src/resource-gate.ts
+import os from "node:os";
+import path5 from "node:path";
+
+// src/run-store.ts
+import path4 from "node:path";
+
+// src/paths.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import path3 from "node:path";
+var LEGACY_ROOT = path3.join(homedir2(), ".openclaw", "harness");
+function resolveHarnessRoot() {
+  const env = process.env.KYNVER_HARNESS_ROOT || process.env.OPUS_HARNESS_ROOT;
+  if (env) return path3.resolve(env);
+  const kynverRoot = path3.join(homedir2(), ".kynver", "harness");
+  if (existsSync3(kynverRoot)) return kynverRoot;
+  if (existsSync3(LEGACY_ROOT)) return LEGACY_ROOT;
+  return kynverRoot;
+}
+function getHarnessPaths() {
+  const harnessRoot = resolveHarnessRoot();
+  return {
+    harnessRoot,
+    runsDir: path3.join(harnessRoot, "runs"),
+    worktreesDir: path3.join(harnessRoot, "worktrees")
+  };
+}
+function runDir(runsDir, id) {
+  return path3.join(runsDir, safeSlug(id));
+}
+
+// src/run-store.ts
+function getPaths() {
+  return getHarnessPaths();
+}
+function loadRun(id) {
+  const { runsDir } = getPaths();
+  return readJson(path4.join(runDir(runsDir, safeSlug(id)), "run.json"));
+}
+function loadWorker(runId, name) {
+  const { runsDir } = getPaths();
+  return readJson(
+    path4.join(runDir(runsDir, safeSlug(runId)), "workers", safeSlug(name), "worker.json")
+  );
+}
+function saveRun(run) {
+  const { runsDir } = getPaths();
+  writeJson(path4.join(runDir(runsDir, run.id), "run.json"), run);
+}
+function saveWorker(runId, worker) {
+  const { runsDir } = getPaths();
+  writeJson(path4.join(runDir(runsDir, runId), "workers", worker.name, "worker.json"), worker);
+}
+function runDirectory(id) {
+  const { runsDir } = getPaths();
+  return runDir(runsDir, safeSlug(id));
+}
+
+// src/heartbeat.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+function parseHeartbeat(file) {
+  const result = {
+    heartbeatCount: 0,
+    lastHeartbeatAt: null,
+    lastHeartbeatPhase: null,
+    lastHeartbeatSummary: null,
+    heartbeatBlocker: null
+  };
+  if (!existsSync4(file)) return result;
+  const lines = readFileSync3(file, "utf8").split("\n").filter(Boolean);
+  for (const line of lines) {
+    const entry = safeJson(line);
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const row = entry;
+    result.heartbeatCount++;
+    if (row.ts) result.lastHeartbeatAt = String(row.ts);
+    if (row.phase !== void 0 && row.phase !== null) result.lastHeartbeatPhase = String(row.phase);
+    if (row.summary !== void 0 && row.summary !== null) result.lastHeartbeatSummary = String(row.summary);
+    result.heartbeatBlocker = row.blocker ? String(row.blocker) : null;
+  }
+  return result;
+}
+
+// src/stream.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+function parseClaudeStream(file) {
+  const result = {
+    firstEventAt: null,
+    lastEventAt: null,
+    currentTool: null,
+    finalResult: null,
+    error: null
+  };
+  if (!existsSync5(file)) return result;
+  const lines = readFileSync4(file, "utf8").split("\n").filter(Boolean);
+  for (const line of lines) {
+    const event = safeJson(line);
+    if (!event) continue;
+    const ts = event.timestamp || event.ts;
+    if (ts) {
+      result.firstEventAt ||= ts;
+      result.lastEventAt = ts;
+    }
+    if (event.type === "stream_event" && event.event && typeof event.event === "object" && event.event.type === "content_block_start") {
+      const block = event.event.content_block;
+      if (block?.type === "tool_use") result.currentTool = String(block.name || "tool");
+    }
+    if (event.type === "assistant" && event.message && typeof event.message === "object") {
+      const content = event.message.content;
+      if (Array.isArray(content)) {
+        const tool = content.find((item) => item?.type === "tool_use");
+        if (tool) result.currentTool = String(tool.name || result.currentTool);
+      }
+    }
+    if (event.type === "result") {
+      result.finalResult = event.result || event.subtype || event.terminal_reason || "completed";
+      if (event.is_error) result.error = String(event.result || event.api_error_status || "Claude result error");
+    }
+  }
+  return result;
+}
+function summarizeEvent(event) {
+  if (event.type === "system" && event.subtype) {
+    return `[system:${event.subtype}] ${String(event.status || event.cwd || "")}`.trim();
+  }
+  if (event.type === "stream_event" && event.event && typeof event.event === "object") {
+    const type = event.event.type;
+    if (type === "content_block_start") {
+      const block = event.event.content_block;
+      if (block?.type === "tool_use") return `[tool:start] ${block.name}`;
+    }
+    if (type === "content_block_delta") {
+      const delta = event.event.delta;
+      if (delta?.partial_json) return `[tool:input] ${delta.partial_json}`;
+    }
+    if (type === "message_stop") return "[message:stop]";
+    return type ? `[stream:${type}]` : void 0;
+  }
+  if (event.type === "assistant" && event.message && typeof event.message === "object") {
+    const content = event.message.content;
+    if (Array.isArray(content)) {
+      const text = content.find((item) => item?.type === "text");
+      if (text) return `[assistant] ${oneLine(String(text.text || ""))}`;
+      const tool = content.find((item) => item?.type === "tool_use");
+      if (tool) return `[tool] ${tool.name} ${JSON.stringify(tool.input || {})}`;
+    }
+  }
+  if (event.type === "user" && event.tool_use_result) {
+    const result = event.tool_use_result;
+    return `[tool:result] stdout=${JSON.stringify(result.stdout || "")} stderr=${JSON.stringify(result.stderr || "")}`;
+  }
+  if (event.type === "result") {
+    return `[result] ${event.subtype || ""} ${oneLine(String(event.result || ""))}`.trim();
+  }
+  return void 0;
+}
+
+// src/git.ts
+import { spawnSync } from "node:child_process";
+function git(cwd, args, options = {}) {
+  const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+  if (res.status !== 0 && !options.allowFailure) {
+    const message = `git ${args.join(" ")} failed: ${res.stderr || res.stdout}`;
+    if (options.throwError) throw new Error(message);
+    fail(message);
+  }
+  return res.stdout || "";
+}
+function ensureGitRepo(repo) {
+  git(repo, ["rev-parse", "--show-toplevel"]);
+}
+function gitStatusShort(worktreePath) {
+  return git(worktreePath, ["status", "--short"], { allowFailure: true }).split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function scrubClaudeEnv(env) {
+  const next = { ...env };
+  delete next.ANTHROPIC_API_KEY;
+  return next;
+}
+
+// src/status.ts
+var NO_START_MS = 18e4;
+var STALE_MS = 6e5;
+function computeAttention(input) {
+  const now = Date.now();
+  if (input.finalResult) return { state: "done", reason: "final result recorded" };
+  if (!input.alive) return { state: "needs_attention", reason: "process exited without a final result" };
+  if (input.heartbeatBlocker) {
+    return { state: "blocked", reason: `worker heartbeat reported blocker: ${input.heartbeatBlocker}` };
+  }
+  const startMs = input.startedAt ? Date.parse(input.startedAt) : NaN;
+  if (!input.firstEventAt && input.stdoutBytes === 0 && input.heartbeatBytes === 0 && Number.isFinite(startMs) && now - startMs > NO_START_MS) {
+    return { state: "needs_attention", reason: `no first stream event ${secsAgo(startMs)}s after start` };
+  }
+  const actMs = input.lastActivityAt ? Date.parse(input.lastActivityAt) : NaN;
+  if (Number.isFinite(actMs) && now - actMs > STALE_MS) {
+    return { state: "stale", reason: `no log/event/heartbeat activity for ${secsAgo(actMs)}s` };
+  }
+  return { state: "ok", reason: "recent activity" };
+}
+function computeWorkerStatus(worker) {
+  const parsed = parseClaudeStream(worker.stdoutPath);
+  const heartbeat = parseHeartbeat(worker.heartbeatPath);
+  const alive = isPidAlive(worker.pid);
+  const stdoutBytes = fileSize(worker.stdoutPath);
+  const stderrBytes = fileSize(worker.stderrPath);
+  const heartbeatBytes = fileSize(worker.heartbeatPath);
+  const changedFiles = gitStatusShort(worker.worktreePath);
+  const lastActivityAt = latestIso([
+    parsed.lastEventAt,
+    heartbeat.lastHeartbeatAt,
+    fileMtime(worker.stdoutPath),
+    fileMtime(worker.stderrPath),
+    fileMtime(worker.heartbeatPath)
+  ]);
+  const attention = computeAttention({
+    alive,
+    finalResult: parsed.finalResult,
+    firstEventAt: parsed.firstEventAt,
+    stdoutBytes,
+    heartbeatBytes,
+    lastActivityAt,
+    heartbeatBlocker: heartbeat.heartbeatBlocker,
+    startedAt: worker.startedAt
+  });
+  return {
+    runId: worker.runId,
+    worker: worker.name,
+    pid: worker.pid,
+    alive,
+    status: parsed.finalResult ? "done" : alive ? "running" : "exited",
+    attention,
+    branch: worker.branch,
+    worktreePath: worker.worktreePath,
+    ownedPaths: worker.ownedPaths,
+    stdoutBytes,
+    stderrBytes,
+    heartbeatBytes,
+    firstEventAt: parsed.firstEventAt,
+    lastEventAt: parsed.lastEventAt,
+    lastActivityAt,
+    currentTool: parsed.currentTool,
+    heartbeatCount: heartbeat.heartbeatCount,
+    lastHeartbeatAt: heartbeat.lastHeartbeatAt,
+    lastHeartbeatPhase: heartbeat.lastHeartbeatPhase,
+    lastHeartbeatSummary: heartbeat.lastHeartbeatSummary,
+    heartbeatBlocker: heartbeat.heartbeatBlocker,
+    finalResult: parsed.finalResult,
+    error: parsed.error || (!alive && !parsed.finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0),
+    changedFiles
+  };
+}
+function isFinishedWorkerStatus(status) {
+  if (status.finalResult) return true;
+  if (status.alive === false) return true;
+  if (status.status === "exited" || status.status === "done") return true;
+  return false;
+}
+function deriveRunStatus(fallback, workers) {
+  if (workers.length === 0) return fallback;
+  if (workers.some((w) => w.attention === "needs_attention" || w.attention === "stale" || w.attention === "blocked")) {
+    return "needs_attention";
+  }
+  if (workers.every((w) => w.status === "done")) return "done";
+  if (workers.some((w) => w.status === "running")) return "running";
+  return fallback;
+}
+
+// src/resource-gate.ts
+var DEFAULT_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
+var DEFAULT_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
+var DEFAULT_MEM_UTILIZATION = 0.85;
+var AUTO_MAX_WORKERS_CEILING = 64;
+function positiveInt(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+function resolveResourceConfig(config = loadUserConfig(), configuredMaxWorkersOverride) {
+  const perWorkerMemBytes = positiveInt(config.perWorkerMemBytes, DEFAULT_PER_WORKER_MEM_BYTES);
+  const memReserveBytes = positiveInt(config.memReserveBytes, DEFAULT_MEM_RESERVE_BYTES);
+  const memUtilization = Math.min(
+    1,
+    Math.max(0.1, Number(config.memUtilization) > 0 ? Number(config.memUtilization) : DEFAULT_MEM_UTILIZATION)
+  );
+  const envCap = process.env.KYNVER_MAX_WORKERS ? positiveInt(process.env.KYNVER_MAX_WORKERS, 0) || null : null;
+  const configuredMaxWorkers = configuredMaxWorkersOverride !== void 0 ? configuredMaxWorkersOverride : envCap ?? (config.maxConcurrentWorkers !== void 0 && config.maxConcurrentWorkers !== null ? positiveInt(config.maxConcurrentWorkers, 0) || null : null);
+  return { perWorkerMemBytes, memReserveBytes, memUtilization, configuredMaxWorkers };
+}
+function computeAutoMaxWorkers(totalMemBytes, opts = {}) {
+  const perWorkerMemBytes = opts.perWorkerMemBytes ?? DEFAULT_PER_WORKER_MEM_BYTES;
+  const memReserveBytes = opts.memReserveBytes ?? DEFAULT_MEM_RESERVE_BYTES;
+  const memUtilization = opts.memUtilization ?? DEFAULT_MEM_UTILIZATION;
+  const budgetBytes = Math.max(0, Math.floor(totalMemBytes * memUtilization) - memReserveBytes);
+  const raw = Math.max(1, Math.floor(budgetBytes / perWorkerMemBytes));
+  return Math.min(raw, AUTO_MAX_WORKERS_CEILING);
+}
+function countActiveWorkers(runId) {
+  const run = loadRun(runId);
+  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
+    );
+    if (!worker) continue;
+    const status = computeWorkerStatus(worker);
+    if (status.alive && !status.finalResult && status.attention.state !== "done") {
+      active++;
+    }
+  }
+  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 budgetBytes = Math.max(0, Math.floor(totalMemBytes * memUtilization) - memReserveBytes);
+  const capacityFromTotal = Math.max(0, Math.floor(budgetBytes / perWorkerMemBytes));
+  const capacityFromFree = Math.max(0, Math.floor(Math.max(0, freeMemBytes - memReserveBytes) / perWorkerMemBytes));
+  const autoCap = computeAutoMaxWorkers(totalMemBytes, { perWorkerMemBytes, memReserveBytes, memUtilization });
+  const targetCap = configuredMaxWorkers ?? autoCap;
+  const maxConcurrentWorkers = Math.max(0, Math.min(targetCap, capacityFromTotal));
+  const slotsByCapacity = Math.max(0, maxConcurrentWorkers - activeWorkers);
+  const slotsByFreeMem = Math.max(0, capacityFromFree - activeWorkers);
+  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) {
+      reason = "insufficient free memory \u2014 waiting for workers to finish";
+    } else {
+      reason = "no worker slots available";
+    }
+  }
+  return {
+    ok: slotsAvailable > 0,
+    totalMemBytes,
+    freeMemBytes,
+    memReserveBytes,
+    perWorkerMemBytes,
+    configuredMaxWorkers,
+    autoCap,
+    capacityWorkers: capacityFromTotal,
+    maxConcurrentWorkers,
+    activeWorkers,
+    slotsAvailable,
+    reason
+  };
+}
+
+// src/supervisor.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "node:fs";
+import path6 from "node:path";
+
+// src/prompt.ts
+function buildPrompt(input) {
+  const ownership = input.ownedPaths.length ? `Owned paths: ${input.ownedPaths.join(", ")}. Do not edit outside these paths without stopping and reporting why.` : "Owned paths: unrestricted for this worker, but keep edits tightly scoped.";
+  return [
+    "You are running under the Kynver AgentOS runtime.",
+    "Immediately state your plan before editing.",
+    ownership,
+    `Worktree: ${input.worktreePath}`,
+    `Progress heartbeat file: ${input.heartbeatPath}`,
+    "After each major step, append one JSON line to the heartbeat file with fields: ts, phase, summary, changedFiles, blocker.",
+    "Final response must include files changed, verification commands, and unresolved risks.",
+    "",
+    "Task:",
+    input.task
+  ].join("\n");
+}
+
+// src/providers/claude.ts
+import { closeSync, openSync } from "node:fs";
+import { spawn } from "node:child_process";
+var claudeProvider = {
+  name: "claude",
+  start(opts) {
+    const model = opts.model || "claude-opus-4-7";
+    const stdoutFd = openSync(opts.stdoutPath, "a");
+    const stderrFd = openSync(opts.stderrPath, "a");
+    const child = spawn(
+      "claude",
+      [
+        "--model",
+        model,
+        "-p",
+        "--verbose",
+        "--permission-mode",
+        "bypassPermissions",
+        "--output-format",
+        "stream-json",
+        "--include-partial-messages",
+        opts.prompt
+      ],
+      {
+        cwd: opts.worktreePath,
+        detached: true,
+        stdio: ["ignore", stdoutFd, stderrFd],
+        env: scrubClaudeEnv(process.env)
+      }
+    );
+    closeSync(stdoutFd);
+    closeSync(stderrFd);
+    if (!child.pid) {
+      throw new Error("failed to spawn claude worker process (is the `claude` CLI on PATH?)");
+    }
+    child.unref();
+    return { pid: child.pid, model };
+  }
+};
+
+// src/providers/registry.ts
+var BUILTIN = {
+  claude: claudeProvider
+};
+var overrideProvider = null;
+function resolveWorkerProvider(name) {
+  if (overrideProvider) return overrideProvider;
+  const configured = (name || loadUserConfig().workerProvider || "claude").trim();
+  const provider = BUILTIN[configured];
+  if (!provider) {
+    throw new Error(`unknown worker provider "${configured}" \u2014 supported: ${Object.keys(BUILTIN).join(", ")}`);
+  }
+  return provider;
+}
+
+// src/supervisor.ts
+function spawnWorkerProcess(run, opts) {
+  const name = safeSlug(opts.name);
+  if (!opts.name) throw new Error("worker name is required");
+  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();
+  const workerDir = path6.join(runDirectory(run.id), "workers", name);
+  mkdirSync3(workerDir, { recursive: true });
+  const worktreePath = path6.join(worktreesDir, run.id, name);
+  const branch = opts.branch || `agent/${run.id}/${name}`;
+  if (existsSync6(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 = path6.join(workerDir, "stdout.jsonl");
+  const stderrPath = path6.join(workerDir, "stderr.log");
+  const heartbeatPath = path6.join(workerDir, "heartbeat.jsonl");
+  const prompt = buildPrompt({
+    task: opts.task,
+    ownedPaths: opts.ownedPaths || [],
+    worktreePath,
+    heartbeatPath
+  });
+  const provider = resolveWorkerProvider(opts.provider);
+  let started;
+  try {
+    started = provider.start({
+      name,
+      task: opts.task,
+      ownedPaths: opts.ownedPaths,
+      model: opts.model,
+      branch,
+      worktreePath,
+      workerDir,
+      stdoutPath,
+      stderrPath,
+      heartbeatPath,
+      prompt
+    });
+  } catch (error) {
+    git(run.repo, ["worktree", "remove", "--force", worktreePath], { allowFailure: true });
+    git(run.repo, ["branch", "-D", branch], { allowFailure: true });
+    throw error;
+  }
+  const model = started.model || opts.model || "claude-opus-4-7";
+  const worker = {
+    name,
+    runId: run.id,
+    status: "running",
+    pid: started.pid,
+    model,
+    branch,
+    worktreePath,
+    workerDir,
+    stdoutPath,
+    stderrPath,
+    heartbeatPath,
+    ownedPaths: opts.ownedPaths,
+    ...opts.agentOsId ? { agentOsId: String(opts.agentOsId) } : {},
+    ...opts.taskId ? { taskId: String(opts.taskId) } : {},
+    ...opts.leaseOwner ? { leaseOwner: String(opts.leaseOwner) } : {},
+    ...opts.dispatched ? { dispatched: true } : {},
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveWorker(run.id, worker);
+  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path6.join(workerDir, "worker.json") } };
+  run.status = "running";
+  saveRun(run);
+  return worker;
+}
+function startWorker(args) {
+  const run = loadRun(String(args.run));
+  const task = args.task ? String(args.task) : readMaybeFile(args.taskFile ? String(args.taskFile) : void 0);
+  if (!task) {
+    console.error("missing --task or --task-file");
+    process.exit(1);
+  }
+  try {
+    const worker = spawnWorkerProcess(run, {
+      name: String(args.name),
+      task,
+      ownedPaths: args.owned ? String(args.owned).split(",").map((s) => s.trim()).filter(Boolean) : [],
+      model: args.model ? String(args.model) : void 0,
+      branch: args.branch ? String(args.branch) : void 0,
+      agentOsId: args.agentOsId ? String(args.agentOsId) : void 0,
+      taskId: args.taskId ? String(args.taskId) : void 0,
+      provider: args.provider ? String(args.provider) : void 0
+    });
+    console.log(
+      JSON.stringify(
+        {
+          runId: run.id,
+          worker: worker.name,
+          pid: worker.pid,
+          branch: worker.branch,
+          worktreePath: worker.worktreePath,
+          workerDir: worker.workerDir
+        },
+        null,
+        2
+      )
+    );
+  } catch (error) {
+    console.error(`worker start failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// src/dispatch.ts
+var DEFAULT_DISPATCH_LEASE_MS = 60 * 60 * 1e3;
+function buildDispatchTaskText(task, agentOsId) {
+  return [
+    `[AgentOS task ${task.id}] ${task.title}`,
+    "",
+    task.description ? String(task.description) : "(no description on the board task)",
+    "",
+    `Board linkage: agentOsId=${agentOsId}, taskId=${task.id}, attempt=${task.attempt}, executor=${task.executor}${task.executorRef ? `, executorRef=${task.executorRef}` : ""}.`,
+    "This worker was dispatched from the AgentOS board. The harness reports your completion back to the board when you finish."
+  ].join("\n");
+}
+async function dispatchRun(args) {
+  const pipeline = args.pipeline === true || args.pipeline === "true";
+  try {
+    const run = loadRun(String(required(String(args.run || ""), "--run")));
+    const agentOsId = String(required(String(args.agentOsId || ""), "--agent-os-id"));
+    const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+    const secret = resolveCallbackSecret(args.secret ? String(args.secret) : void 0);
+    const execute = args.execute === true || args.execute === "true";
+    const dryRun = !execute;
+    const leaseOwner = `openclaw-harness:${run.id}`;
+    const runnerDiskGate = args.diskPath ? observeRunnerDiskGate({ diskPath: String(args.diskPath) }) : observeRunnerDiskGate({ diskPath: run.repo });
+    const runnerResourceGate = observeRunnerResourceGate({ runId: run.id });
+    const requestedStarts = Number(args.maxStarts) > 0 ? Math.floor(Number(args.maxStarts)) : 1;
+    const cappedStarts = dryRun ? requestedStarts : Math.min(requestedStarts, runnerResourceGate.slotsAvailable);
+    const dispatchUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/dispatch-next`;
+    const body = {
+      agentOsId,
+      dryRun,
+      maxStarts: cappedStarts,
+      leaseOwner,
+      leaseDurationMs: Number(args.leaseMs) > 0 ? Math.floor(Number(args.leaseMs)) : DEFAULT_DISPATCH_LEASE_MS,
+      runnerDiskGate,
+      runnerResourceGate,
+      ...args.lane ? { lane: String(args.lane) } : {},
+      ...args.diskPath ? { diskPath: String(args.diskPath) } : {}
+    };
+    const dispatch = await postJson(dispatchUrl, secret, body);
+    const responseBody = dispatch.response;
+    if (!dispatch.ok || !responseBody?.result) {
+      const failure = {
+        runId: run.id,
+        agentOsId,
+        action: "dispatch",
+        httpStatus: dispatch.status,
+        response: dispatch.response
+      };
+      if (pipeline) return { ok: false, ...failure };
+      console.log(JSON.stringify(failure, null, 2));
+      process.exit(1);
+    }
+    const result = responseBody.result;
+    if (dryRun) {
+      const summary2 = {
+        runId: run.id,
+        agentOsId,
+        dryRun: true,
+        wouldStart: result.started.map((d) => ({
+          taskId: d.task.id,
+          title: d.task.title,
+          reason: d.reason
+        })),
+        skipped: result.skipped.map(
+          (d) => ({ taskId: d.task.id, skipReason: d.skipReason, reason: d.reason })
+        ),
+        diskGate: result.diskGate,
+        resourceGate: result.resourceGate,
+        inspected: result.inspected
+      };
+      if (pipeline) return { ok: true, ...summary2 };
+      console.log(JSON.stringify(summary2, null, 2));
+      return;
+    }
+    if (!dryRun && cappedStarts <= 0) {
+      const summary2 = {
+        runId: run.id,
+        agentOsId,
+        dryRun: false,
+        skipped: true,
+        reason: runnerResourceGate.reason ?? "no resource slots",
+        resourceGate: runnerResourceGate
+      };
+      if (pipeline) return { ok: true, ...summary2 };
+      console.log(JSON.stringify(summary2, null, 2));
+      return;
+    }
+    const outcomes = [];
+    for (const decision of result.started) {
+      const task = decision.task;
+      const name = safeSlug(`t-${task.id}-a${task.attempt}`);
+      try {
+        const worker = spawnWorkerProcess(run, {
+          name,
+          task: buildDispatchTaskText(task, agentOsId),
+          ownedPaths: args.owned ? String(args.owned).split(",").map((s) => s.trim()).filter(Boolean) : [],
+          model: args.model ? String(args.model) : void 0,
+          agentOsId,
+          taskId: String(task.id),
+          leaseOwner,
+          dispatched: true
+        });
+        outcomes.push({
+          taskId: task.id,
+          started: true,
+          worker: worker.name,
+          pid: worker.pid,
+          branch: worker.branch
+        });
+      } catch (error) {
+        const releaseUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(String(task.id))}/release`;
+        let release;
+        try {
+          release = await postJson(releaseUrl, secret, { agentOsId, leaseOwner });
+        } catch (relErr) {
+          release = { ok: false, error: relErr.message };
+        }
+        outcomes.push({
+          taskId: task.id,
+          started: false,
+          error: error.message,
+          released: release.ok === true || release.response?.ok === true,
+          releaseResponse: release.response ?? release
+        });
+      }
+    }
+    const summary = {
+      runId: run.id,
+      agentOsId,
+      dryRun: false,
+      leaseOwner,
+      startedCount: outcomes.filter((o) => o.started).length,
+      outcomes,
+      skipped: result.skipped.map((d) => ({
+        taskId: d.task.id,
+        skipReason: d.skipReason
+      })),
+      diskGate: result.diskGate,
+      resourceGate: result.resourceGate
+    };
+    if (pipeline) {
+      return { ok: !outcomes.some((o) => !o.started), ...summary };
+    }
+    console.log(JSON.stringify(summary, null, 2));
+    if (outcomes.some((o) => !o.started)) process.exit(1);
+  } catch (error) {
+    if (pipeline) return { ok: false, error: error.message };
+    console.error(`run dispatch failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// src/redact.ts
+function redactHarness(text, secret) {
+  let out = text;
+  if (secret) out = out.split(secret).join("[REDACTED_SECRET]");
+  out = out.replace(/kynver_[a-z0-9_]+/gi, "[REDACTED_KYNVER_TOKEN]");
+  out = out.replace(/sk-[a-zA-Z0-9_-]+/g, "[REDACTED_API_KEY]");
+  return out;
+}
+
+// src/validate.ts
+import path7 from "node:path";
+var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
+var WORKER_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
+function validateRunId(runId) {
+  const trimmed = runId.trim();
+  if (!RUN_ID_RE.test(trimmed)) throw new Error(`invalid run id: ${runId}`);
+  return trimmed;
+}
+function validateWorkerName(name) {
+  const trimmed = name.trim();
+  if (!WORKER_NAME_RE.test(trimmed)) throw new Error(`invalid worker name: ${name}`);
+  return trimmed;
+}
+function validateRepo(repo) {
+  const resolved = path7.resolve(repo);
+  if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
+  return resolved;
+}
+function validateOwnedPaths(repoRoot, ownedPaths) {
+  return ownedPaths.map((owned) => {
+    const resolved = path7.resolve(repoRoot, owned);
+    const rel = path7.relative(repoRoot, resolved);
+    if (rel.startsWith("..") || path7.isAbsolute(rel)) {
+      throw new Error(`owned path escapes repo: ${owned}`);
+    }
+    return resolved;
+  });
+}
+function validateTailLines(lines) {
+  if (!Number.isFinite(lines) || lines <= 0 || lines > 500) return 40;
+  return Math.floor(lines);
+}
+
+// src/worktree.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync4 } from "node:fs";
+import path8 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 (existsSync7(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();
+  const run = {
+    id,
+    name: String(args.name || id),
+    repo,
+    base,
+    baseCommit,
+    status: "created",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workers: {}
+  };
+  writeJson(path8.join(dir, "run.json"), run);
+  console.log(JSON.stringify({ runId: id, runDir: dir, repo, base, baseCommit }, null, 2));
+}
+function listRuns() {
+  const { runsDir } = getPaths();
+  const rows = listRunIds(runsDir).map((id) => readJson(path8.join(runDirectory(id), "run.json"), null)).filter(Boolean).map((run) => ({
+    id: run.id,
+    name: run.name,
+    status: run.status,
+    repo: run.repo,
+    createdAt: run.createdAt
+  }));
+  console.log(JSON.stringify(rows, null, 2));
+}
+function failExists(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+// src/sweep.ts
+import path9 from "node:path";
+async function sweepRun(args) {
+  const pipeline = args.pipeline === true || args.pipeline === "true";
+  try {
+    const run = loadRun(String(required(String(args.run || ""), "--run")));
+    const agentOsId = String(required(String(args.agentOsId || ""), "--agent-os-id"));
+    const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+    const secret = resolveCallbackSecret(args.secret ? String(args.secret) : void 0);
+    const leaseOwner = `openclaw-harness:${run.id}`;
+    const releasedLocalOrphans = [];
+    for (const name of Object.keys(run.workers || {})) {
+      const worker = readJson(
+        path9.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        null
+      );
+      if (!worker || !worker.dispatched || !worker.taskId) continue;
+      const status = computeWorkerStatus(worker);
+      if (status.alive) continue;
+      if (status.finalResult) continue;
+      const releaseUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/${encodeURIComponent(String(worker.taskId))}/release`;
+      let release;
+      try {
+        release = await postJson(releaseUrl, secret, { agentOsId, leaseOwner });
+      } catch (relErr) {
+        release = { ok: false, error: relErr.message };
+      }
+      releasedLocalOrphans.push({
+        worker: name,
+        taskId: worker.taskId,
+        pid: worker.pid,
+        released: release.ok === true || release.response?.ok === true,
+        response: release.response ?? release
+      });
+    }
+    const reapUrl = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/tasks/reap`;
+    let reap;
+    try {
+      reap = await postJson(reapUrl, secret, {
+        agentOsId,
+        ...Number(args.graceMs) >= 0 && args.graceMs !== void 0 && args.graceMs !== true ? { graceMs: Math.floor(Number(args.graceMs)) } : {}
+      });
+    } catch (reapErr) {
+      reap = { ok: false, error: reapErr.message };
+    }
+    const summary = { runId: run.id, agentOsId, leaseOwner, releasedLocalOrphans, reap: reap.response ?? reap };
+    if (pipeline) return { ok: true, ...summary };
+    console.log(JSON.stringify(summary, null, 2));
+  } catch (error) {
+    if (pipeline) return { ok: false, error: error.message };
+    console.error(`run sweep failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// src/worker-ops.ts
+import path10 from "node:path";
+async function tryCompleteWorker(args) {
+  const worker = loadWorker(String(args.run), String(args.name));
+  const status = computeWorkerStatus(worker);
+  const agentOsId = (args.agentOsId ? String(args.agentOsId) : worker.agentOsId) || "";
+  const taskId = (args.taskId ? String(args.taskId) : worker.taskId) || null;
+  if (!agentOsId) {
+    return { ok: false, reason: "missing agentOsId" };
+  }
+  if (!isFinishedWorkerStatus(status)) {
+    return { ok: true, skipped: true, reason: "worker-not-finished" };
+  }
+  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+  const secret = resolveCallbackSecret(args.secret ? String(args.secret) : void 0);
+  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/harness/completion`;
+  const body = {
+    source: "openclaw-harness",
+    agentOsId,
+    runId: worker.runId,
+    workerName: worker.name,
+    taskId,
+    startedAt: worker.startedAt,
+    finishedAt: status.lastActivityAt || (/* @__PURE__ */ new Date()).toISOString(),
+    status
+  };
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-OpenClaw-Cron-Secret": secret,
+      "X-Kynver-Runtime-Secret": secret
+    },
+    body: JSON.stringify(body)
+  });
+  let parsed = null;
+  try {
+    parsed = await res.json();
+  } catch {
+    parsed = null;
+  }
+  return { ok: res.ok, httpStatus: res.status, response: parsed };
+}
+async function completeWorker(args) {
+  try {
+    const worker = loadWorker(String(args.run), String(args.name));
+    const status = computeWorkerStatus(worker);
+    const agentOsId = (args.agentOsId ? String(args.agentOsId) : worker.agentOsId) || "";
+    const taskId = (args.taskId ? String(args.taskId) : worker.taskId) || null;
+    if (!agentOsId) {
+      console.error("worker complete requires --agent-os-id (or an agentOsId persisted at worker start)");
+      process.exit(1);
+    }
+    if (!isFinishedWorkerStatus(status)) {
+      console.log(
+        JSON.stringify(
+          {
+            worker: worker.name,
+            runId: worker.runId,
+            status: "skipped",
+            reason: "worker-not-finished",
+            workerStatus: status.status,
+            alive: status.alive
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const result = await tryCompleteWorker(args);
+    console.log(
+      JSON.stringify(
+        {
+          worker: worker.name,
+          runId: worker.runId,
+          agentOsId,
+          taskId,
+          httpStatus: result.httpStatus,
+          response: result.response
+        },
+        null,
+        2
+      )
+    );
+    if (!result.ok) process.exit(1);
+  } catch (error) {
+    console.error(`worker complete failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+function workerStatus(args) {
+  const worker = loadWorker(String(args.run), String(args.name));
+  const status = computeWorkerStatus(worker);
+  writeJson(path10.join(worker.workerDir, "last-status.json"), status);
+  console.log(JSON.stringify(status, null, 2));
+}
+function runStatus(args) {
+  const run = loadRun(String(args.run));
+  const names = Object.keys(run.workers || {});
+  const workers = names.map((name) => {
+    const worker = readJson(
+      path10.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      null
+    );
+    if (!worker) {
+      return { worker: name, status: "missing", attention: "needs_attention", attentionReason: "worker.json not found" };
+    }
+    const status = computeWorkerStatus(worker);
+    return {
+      worker: status.worker,
+      status: status.status,
+      attention: status.attention.state,
+      attentionReason: status.attention.reason,
+      pid: status.pid,
+      alive: status.alive,
+      currentTool: status.currentTool,
+      lastActivityAt: status.lastActivityAt,
+      lastHeartbeatPhase: status.lastHeartbeatPhase,
+      lastHeartbeatSummary: status.lastHeartbeatSummary,
+      heartbeatBlocker: status.heartbeatBlocker,
+      changedFileCount: status.changedFiles.length,
+      branch: status.branch
+    };
+  });
+  const board = {
+    runId: run.id,
+    name: run.name,
+    status: deriveRunStatus(run.status, workers),
+    repo: run.repo,
+    workerCount: workers.length,
+    needsAttention: workers.filter((w) => w.attention && w.attention !== "ok" && w.attention !== "done").map((w) => w.worker),
+    workers
+  };
+  writeJson(path10.join(runDirectory(run.id), "last-board.json"), board);
+  console.log(JSON.stringify(board, null, 2));
+}
+function tailWorker(args) {
+  const worker = loadWorker(String(args.run), String(args.name));
+  const raw = tailFile(worker.stdoutPath, Number(args.lines || 40));
+  if (args.raw === true || args.raw === "true") {
+    process.stdout.write(raw);
+    return;
+  }
+  for (const line of raw.split("\n").filter(Boolean)) {
+    const event = safeJson(line);
+    const summary = event ? summarizeEvent(event) : line;
+    if (summary) console.log(summary);
+  }
+}
+function stopWorker(args) {
+  const worker = loadWorker(String(args.run), String(args.name));
+  if (!isPidAlive(worker.pid)) {
+    console.log(JSON.stringify({ worker: worker.name, pid: worker.pid, status: "not_running" }, null, 2));
+    return;
+  }
+  killWorkerProcess(worker.pid, "SIGTERM");
+  sleepMs(1500);
+  if (isPidAlive(worker.pid)) {
+    killWorkerProcess(worker.pid, "SIGKILL");
+    console.log(JSON.stringify({ worker: worker.name, pid: worker.pid, status: "sigkill_sent" }, null, 2));
+    return;
+  }
+  console.log(JSON.stringify({ worker: worker.name, pid: worker.pid, status: "stopped" }, null, 2));
+}
+
+// src/cli.ts
+import { mkdirSync as mkdirSync5 } from "node:fs";
+import path12 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/pipeline-tick.ts
+import path11 from "node:path";
+
+// src/workspace-runtime-config.ts
+async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
+  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+  const secret = resolveCallbackSecret(args.secret ? String(args.secret) : void 0);
+  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/runtime`;
+  try {
+    const res = await getJson(url, secret);
+    if (!res.ok) return null;
+    const body = res.response;
+    const raw = body?.preferences?.maxConcurrentWorkers;
+    if (raw === null || raw === void 0) {
+      return { maxConcurrentWorkers: null };
+    }
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0) return { maxConcurrentWorkers: null };
+    return { maxConcurrentWorkers: Math.floor(n) };
+  } catch {
+    return null;
+  }
+}
+
+// src/pipeline-tick.ts
+async function completeFinishedWorkers(runId, args) {
+  const run = loadRun(runId);
+  const outcomes = [];
+  for (const name of Object.keys(run.workers || {})) {
+    const worker = readJson(
+      path11.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      null
+    );
+    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,
+      agentOsId: String(args.agentOsId || worker.agentOsId || ""),
+      ...args
+    });
+    outcomes.push({ worker: name, ok: result.ok, taskId: worker.taskId ?? null });
+  }
+  return outcomes;
+}
+async function postOperatorTick(agentOsId, runId, resourceGate, args) {
+  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+  const secret = resolveCallbackSecret(args.secret ? String(args.secret) : void 0);
+  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/operator/tick`;
+  const res = await postJson(url, secret, {
+    agentOsId,
+    runId,
+    ingestHarness: true,
+    resourceGate
+  });
+  return { ok: res.ok, httpStatus: res.status, response: res.response };
+}
+async function runPipelineTick(args) {
+  const runId = String(required(String(args.run || ""), "--run"));
+  const agentOsId = String(required(String(args.agentOsId || ""), "--agent-os-id"));
+  const execute = args.execute !== false && args.execute !== "false";
+  runStatus({ run: runId });
+  const completedWorkers = await completeFinishedWorkers(runId, args);
+  const workspacePrefs = await fetchWorkspaceRuntimePreferences(agentOsId, args);
+  const resourceGate = observeRunnerResourceGate({
+    runId,
+    configuredMaxWorkersOverride: workspacePrefs?.maxConcurrentWorkers
+  });
+  const operatorTick = await postOperatorTick(agentOsId, runId, resourceGate, args);
+  let maxStarts = resourceGate.slotsAvailable;
+  const tickBody = operatorTick;
+  const advised = tickBody.response?.dispatch?.recommendedMaxStarts;
+  if (typeof advised === "number") {
+    maxStarts = Math.min(maxStarts, Math.max(0, advised));
+  }
+  const sweep = await sweepRun({ run: runId, agentOsId, pipeline: true, ...args });
+  let dispatch = null;
+  if (execute && maxStarts > 0) {
+    dispatch = await dispatchRun({
+      run: runId,
+      agentOsId,
+      execute: true,
+      maxStarts: String(maxStarts),
+      pipeline: true,
+      ...args
+    });
+  } else {
+    dispatch = {
+      ok: true,
+      skipped: true,
+      reason: execute ? resourceGate.reason ?? "no slots or queued work" : "execute disabled",
+      maxStarts: 0
+    };
+  }
+  const startedCount = dispatch?.startedCount ?? 0;
+  const idle = maxStarts === 0 && completedWorkers.length === 0 && startedCount === 0;
+  return {
+    runId,
+    agentOsId,
+    execute,
+    resourceGate,
+    completedWorkers,
+    operatorTick,
+    sweep,
+    dispatch,
+    idle
+  };
+}
+
+// src/daemon.ts
+var DEFAULT_INTERVAL_MS = 6e4;
+var IDLE_INTERVAL_MS = 5 * 6e4;
+var MAX_IDLE_STREAK = 10;
+async function runDaemon(args) {
+  const runId = String(required(String(args.run || ""), "--run"));
+  const agentOsId = String(required(String(args.agentOsId || loadUserConfig().agentOsId || ""), "--agent-os-id"));
+  const execute = args.execute !== false && args.execute !== "false";
+  const intervalMs = Number(args.intervalMs) > 0 ? Math.floor(Number(args.intervalMs)) : DEFAULT_INTERVAL_MS;
+  let stopping = false;
+  let idleStreak = 0;
+  process.on("SIGINT", () => {
+    stopping = true;
+  });
+  process.on("SIGTERM", () => {
+    stopping = true;
+  });
+  console.error(JSON.stringify({ event: "daemon_start", runId, agentOsId, execute, intervalMs }));
+  while (!stopping) {
+    try {
+      const tick = await runPipelineTick({ run: runId, agentOsId, execute, ...args });
+      console.error(JSON.stringify({ event: "daemon_tick", ...tick }));
+      if (tick.idle) {
+        idleStreak++;
+      } else {
+        idleStreak = 0;
+      }
+      const backoff = idleStreak >= MAX_IDLE_STREAK ? IDLE_INTERVAL_MS : intervalMs;
+      sleepMs(backoff);
+    } catch (error) {
+      console.error(JSON.stringify({ event: "daemon_tick_error", error: error.message }));
+      sleepMs(intervalMs);
+    }
+  }
+  console.error(JSON.stringify({ event: "daemon_stop", runId, agentOsId }));
+}
+
+// src/cli.ts
+function isHelpFlag(arg) {
+  return arg === "help" || arg === "--help" || arg === "-h";
+}
+function unknownCommand(scope, action) {
+  const cmd = [scope, action].filter(Boolean).join(" ");
+  console.error(`unknown command: ${cmd || "(none)"}`);
+  usage(1);
+}
+function usage(code = 0) {
+  const out = code === 0 ? console.log : console.error;
+  out(
+    [
+      "Usage:",
+      "  kynver login --api-key KEY",
+      "  kynver setup [--api-base-url URL] [--agent-os-id ID] [--agent-os-slug SLUG] [--repo PATH] [--max-workers N]",
+      "  kynver daemon --run RUN_ID --agent-os-id AOS_ID [--execute] [--interval-ms MS]",
+      "  kynver run create --repo /path/repo [--name name] [--base origin/main]",
+      "  kynver run list",
+      "  kynver run status --run RUN_ID",
+      "  kynver run dispatch --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--execute] [--lane any|implementation|review|landing] [--max-starts 1] [--lease-ms MS] [--owned path[,path]] [--model claude-opus-4-7] [--disk-path /]",
+      "  kynver run sweep --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--grace-ms MS]",
+      '  kynver worker start --run RUN_ID --name worker --task "..." [--owned path[,path]] [--model claude-opus-4-7] [--agent-os-id AOS_ID] [--task-id TASK_ID]',
+      "  kynver worker status --run RUN_ID --name worker",
+      "  kynver worker tail --run RUN_ID --name worker [--lines 40] [--raw]",
+      "  kynver worker stop --run RUN_ID --name worker",
+      "  kynver worker complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--task-id TASK_ID] [--base-url URL] [--secret SECRET]"
+    ].join("\n")
+  );
+  process.exit(code);
+}
+async function main(argv = process.argv.slice(2)) {
+  if (argv.length === 0 || isHelpFlag(argv[0])) return usage(0);
+  const scope = argv.shift();
+  const action = argv.shift();
+  const args = parseArgs(argv);
+  const { runsDir, worktreesDir } = getPaths();
+  mkdirSync5(runsDir, { recursive: true });
+  mkdirSync5(worktreesDir, { recursive: true });
+  if (scope === "login") return void await runLogin(args);
+  if (scope === "setup") return void await runSetup(args);
+  if (scope === "daemon") return void await runDaemon(args);
+  if (scope === "run" && action === "create") return createRun(args);
+  if (scope === "run" && action === "list") return listRuns();
+  if (scope === "run" && action === "status") return runStatus(args);
+  if (scope === "run" && action === "dispatch") return void await dispatchRun(args);
+  if (scope === "run" && action === "sweep") return void await sweepRun(args);
+  if (scope === "worker" && action === "start") return startWorker(args);
+  if (scope === "worker" && action === "status") return workerStatus(args);
+  if (scope === "worker" && action === "tail") return tailWorker(args);
+  if (scope === "worker" && action === "stop") return stopWorker(args);
+  if (scope === "worker" && action === "complete") return void await completeWorker(args);
+  unknownCommand(scope, action);
+}
+var isCliEntry = process.argv[1] && path12.resolve(process.argv[1]) === path12.resolve(fileURLToPath(import.meta.url));
+if (isCliEntry) {
+  void main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+export {
+  DEFAULT_DISPATCH_LEASE_MS,
+  buildDispatchTaskText,
+  buildPrompt,
+  completeWorker,
+  computeAttention,
+  computeWorkerStatus,
+  createRun,
+  deriveRunStatus,
+  dispatchRun,
+  getHarnessPaths,
+  isFinishedWorkerStatus,
+  listRuns,
+  loadUserConfig,
+  main,
+  observeRunnerDiskGate,
+  parseArgs,
+  parseClaudeStream,
+  parseHeartbeat,
+  postJson,
+  redactHarness,
+  resolveBaseUrl,
+  resolveCallbackSecret,
+  resolveHarnessRoot,
+  runDaemon,
+  runStatus,
+  saveUserConfig,
+  spawnWorkerProcess,
+  startWorker,
+  stopWorker,
+  summarizeEvent,
+  sweepRun,
+  tailWorker,
+  usage,
+  validateOwnedPaths,
+  validateRepo,
+  validateRunId,
+  validateTailLines,
+  validateWorkerName,
+  workerStatus
+};
+//# sourceMappingURL=index.js.map