@sagentlab/navarch-runtime 0.1.44 → 0.1.45

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

@@ -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.45",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",