@kynver-app/runtime 0.1.17 → 0.1.18

package/dist/cli.js

@@ -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
   };
@@ -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();
@@ -1454,6 +1582,20 @@ 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 = path9.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
@@ -1471,14 +1613,13 @@ function spawnWorkerProcess(run, opts) {
     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,
@@ -1492,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,