@sagentlab/navarch-runtime 0.1.38 → 0.1.39

package/README.md

@@ -473,6 +473,39 @@ account's selection.
 Machine-wide extra arguments still configure other CLI behavior; dispatched
 model policy wins.
 
+Codex defaults to `gpt-6-astra`; Claude Code defaults to `claude-fable-5-1`.
+Explicit project and `steering/navarch.yaml` model choices still win. A task's
+explicit execution profile wins over the repository's per-task-type profile.
+Otherwise, claim-time classification uses the task summary and metadata:
+
+- Clearly scoped typo, spelling, link, wording, or label fixes use `fast` / `low`.
+- Planning, retries, video work, tasks with at least three dependencies,
+  production operations, and descriptions indicating architectural or sensitive
+  changes use `complex` / `high`.
+- Ambiguous work uses `standard` / the project effort baseline (`medium` by default).
+
+The classifier is deterministic and conservative; it never chooses `critical`
+or `deep` automatically. Set an explicit profile to override its assessment.
+Existing explicit task profiles remain explicit.
+
+Fable sessions pass `--fallback-model claude-opus-5` for Claude Code's native
+[availability fallback](https://code.claude.com/docs/en/model-config#fallback-model-chains).
+Because native fallback excludes usage limits, a structured 429 usage-limit
+rejection gets one additional Opus attempt within the original timeout. It
+resumes the saved conversation, or starts afresh only for a confirmed zero-turn
+rejection. Missing transcripts after possible work, authentication/policy
+errors, cancellation, and explicit fallback/session arguments do not trigger
+that retry. If Opus is also limited, the usual machine cooldown applies.
+The runtime records the fallback in the transcript and reports Opus for the
+retry and subsequent turns. Native multi-model turns still report the requested
+primary model; their aggregate provider-reported usage includes both models.
+Requires a Claude Code version supporting Fable 5.1 (v2.1.255 or later).
+
+Astra token cost reporting uses a standard short-context API-equivalent
+estimate from [OpenAI pricing](https://developers.openai.com/api/docs/pricing),
+not the account's subscription charge or long-context/fast-mode uplifts.
+
+
 The Codex CLI invocation was verified against `codex-cli 0.144.1` on
 2026-07-18. The runtime uses `codex exec "<prompt>" --json` and translates
 the existing per-session MCP JSON into one-off `-c mcp_servers.*` overrides.

package/dist/adapters/claude.cjs

@@ -4,6 +4,12 @@ exports.claudeCodeAdapter = void 0;
 exports.runClaudeCodeAdapter = runClaudeCodeAdapter;
 const node_child_process_1 = require("node:child_process");
 const exit_conditions_cjs_1 = require("../exit-conditions.cjs");
+const adapter_capacity_cjs_1 = require("../adapter-capacity.cjs");
+const DEFAULT_CLAUDE_MODEL = "claude-fable-5-1";
+const FALLBACK_CLAUDE_MODEL = "claude-opus-5";
+function hasFlag(args, flag) {
+    return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
 /**
  * Headless Claude Code adapter (project-plan.md §3.9 / implementation-plan.md
  * WP-07): `claude -p "<context bundle>" --mcp-config platform-mcp.json
@@ -25,6 +31,65 @@ const exit_conditions_cjs_1 = require("../exit-conditions.cjs");
  * default) rather than throwing -- see runtime/README.md.
  */
 async function runClaudeCodeAdapter(options) {
+    if (options.signal?.aborted) {
+        return { exitCode: null, timedOut: false, killedByLeaseLoss: true, stdout: "", stderr: "" };
+    }
+    const model = options.model ?? DEFAULT_CLAUDE_MODEL;
+    const automaticFallback = [DEFAULT_CLAUDE_MODEL, "fable"].includes(model) &&
+        !hasFlag(options.extraArgs, "--fallback-model");
+    const startedAt = Date.now();
+    const primary = await runClaudeAttempt({ ...options, model }, automaticFallback);
+    const remainingMs = options.timeoutMs - (Date.now() - startedAt);
+    if (!automaticFallback || primary.timedOut || primary.killedByLeaseLoss ||
+        options.signal?.aborted || remainingMs <= 0)
+        return primary;
+    const parsed = (0, exit_conditions_cjs_1.parseClaudeJsonResult)(primary.stdout) ?? (0, exit_conditions_cjs_1.parseClaudeJsonResult)(primary.stderr);
+    // Native fallback handles overload/unavailability, but explicitly excludes
+    // 429 usage limits. Try Opus once; if the limit is account-wide, the ordinary
+    // capacity cooldown still sees the fallback's failure.
+    if (!parsed?.is_error || !(0, adapter_capacity_cjs_1.detectAdapterCapacityLimit)(primary))
+        return primary;
+    const canResume = typeof parsed.session_id === "string" &&
+        /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(parsed.session_id) &&
+        !hasFlag(options.extraArgs, "--no-session-persistence");
+    // Never replay a task that may already have side effects without its saved
+    // conversation. A structured zero-turn rejection is safe to start afresh.
+    if (!canResume && parsed.num_turns !== 0)
+        return primary;
+    if (["--resume", "-r", "--continue", "-c", "--session-id", "--fork-session"].some((flag) => hasFlag(options.extraArgs, flag)))
+        return primary;
+    const fallback = await runClaudeAttempt({
+        ...options,
+        model: FALLBACK_CLAUDE_MODEL,
+        timeoutMs: remainingMs,
+        prompt: canResume
+            ? "Continue the interrupted task from the saved conversation. Check existing work before taking further action."
+            : options.prompt,
+        extraArgs: canResume
+            ? [...options.extraArgs, "--resume", parsed.session_id]
+            : options.extraArgs,
+    }, false);
+    return {
+        ...fallback,
+        model: FALLBACK_CLAUDE_MODEL,
+        // Keep the provider rejection in the transcript without letting the old
+        // JSON result override the final attempt's exit condition/capacity signal.
+        stderr: [
+            `Navarch model fallback: ${model} -> ${FALLBACK_CLAUDE_MODEL}`,
+            ...primary.stderr.split("\n").map((line) => `Primary stderr: ${line}`),
+            ...primary.stdout.split("\n").map((line) => `Primary stdout: ${line}`),
+            fallback.stderr,
+        ].join("\n"),
+        tokensIn: addUsage(primary.tokensIn, fallback.tokensIn),
+        tokensOut: addUsage(primary.tokensOut, fallback.tokensOut),
+        cacheHitTokensIn: addUsage(primary.cacheHitTokensIn, fallback.cacheHitTokensIn),
+        costUsd: addUsage(primary.costUsd, fallback.costUsd),
+    };
+}
+function addUsage(first, second) {
+    return first === undefined && second === undefined ? undefined : (first ?? 0) + (second ?? 0);
+}
+async function runClaudeAttempt(options, automaticFallback) {
     const args = ["-p", options.prompt];
     const hasSettingSources = options.extraArgs.some((arg) => arg === "--setting-sources" || arg.startsWith("--setting-sources="));
     const hasExplicitPermissionMode = options.extraArgs.some((arg) => ["--permission-mode", "--permission-prompt-tool", "--dangerously-skip-permissions"].some((flag) => arg === flag || arg.startsWith(`${flag}=`)));
@@ -76,6 +141,8 @@ async function runClaudeCodeAdapter(options) {
     // dispatched session consistently uses the settings recorded by Navarch.
     if (options.model)
         args.push("--model", options.model);
+    if (automaticFallback)
+        args.push("--fallback-model", FALLBACK_CLAUDE_MODEL);
     if (options.reasoningEffort)
         args.push("--effort", options.reasoningEffort);
     const runOptions = options.reasoningEffort

package/dist/codex-pricing.cjs

@@ -7,14 +7,23 @@ exports.estimateCodexCostUsd = estimateCodexCostUsd;
  * usage into project spend. Keep this deliberately limited to models Navarch
  * offers rather than silently applying the wrong price to custom/gateway ids.
  *
- * Source (checked 2026-08-05): https://developers.openai.com/api/docs/pricing
+ * Source (checked 2026-09-07): https://developers.openai.com/api/docs/pricing
  */
 const CODEX_RATES = {
+    // Standard short-context estimate, verified 2026-09-07 against the pricing
+    // source above. As with other runtime estimates, this excludes tier uplifts.
+    "gpt-6-astra": {
+        input: 10,
+        cachedInput: 1,
+        cacheWrite: 12.5,
+        output: 50,
+    },
+    // Promotional standard rates, available at least through 2026-11-21.
     "gpt-5.6-sol": {
-        input: 5,
-        cachedInput: 0.5,
-        cacheWrite: 6.25,
-        output: 30,
+        input: 4,
+        cachedInput: 0.4,
+        cacheWrite: 5,
+        output: 20,
     },
 };
 function nonnegative(value) {

package/dist/session.cjs

@@ -64,12 +64,12 @@ async function runSession(deps, claimed, sessionId) {
         const execution = bundle.execution ?? {
             profile: task.execution_profile ?? "standard",
             model: runtime === "codex"
-                ? "gpt-5.6-sol"
+                ? "gpt-6-astra"
                 : runtime === "gemini"
                     ? "auto"
                     : runtime === "opencode"
                         ? "default"
-                        : "best",
+                        : "claude-fable-5-1",
             reasoning_effort: "medium",
         };
         const crashDetail = describeCompletionError(err).slice(0, 1800);
@@ -102,12 +102,12 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
     const execution = bundle.execution ?? {
         profile: task.execution_profile ?? "standard",
         model: runtime === "codex"
-            ? "gpt-5.6-sol"
+            ? "gpt-6-astra"
             : runtime === "gemini"
                 ? "auto"
                 : runtime === "opencode"
                     ? "default"
-                    : "best",
+                    : "claude-fable-5-1",
         reasoning_effort: "medium",
     };
     // Isolation posture reported on every completion so `sessions` records what
@@ -118,7 +118,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         sandbox_profile: config.sandboxMode === "docker" ? config.sandboxProfile : "host",
         ...(config.sandboxMode === "docker" ? { sandbox_image: config.dockerImage } : {}),
     };
-    const executionReport = {
+    let executionReport = {
         model: execution.model,
         execution_profile: execution.profile,
         reasoning_effort: execution.reasoning_effort,
@@ -397,6 +397,10 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 signal: activeAbortController.signal,
             });
             activeAbortController = null;
+            if (turnResult.model) {
+                execution.model = turnResult.model;
+                executionReport = { ...executionReport, model: turnResult.model };
+            }
             attempts.push(turnResult);
             const capacityLimit = (0, adapter_capacity_cjs_1.detectAdapterCapacityLimit)(turnResult);
             if (capacityLimit) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through Claude Code, Codex, Gemini, or OpenCode.",
   "type": "commonjs",
   "license": "MIT",