@sagentlab/navarch-runtime 0.1.44 → 0.1.46

package/README.md

@@ -490,7 +490,7 @@ set the standard `reasoning_effort` configuration option when it is available.
 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`.
+Codex defaults to `gpt-6-astra`; Claude Code defaults to `claude-opus-5`.
 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:
@@ -505,7 +505,7 @@ 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
+Explicitly selected 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
@@ -516,7 +516,7 @@ 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).
+Selecting Fable 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),

package/dist/adapters/claude.cjs

@@ -5,7 +5,7 @@ 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 DEFAULT_CLAUDE_MODEL = "claude-opus-5";
 const FALLBACK_CLAUDE_MODEL = "claude-opus-5";
 function hasFlag(args, flag) {
     return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
@@ -35,7 +35,7 @@ async function runClaudeCodeAdapter(options) {
         return { exitCode: null, timedOut: false, killedByLeaseLoss: true, stdout: "", stderr: "" };
     }
     const model = options.model ?? DEFAULT_CLAUDE_MODEL;
-    const automaticFallback = [DEFAULT_CLAUDE_MODEL, "fable"].includes(model) &&
+    const automaticFallback = ["claude-fable-5-1", "fable"].includes(model) &&
         !hasFlag(options.extraArgs, "--fallback-model");
     const startedAt = Date.now();
     const primary = await runClaudeAttempt({ ...options, model }, automaticFallback);

package/dist/git-worktree.cjs

@@ -56,6 +56,7 @@ class GitWorktree {
         await node_fs_1.promises.mkdir(this.sessionRoot, { recursive: true });
         await withRepositoryLock(this.repositoryPath, async () => {
             await this.ensureRepositoryCache();
+            await this.installDeliveryBranchGuard();
             try {
                 await this.addSessionWorktree();
             }
@@ -94,6 +95,22 @@ class GitWorktree {
         await node_fs_1.promises.chmod(configPath, 0o600);
         await node_fs_1.promises.appendFile(configPath, block, { encoding: "utf8", mode: 0o600 });
     }
+    /**
+     * Installs the delivery-branch guard shared by every worktree of this cache.
+     * The hook is inert unless the session exports `NAVARCH_DELIVERY_BRANCH`, so
+     * PR-continuation sessions that must push a reviewed PR's head branch are
+     * unaffected. Root tasks export the allocated `navarch/...` branch, which
+     * stops an agent from renaming the branch (e.g. Codex's default `codex/...`
+     * prefix) and stranding the PR on a branch the task does not own.
+     */
+    async installDeliveryBranchGuard(repositoryPath = this.repositoryPath) {
+        const hooksDir = node_path_1.default.join(repositoryPath, "hooks");
+        await node_fs_1.promises.mkdir(hooksDir, { recursive: true });
+        await node_fs_1.promises.writeFile(node_path_1.default.join(hooksDir, "pre-push"), DELIVERY_BRANCH_GUARD_HOOK, {
+            encoding: "utf8",
+            mode: 0o755,
+        });
+    }
     /** Clones the bare cache if missing, repoints origin if needed, and fetches all branches. */
     async ensureRepositoryCache() {
         if (!(await pathExists(node_path_1.default.join(this.repositoryPath, "HEAD")))) {
@@ -312,6 +329,8 @@ class GitWorktree {
             if (!/unknown option|usage: git worktree add/i.test(errorMessage(error)))
                 throw error;
             await this.runGit(["init", "--initial-branch", this.branch, this.worktreePath], false);
+            // This fallback is a standalone repository, so it does not share cache hooks.
+            await this.installDeliveryBranchGuard(node_path_1.default.join(this.worktreePath, ".git"));
             await this.runGit(["-C", this.worktreePath, "remote", "add", "origin", this.cloneUrl], false);
         }
     }
@@ -337,6 +356,30 @@ class GitWorktree {
             sha,
         };
     }
+    /**
+     * Resolves the head the session reports to the control plane after an agent
+     * turn.
+     *
+     * Root tasks own exactly one delivery branch. If an agent renamed or switched
+     * away from the allocated `navarch/...` branch, the worktree is moved back
+     * onto it so completion evidence and the PR land on the branch the task owns.
+     * PR-continuation tasks (review-fix, conflict resolution, stale-PR recovery)
+     * pass `allowRename` so they can check out and push the reviewed PR's head
+     * branch, which is the one case a different branch is expected.
+     */
+    async resolveDeliveryHead(allowRename) {
+        const head = await this.resolveCurrentHead();
+        if (allowRename || head.branch === this.branch)
+            return head;
+        try {
+            await this.runGit(["-C", this.worktreePath, "checkout", "-B", this.branch, "HEAD"], false);
+        }
+        catch (error) {
+            throw new Error(`Could not restore task delivery branch ${this.branch} after the agent left ` +
+                `${head.branch ?? "a detached HEAD"}: ${errorMessage(error)}`);
+        }
+        return { branch: this.branch, sha: head.sha };
+    }
     async cleanup() {
         await withRepositoryLock(this.repositoryPath, async () => {
             await this.removeRepoLocalGithubToken();
@@ -443,6 +486,32 @@ async function pathExists(value) {
         return false;
     }
 }
+/**
+ * Pre-push guard installed in the repository cache's hooks directory. When
+ * `NAVARCH_DELIVERY_BRANCH` is present it refuses to create, update, or delete
+ * any other branch, so a coding agent cannot move a root task's delivery off
+ * the allocated `navarch/...` branch (for example onto Codex's default
+ * `codex/...` prefix). `--no-verify` bypasses any hook, so
+ * `resolveDeliveryHead` also repairs the worktree before completion.
+ */
+const DELIVERY_BRANCH_GUARD_HOOK = `#!/bin/sh
+# Managed by @sagentlab/navarch-runtime (git-worktree.cts).
+allowed="\${NAVARCH_DELIVERY_BRANCH:-}"
+[ -n "$allowed" ] || exit 0
+status=0
+while read -r local_ref local_sha remote_ref remote_sha; do
+  case "$remote_ref" in
+    refs/heads/*) ;;
+    *) continue ;;
+  esac
+  branch="\${remote_ref#refs/heads/}"
+  if [ "$branch" != "$allowed" ]; then
+    printf '%s\\n' "navarch: refusing to push '$branch'; this task's delivery branch is '$allowed'." >&2
+    status=1
+  fi
+done
+exit "$status"
+`;
 /**
  * Kebab-case slug for the task branch, derived from the task summary so
  * branch names read like `navarch/fix-login-redirect-<task-id>` instead of a

package/dist/github-pr.cjs

@@ -85,7 +85,7 @@ async function findHeadBranchPullRequestUrl(options) {
         (!normalizedHeadSha ||
             (typeof candidate.head.sha === "string" &&
                 candidate.head.sha.toLowerCase() === normalizedHeadSha)));
-    if (branchMatch || !normalizedHeadSha)
+    if (branchMatch || !normalizedHeadSha || options.allowShaFallback === false)
         return branchMatch;
     const commitUrl = new URL(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/commits/${normalizedHeadSha}/pulls`);
     commitUrl.searchParams.set("per_page", "10");

package/dist/session.cjs

@@ -69,7 +69,7 @@ async function runSession(deps, claimed, sessionId) {
                     ? "auto"
                     : runtime === "opencode" || runtime === "acp"
                         ? "default"
-                        : "claude-fable-5-1",
+                        : "claude-opus-5",
             reasoning_effort: "medium",
         };
         const crashDetail = describeCompletionError(err).slice(0, 1800);
@@ -107,7 +107,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 ? "auto"
                 : runtime === "opencode" || runtime === "acp"
                     ? "default"
-                    : "claude-fable-5-1",
+                    : "claude-opus-5",
         reasoning_effort: "medium",
     };
     // Isolation posture reported on every completion so `sessions` records what
@@ -193,6 +193,11 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         githubToken,
         repoLocalGithubToken: secrets["github-pat"],
     });
+    // A root task owns one delivery branch, so the pre-push guard and the
+    // completion-time reconciliation keep the agent on the allocated
+    // `navarch/...` branch. PR-continuation tasks are the exception: their agent
+    // must check out and push the reviewed PR's existing head branch.
+    const allowBranchRename = Boolean(task.review_of_task_id);
     const knownGuidanceIds = new Set((bundle.guidance ?? []).map((entry) => entry.id));
     const deliveredGuidance = [...(bundle.guidance ?? [])];
     let guidanceCursor = bundle.guidance_cursor ?? null;
@@ -344,6 +349,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
     lifecycle.enteredMainSessionTry = true;
     try {
         await gitWorktree.prepare();
+        // Preparation may resume an existing task branch with an older slug or ID format.
+        if (!allowBranchRename)
+            sessionEnv.NAVARCH_DELIVERY_BRANCH = gitWorktree.branch;
         if (sandbox) {
             await sandbox.create();
             // Security-policy refusals (a mount outside the allowlist, an egress
@@ -435,7 +443,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             let headBranch = gitWorktree.branch;
             let headSha;
             try {
-                const currentHead = await gitWorktree.resolveCurrentHead();
+                const currentHead = await gitWorktree.resolveDeliveryHead(allowBranchRename);
                 headBranch = currentHead.branch ?? headBranch;
                 headSha = currentHead.sha;
             }
@@ -448,6 +456,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                     repository: bundle.repository?.full_name ?? task.repo,
                     headBranch,
                     headSha,
+                    // Keep SHA verification on the exact branch, but do not adopt a
+                    // foreign-branch PR as delivery evidence for a root task.
+                    allowShaFallback: allowBranchRename,
                     githubToken,
                 });
                 if (prUrl)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",