@kynver-app/runtime 0.1.16 → 0.1.18

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { mkdirSync as mkdirSync5, realpathSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/config.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -392,12 +392,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 path15 = input.diskPath?.trim() || "/";
+  const path16 = 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(path15);
+  const stats = statfsSync(path16);
   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;
@@ -417,7 +417,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path15,
+    path: path16,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -604,6 +604,52 @@ function summarizeEvent(event) {
   return void 0;
 }
 
+// src/exit-classify.ts
+var FAILURE_PATTERNS = [
+  {
+    test: /\b(?:invalid|unknown|unsupported|unrecognized)\b[^.\n]*\bmodel\b/i,
+    label: "provider rejected the requested model"
+  },
+  {
+    test: /\bmodel\b[^.\n]*\b(?:not\s+(?:found|supported|available|recognized|valid)|is\s+not\s+valid|does\s+not\s+exist)/i,
+    label: "provider rejected the requested model"
+  },
+  {
+    test: /\b(?:did you mean|available models|choose (?:a|one of)|supported models)\b/i,
+    label: "provider rejected the requested model"
+  },
+  {
+    test: /model preflight failed/i,
+    label: "model/provider preflight failed"
+  },
+  {
+    test: /\b(?:command not found|ENOENT|is the .*CLI on PATH|executable not found|no such file or directory)\b/i,
+    label: "provider CLI is missing or not on PATH"
+  },
+  {
+    test: /\bfailed to spawn\b/i,
+    label: "provider failed to spawn the worker process"
+  },
+  {
+    test: /\b(?:not logged in|unauthorized|authentication (?:failed|required)|invalid api key|missing api key|401)\b/i,
+    label: "provider authentication failed"
+  }
+];
+function tidy(errorText, max = 240) {
+  const oneLine2 = errorText.replace(/\s+/g, " ").trim();
+  return oneLine2.length > max ? `${oneLine2.slice(0, max - 1)}\u2026` : oneLine2;
+}
+function classifyExitFailure(errorText) {
+  const text = (errorText ?? "").trim();
+  if (!text) return null;
+  for (const pattern of FAILURE_PATTERNS) {
+    if (pattern.test.test(text)) {
+      return { blocked: true, reason: `${pattern.label}: ${tidy(text)}` };
+    }
+  }
+  return null;
+}
+
 // src/git.ts
 import { spawnSync } from "node:child_process";
 function git(cwd, args, options = {}) {
@@ -719,7 +765,15 @@ 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.alive) {
+    const classified = classifyExitFailure(input.error);
+    if (classified) return { state: "blocked", reason: classified.reason };
+    const tail = input.error?.trim();
+    return {
+      state: "needs_attention",
+      reason: tail ? `process exited without a final result: ${tail}` : "process exited without a final result"
+    };
+  }
   if (input.heartbeatBlocker) {
     return { state: "blocked", reason: `worker heartbeat reported blocker: ${input.heartbeatBlocker}` };
   }
@@ -749,6 +803,7 @@ function computeWorkerStatus(worker, options = {}) {
     fileMtime(worker.stderrPath),
     fileMtime(worker.heartbeatPath)
   ]);
+  const error = parsed.error || (!alive && !parsed.finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0);
   const attention = computeAttention({
     alive,
     finalResult: parsed.finalResult,
@@ -757,7 +812,8 @@ function computeWorkerStatus(worker, options = {}) {
     heartbeatBytes,
     lastActivityAt,
     heartbeatBlocker: heartbeat.heartbeatBlocker,
-    startedAt: worker.startedAt
+    startedAt: worker.startedAt,
+    error
   });
   return {
     runId: worker.runId,
@@ -782,7 +838,7 @@ function computeWorkerStatus(worker, options = {}) {
     lastHeartbeatSummary: heartbeat.lastHeartbeatSummary,
     heartbeatBlocker: heartbeat.heartbeatBlocker,
     finalResult: parsed.finalResult,
-    error: parsed.error || (!alive && !parsed.finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0),
+    error,
     changedFiles,
     gitAncestry
   };
@@ -907,8 +963,8 @@ function observeRunnerResourceGate(input) {
 }
 
 // src/supervisor.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3 } from "node:fs";
+import path9 from "node:path";
 
 // src/prompt.ts
 function buildPrompt(input) {
@@ -942,10 +998,74 @@ function buildPrompt(input) {
 // src/providers/claude.ts
 import { closeSync, openSync } from "node:fs";
 import { spawn } from "node:child_process";
+
+// src/providers/model-preflight.ts
+var REASONING_SUFFIX_RE = /-(?:thinking(?:-(?:high|medium|low|minimal|max|none))?|high|medium|low|minimal)$/i;
+function stripReasoningSuffix(model) {
+  return model.replace(REASONING_SUFFIX_RE, "");
+}
+var FOREIGN_MODEL_RE = /^(?:gpt-|gpt5|o1|o3|o4|gemini-|grok-|composer|deepseek|llama|mistral|qwen|command-)/i;
+function looksLikeClaudeModel(model) {
+  return /^claude[-_]/i.test(model) || /^(?:opus|sonnet|haiku)\b/i.test(model);
+}
+function preflightClaudeModel(model, defaultModel) {
+  const requested = (model ?? "").trim();
+  if (!requested) {
+    return { ok: true, model: defaultModel, normalized: false };
+  }
+  const stripped = stripReasoningSuffix(requested).trim();
+  const launch = stripped || defaultModel;
+  if (FOREIGN_MODEL_RE.test(launch) || !looksLikeClaudeModel(launch) && launch !== defaultModel) {
+    return {
+      ok: false,
+      model: requested,
+      normalized: false,
+      requested,
+      note: `model "${requested}" is not a Claude model \u2014 the "claude" provider drives the Claude CLI, which only accepts claude-* model ids (got "${launch}"). Pick a Claude model or switch the worker provider.`
+    };
+  }
+  if (launch !== requested) {
+    return {
+      ok: true,
+      model: launch,
+      normalized: true,
+      requested,
+      note: `normalized model "${requested}" \u2192 "${launch}" (the Claude CLI rejects reasoning-effort suffixes)`
+    };
+  }
+  return { ok: true, model: launch, normalized: false };
+}
+function preflightCursorModel(model, defaultModel) {
+  const requested = (model ?? "").trim();
+  if (!requested) {
+    return { ok: true, model: defaultModel, normalized: false };
+  }
+  if (looksLikeClaudeModel(requested)) {
+    return {
+      ok: false,
+      model: requested,
+      normalized: false,
+      requested,
+      note: `model "${requested}" is a Claude model but the worker provider is "cursor". Switch the provider to "claude" or pick a Cursor model.`
+    };
+  }
+  return { ok: true, model: requested, normalized: false };
+}
+
+// src/providers/claude.ts
+var CLAUDE_DEFAULT_MODEL = "claude-opus-4-7";
 var claudeProvider = {
   name: "claude",
+  defaultModel: CLAUDE_DEFAULT_MODEL,
+  preflightModel(model) {
+    return preflightClaudeModel(model, CLAUDE_DEFAULT_MODEL);
+  },
   start(opts) {
-    const model = opts.model || "claude-opus-4-7";
+    const preflight = preflightClaudeModel(opts.model, CLAUDE_DEFAULT_MODEL);
+    if (!preflight.ok) {
+      throw new Error(`claude provider model preflight failed: ${preflight.note}`);
+    }
+    const model = preflight.model;
     const stdoutFd = openSync(opts.stdoutPath, "a");
     const stderrFd = openSync(opts.stderrPath, "a");
     const child = spawn(
@@ -1021,8 +1141,16 @@ function resolveAgentBin() {
 }
 var cursorProvider = {
   name: "cursor",
+  defaultModel: DEFAULT_CURSOR_MODEL,
+  preflightModel(model) {
+    return preflightCursorModel(model, DEFAULT_CURSOR_MODEL);
+  },
   start(opts) {
-    const model = opts.model || DEFAULT_CURSOR_MODEL;
+    const preflight = preflightCursorModel(opts.model, DEFAULT_CURSOR_MODEL);
+    if (!preflight.ok) {
+      throw new Error(`cursor provider model preflight failed: ${preflight.note}`);
+    }
+    const model = preflight.model;
     const stdoutFd = openSync2(opts.stdoutPath, "a");
     const stderrFd = openSync2(opts.stderrPath, "a");
     const agentBin = resolveAgentBin();
@@ -1082,6 +1210,369 @@ function resolveWorkerProvider(name) {
   return provider;
 }
 
+// src/auto-complete.ts
+import { spawn as spawn3 } from "node:child_process";
+import { existsSync as existsSync8, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
+import path8 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/worker-ops.ts
+import path7 from "node:path";
+async function postCompletion(url, secret, body) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: buildHarnessCallbackHeaders(secret),
+    body: JSON.stringify(body)
+  });
+  let parsed = null;
+  try {
+    parsed = await res.json();
+  } catch {
+    parsed = null;
+  }
+  return { ok: res.ok, status: res.status, parsed };
+}
+function completionErrorText(parsed) {
+  if (parsed && typeof parsed === "object") {
+    const err = parsed.error;
+    if (typeof err === "string" && err.trim()) return err.trim();
+  }
+  return void 0;
+}
+function persistCompletionBlocker(worker, reason) {
+  const current = worker.completionBlocker;
+  if ((current ?? void 0) === (reason ?? void 0)) return;
+  if (reason) worker.completionBlocker = reason;
+  else delete worker.completionBlocker;
+  saveWorker(worker.runId, worker);
+}
+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 explicitSecret = args.secret ? String(args.secret) : void 0;
+  let secret = await resolveCallbackSecretWithMint(explicitSecret, agentOsId, { baseUrl: base });
+  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
+  };
+  let result = await postCompletion(url, secret, body);
+  if ((result.status === 401 || result.status === 403) && !explicitSecret) {
+    const refreshed = await refreshRunnerToken(agentOsId, { baseUrl: base });
+    if (refreshed && refreshed !== secret) {
+      secret = refreshed;
+      result = await postCompletion(url, secret, body);
+    }
+  }
+  if (result.ok) {
+    persistCompletionBlocker(worker, void 0);
+    return { ok: true, httpStatus: result.status, response: result.parsed };
+  }
+  const authRejected = result.status === 401 || result.status === 403;
+  const detail = completionErrorText(result.parsed) ?? (authRejected ? "runner token unauthorized" : "non-2xx response");
+  const reason = authRejected ? `completion replay rejected (${result.status}): ${detail}` : `completion replay failed (${result.status}): ${detail}`;
+  persistCompletionBlocker(worker, reason);
+  return { ok: false, httpStatus: result.status, response: result.parsed, completionBlocked: true };
+}
+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(path7.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(
+      path7.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      void 0
+    );
+    if (!worker) {
+      return { worker: name, status: "missing", attention: "needs_attention", attentionReason: "worker.json not found" };
+    }
+    const status = computeWorkerStatus(worker, { base: run.base });
+    const rawBlocker = worker.completionBlocker;
+    const completionBlocker = typeof rawBlocker === "string" && rawBlocker ? rawBlocker : void 0;
+    return {
+      worker: status.worker,
+      status: completionBlocker ? "blocked" : status.status,
+      attention: completionBlocker ? "blocked" : status.attention.state,
+      attentionReason: completionBlocker ?? 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,
+      ancestry: status.gitAncestry.relation,
+      ancestryChecked: status.gitAncestry.checked
+    };
+  });
+  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(path7.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/auto-complete.ts
+var DEFAULT_POLL_MS = 5e3;
+var DEFAULT_MAX_TOTAL_MS = 6 * 60 * 60 * 1e3;
+var DEFAULT_COMPLETE_ATTEMPTS = 3;
+var DEFAULT_COMPLETE_BACKOFF_MS = 5e3;
+function readArgs(raw) {
+  return {
+    run: String(raw.run || ""),
+    name: String(raw.name || ""),
+    agentOsId: raw.agentOsId ? String(raw.agentOsId) : void 0,
+    pollMs: Number(raw.pollMs) > 0 ? Math.floor(Number(raw.pollMs)) : void 0,
+    maxTotalMs: Number(raw.maxTotalMs) > 0 ? Math.floor(Number(raw.maxTotalMs)) : void 0,
+    completeAttempts: Number(raw.completeAttempts) > 0 ? Math.floor(Number(raw.completeAttempts)) : void 0,
+    completeBackoffMs: Number(raw.completeBackoffMs) > 0 ? Math.floor(Number(raw.completeBackoffMs)) : void 0,
+    baseUrl: raw.baseUrl ? String(raw.baseUrl) : void 0,
+    secret: raw.secret ? String(raw.secret) : void 0
+  };
+}
+async function autoCompleteWorker(raw) {
+  const args = readArgs(raw);
+  const pollMs = args.pollMs ?? DEFAULT_POLL_MS;
+  const maxTotalMs = args.maxTotalMs ?? DEFAULT_MAX_TOTAL_MS;
+  const completeAttempts = args.completeAttempts ?? DEFAULT_COMPLETE_ATTEMPTS;
+  const completeBackoffMs = args.completeBackoffMs ?? DEFAULT_COMPLETE_BACKOFF_MS;
+  const worker = loadWorker(args.run, args.name);
+  if (!worker.agentOsId || !worker.taskId) {
+    return {
+      worker: worker.name,
+      runId: worker.runId,
+      outcome: "missing_link",
+      attempts: 0,
+      reason: "worker has no agentOsId/taskId \u2014 nothing to attribute completion to"
+    };
+  }
+  const startMs = Date.now();
+  while (true) {
+    const status = computeWorkerStatus(worker);
+    if (isFinishedWorkerStatus(status)) break;
+    if (!isPidAlive(worker.pid)) break;
+    if (Date.now() - startMs > maxTotalMs) {
+      return {
+        worker: worker.name,
+        runId: worker.runId,
+        outcome: "timed_out",
+        attempts: 0,
+        reason: `worker did not finish within ${maxTotalMs}ms`
+      };
+    }
+    sleepMs(pollMs);
+  }
+  let lastHttpStatus;
+  let lastReason;
+  for (let attempt = 1; attempt <= completeAttempts; attempt++) {
+    const result = await tryCompleteWorker({
+      run: args.run,
+      name: args.name,
+      ...args.agentOsId ? { agentOsId: args.agentOsId } : {},
+      ...args.baseUrl ? { baseUrl: args.baseUrl } : {},
+      ...args.secret ? { secret: args.secret } : {}
+    });
+    lastHttpStatus = result.httpStatus;
+    if (result.ok) {
+      return {
+        worker: worker.name,
+        runId: worker.runId,
+        outcome: "completed",
+        httpStatus: result.httpStatus,
+        attempts: attempt
+      };
+    }
+    const authRejected = result.httpStatus === 401 || result.httpStatus === 403;
+    if (authRejected) {
+      lastReason = typeof result.reason === "string" ? result.reason : "completion replay refused";
+      return {
+        worker: worker.name,
+        runId: worker.runId,
+        outcome: "blocked",
+        httpStatus: result.httpStatus,
+        attempts: attempt,
+        reason: lastReason
+      };
+    }
+    lastReason = typeof result.reason === "string" ? result.reason : "transient failure";
+    if (attempt < completeAttempts) sleepMs(completeBackoffMs);
+  }
+  return {
+    worker: worker.name,
+    runId: worker.runId,
+    outcome: "blocked",
+    httpStatus: lastHttpStatus,
+    attempts: completeAttempts,
+    reason: lastReason ?? "completion failed after retries"
+  };
+}
+async function autoCompleteWorkerCli(raw) {
+  try {
+    const outcome = await autoCompleteWorker(raw);
+    console.log(JSON.stringify(outcome, null, 2));
+    if (outcome.outcome === "missing_link" || outcome.outcome === "timed_out") {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    console.error(`worker auto-complete failed: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+function resolveDefaultCliPath() {
+  return path8.join(fileURLToPath(new URL(".", import.meta.url)), "cli.js");
+}
+function spawnCompletionSidecar(opts) {
+  const cliPath = opts.cliPath ?? resolveDefaultCliPath();
+  if (!existsSync8(cliPath)) return void 0;
+  const logPath = path8.join(opts.workerDir, "auto-complete.log");
+  let logFd;
+  try {
+    logFd = openSync3(logPath, "a");
+  } catch {
+    logFd = void 0;
+  }
+  const stdio = [
+    "ignore",
+    logFd ?? "ignore",
+    logFd ?? "ignore"
+  ];
+  const nodeExecutable = opts.nodeExecutable ?? process.execPath;
+  const args = [
+    cliPath,
+    "worker",
+    "auto-complete",
+    "--run",
+    opts.runId,
+    "--name",
+    opts.workerName
+  ];
+  if (opts.agentOsId) args.push("--agent-os-id", opts.agentOsId);
+  if (opts.baseUrl) args.push("--base-url", opts.baseUrl);
+  if (opts.secret) args.push("--secret", opts.secret);
+  try {
+    const child = spawn3(nodeExecutable, args, {
+      detached: true,
+      stdio,
+      env: process.env
+    });
+    if (logFd !== void 0) closeSync3(logFd);
+    child.unref();
+    return { pid: child.pid, logPath, cliPath };
+  } catch {
+    if (logFd !== void 0) {
+      try {
+        closeSync3(logFd);
+      } catch {
+      }
+    }
+    return void 0;
+  }
+}
+
 // src/supervisor.ts
 function spawnWorkerProcess(run, opts) {
   const rawName = typeof opts.name === "string" ? opts.name.trim() : "";
@@ -1091,31 +1582,44 @@ function spawnWorkerProcess(run, opts) {
   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 provider = resolveWorkerProvider(opts.provider);
+  let launchModel = opts.model;
+  if (provider.preflightModel) {
+    const preflight = provider.preflightModel(opts.model);
+    if (!preflight.ok) {
+      throw new Error(
+        `model preflight failed for provider "${provider.name}": ${preflight.note ?? "invalid model/provider combination"}`
+      );
+    }
+    if (preflight.normalized) {
+      console.error(`[supervisor] ${name}: ${preflight.note}`);
+    }
+    launchModel = preflight.model;
+  }
   const { worktreesDir } = getPaths();
-  const workerDir = path7.join(runDirectory(run.id), "workers", name);
+  const workerDir = path9.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
-  const worktreePath = path7.join(worktreesDir, run.id, name);
+  const worktreePath = path9.join(worktreesDir, run.id, name);
   const branch = opts.branch || `agent/${run.id}/${name}`;
-  if (existsSync8(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
+  if (existsSync9(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");
-  const stderrPath = path7.join(workerDir, "stderr.log");
-  const heartbeatPath = path7.join(workerDir, "heartbeat.jsonl");
+  const stdoutPath = path9.join(workerDir, "stdout.jsonl");
+  const stderrPath = path9.join(workerDir, "stderr.log");
+  const heartbeatPath = path9.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,
+      model: launchModel,
       branch,
       worktreePath,
       workerDir,
@@ -1129,7 +1633,7 @@ function spawnWorkerProcess(run, opts) {
     git(run.repo, ["branch", "-D", branch], { allowFailure: true });
     throw error;
   }
-  const model = started.model || opts.model || "claude-opus-4-7";
+  const model = started.model || launchModel || provider.defaultModel || "claude-opus-4-7";
   const worker = {
     name,
     runId: run.id,
@@ -1151,9 +1655,20 @@ function spawnWorkerProcess(run, opts) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveWorker(run.id, worker);
-  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path7.join(workerDir, "worker.json") } };
+  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path9.join(workerDir, "worker.json") } };
   run.status = "running";
   saveRun(run);
+  if (worker.agentOsId && worker.taskId) {
+    try {
+      spawnCompletionSidecar({
+        runId: run.id,
+        workerName: name,
+        workerDir,
+        agentOsId: worker.agentOsId
+      });
+    } catch {
+    }
+  }
   return worker;
 }
 function startWorker(args) {
@@ -1354,7 +1869,7 @@ async function dispatchRun(args) {
 }
 
 // src/sweep.ts
-import path8 from "node:path";
+import path10 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -1366,7 +1881,7 @@ async function sweepRun(args) {
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path8.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path10.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
@@ -1409,11 +1924,11 @@ async function sweepRun(args) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4 } from "node:fs";
-import path10 from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
+import path12 from "node:path";
 
 // src/validate.ts
-import path9 from "node:path";
+import path11 from "node:path";
 var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 function validateRunId(runId) {
   const trimmed = runId.trim();
@@ -1421,7 +1936,7 @@ function validateRunId(runId) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path9.resolve(repo);
+  const resolved = path11.resolve(repo);
   if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
   return resolved;
 }
@@ -1432,7 +1947,7 @@ function createRun(args) {
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync9(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync10(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();
@@ -1446,12 +1961,12 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path10.join(dir, "run.json"), run);
+  writeJson(path12.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(path10.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
+  const rows = listRunIds(runsDir).map((id) => readJson(path12.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
     id: run.id,
     name: run.name,
     status: run.status,
@@ -1465,211 +1980,11 @@ function failExists(message) {
   process.exit(1);
 }
 
-// src/worker-ops.ts
-import path11 from "node:path";
-async function postCompletion(url, secret, body) {
-  const res = await fetch(url, {
-    method: "POST",
-    headers: buildHarnessCallbackHeaders(secret),
-    body: JSON.stringify(body)
-  });
-  let parsed = null;
-  try {
-    parsed = await res.json();
-  } catch {
-    parsed = null;
-  }
-  return { ok: res.ok, status: res.status, parsed };
-}
-function completionErrorText(parsed) {
-  if (parsed && typeof parsed === "object") {
-    const err = parsed.error;
-    if (typeof err === "string" && err.trim()) return err.trim();
-  }
-  return void 0;
-}
-function persistCompletionBlocker(worker, reason) {
-  const current = worker.completionBlocker;
-  if ((current ?? void 0) === (reason ?? void 0)) return;
-  if (reason) worker.completionBlocker = reason;
-  else delete worker.completionBlocker;
-  saveWorker(worker.runId, worker);
-}
-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 explicitSecret = args.secret ? String(args.secret) : void 0;
-  let secret = await resolveCallbackSecretWithMint(explicitSecret, agentOsId, { baseUrl: base });
-  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
-  };
-  let result = await postCompletion(url, secret, body);
-  if ((result.status === 401 || result.status === 403) && !explicitSecret) {
-    const refreshed = await refreshRunnerToken(agentOsId, { baseUrl: base });
-    if (refreshed && refreshed !== secret) {
-      secret = refreshed;
-      result = await postCompletion(url, secret, body);
-    }
-  }
-  if (result.ok) {
-    persistCompletionBlocker(worker, void 0);
-    return { ok: true, httpStatus: result.status, response: result.parsed };
-  }
-  const authRejected = result.status === 401 || result.status === 403;
-  const detail = completionErrorText(result.parsed) ?? (authRejected ? "runner token unauthorized" : "non-2xx response");
-  const reason = authRejected ? `completion replay rejected (${result.status}): ${detail}` : `completion replay failed (${result.status}): ${detail}`;
-  persistCompletionBlocker(worker, reason);
-  return { ok: false, httpStatus: result.status, response: result.parsed, completionBlocked: true };
-}
-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(path11.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(
-      path11.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
-      void 0
-    );
-    if (!worker) {
-      return { worker: name, status: "missing", attention: "needs_attention", attentionReason: "worker.json not found" };
-    }
-    const status = computeWorkerStatus(worker, { base: run.base });
-    const rawBlocker = worker.completionBlocker;
-    const completionBlocker = typeof rawBlocker === "string" && rawBlocker ? rawBlocker : void 0;
-    return {
-      worker: status.worker,
-      status: completionBlocker ? "blocked" : status.status,
-      attention: completionBlocker ? "blocked" : status.attention.state,
-      attentionReason: completionBlocker ?? 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,
-      ancestry: status.gitAncestry.relation,
-      ancestryChecked: status.gitAncestry.checked
-    };
-  });
-  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(path11.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/pipeline-tick.ts
-import path14 from "node:path";
+import path15 from "node:path";
 
 // src/finalize.ts
-import path12 from "node:path";
+import path13 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set(["running", "dispatching", "pending", "queued"]);
 function terminalStatusFor(run) {
   const names = Object.keys(run.workers || {});
@@ -1679,7 +1994,7 @@ function terminalStatusFor(run) {
   let anyCompletionBlocked = false;
   for (const name of names) {
     const worker = readJson(
-      path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path13.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) continue;
@@ -1712,7 +2027,7 @@ function finalizeStaleRuns() {
 }
 
 // src/plan-progress-daemon-sync.ts
-import path13 from "node:path";
+import path14 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -1736,7 +2051,7 @@ async function syncActiveWorkerPlanProgress(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"),
+      path14.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -1790,7 +2105,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path14.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path15.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId) continue;
@@ -2033,6 +2348,7 @@ function usage(code = 0) {
       "  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]",
+      "  kynver worker auto-complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--poll-ms 5000] [--max-total-ms 21600000] [--complete-attempts 3] [--complete-backoff-ms 5000] [--base-url URL] [--secret SECRET]",
       "  kynver plan progress --plan PLAN_ID --row ROW_KEY --role ROLE --status STATUS [--task TASK_ID] [--note NOTE] [--evidence type:value] [--agent-os-id AOS_ID]",
       "  kynver plan verify --plan PLAN_ID [--worktree PATH] [--task TASK_ID] [--human-override]"
     ].join("\n")
@@ -2071,9 +2387,10 @@ async function main(argv = process.argv.slice(2)) {
   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);
+  if (scope === "worker" && action === "auto-complete") return void await autoCompleteWorkerCli(args);
   unknownCommand(scope, action);
 }
-var isCliEntry = process.argv[1] && realpathSync.native(process.argv[1]) === realpathSync.native(fileURLToPath(import.meta.url));
+var isCliEntry = process.argv[1] && realpathSync.native(process.argv[1]) === realpathSync.native(fileURLToPath2(import.meta.url));
 if (isCliEntry) {
   void main().catch((error) => {
     console.error(error);