@sagentlab/navarch-runtime 0.1.23 → 0.1.24

package/dist/git-worktree.cjs

@@ -119,7 +119,20 @@ class GitWorktree {
         // next session must resume that task-owned branch, not fork again from the
         // default branch and create a competing delivery PR.
         const taskRef = await this.resolveTaskBranchRef();
-        const startRef = taskRef ?? (await this.resolveStartRef());
+        // A killed session (timeout, SIGKILL, host crash) cannot guarantee its
+        // cleanup ran, and the janitor is age-gated, so a prompt retry on the same
+        // machine can meet the task branch still present in the shared cache.
+        // `worktree add -b` would fail on it, dooming every remaining attempt.
+        const staleTip = await this.reclaimStaleLocalBranch();
+        const baseRef = taskRef ?? (await this.resolveStartRef());
+        // The stale local tip may hold commits the killed session never pushed;
+        // resume it unless the pushed task branch has moved past it (then the
+        // remote is the durable record).
+        const startRef = staleTip
+            ? taskRef && !(await this.isAncestor(taskRef, staleTip))
+                ? taskRef
+                : staleTip
+            : baseRef;
         if (!startRef) {
             // Empty remote (no commits yet): there is nothing to base the session on,
             // so bootstrap an orphan branch the session can push as the first commit.
@@ -137,9 +150,75 @@ class GitWorktree {
             this.worktreePath,
             startRef,
         ], false);
-        if (!taskRef)
+        if (!taskRef && !staleTip)
             await this.createTaskOwnershipCommit();
     }
+    /**
+     * Releases a leftover local task branch (and any dead worktree holding it)
+     * so a retry can recreate the branch, and returns the leftover tip for
+     * resume. One lease per task means no live session can hold this branch, but
+     * a same-named branch without the ownership marker is not ours to delete.
+     */
+    async reclaimStaleLocalBranch() {
+        const localRef = `refs/heads/${this.branch}`;
+        const tip = await this.runner.run("git", [
+            "--git-dir",
+            this.repositoryPath,
+            "rev-parse",
+            "--verify",
+            "--quiet",
+            `${localRef}^{commit}`,
+        ]);
+        const staleSha = tip.stdout.trim();
+        if (tip.code !== 0 || !/^[0-9a-f]{40,64}$/i.test(staleSha))
+            return null;
+        const owned = this.branch.endsWith(this.legacyTaskBranchSuffix) ||
+            (await this.hasTaskOwnershipMarker(localRef));
+        if (!owned) {
+            throw new Error(`Local branch ${this.branch} already exists in the cached repository but does not ` +
+                `contain ownership marker ${this.taskOwnershipTrailer}; refusing to reuse or delete it.`);
+        }
+        await this.removeWorktreesCheckedOutOn(localRef);
+        try {
+            await this.runGit(["--git-dir", this.repositoryPath, "branch", "-D", this.branch], false);
+        }
+        catch (error) {
+            throw new Error(`Could not release stale task branch ${this.branch} left by an earlier session: ${errorMessage(error)}`);
+        }
+        return staleSha;
+    }
+    async removeWorktreesCheckedOutOn(localRef) {
+        const list = await this.runGit(["--git-dir", this.repositoryPath, "worktree", "list", "--porcelain"], false);
+        let currentPath = null;
+        const holders = [];
+        for (const line of list.stdout.split("\n")) {
+            if (line.startsWith("worktree "))
+                currentPath = line.slice("worktree ".length).trim();
+            else if (line.startsWith("branch ") && line.slice("branch ".length).trim() === localRef && currentPath)
+                holders.push(currentPath);
+        }
+        for (const holder of holders) {
+            // Double --force covers locked and submodule-bearing worktrees.
+            await this.runner
+                .run("git", ["--git-dir", this.repositoryPath, "worktree", "remove", "--force", "--force", holder])
+                .catch(() => undefined);
+        }
+        await this.runner
+            .run("git", ["--git-dir", this.repositoryPath, "worktree", "prune"])
+            .catch(() => undefined);
+    }
+    /** True when `descendant` contains `ancestorRef`; ref-resolution failures count as false. */
+    async isAncestor(ancestorRef, descendant) {
+        const result = await this.runner.run("git", [
+            "--git-dir",
+            this.repositoryPath,
+            "merge-base",
+            "--is-ancestor",
+            ancestorRef,
+            descendant,
+        ]);
+        return result.code === 0;
+    }
     /** Returns the fetched task-owned remote branch when an earlier attempt pushed it. */
     async resolveTaskBranchRef() {
         const refs = await this.runGit(["--git-dir", this.repositoryPath, "for-each-ref", "--format=%(refname)", "refs/remotes/origin/navarch"], false);
@@ -261,14 +340,18 @@ class GitWorktree {
     async cleanup() {
         await withRepositoryLock(this.repositoryPath, async () => {
             await this.removeRepoLocalGithubToken();
+            // Double --force covers locked and submodule-bearing worktrees, and
+            // pruning before the branch delete clears the checkout registration when
+            // the worktree directory is already gone; otherwise git refuses the
+            // delete and the leftover branch blocks the task's next retry.
             await this.runner
-                .run("git", ["--git-dir", this.repositoryPath, "worktree", "remove", "--force", this.worktreePath])
+                .run("git", ["--git-dir", this.repositoryPath, "worktree", "remove", "--force", "--force", this.worktreePath])
                 .catch(() => undefined);
             await this.runner
-                .run("git", ["--git-dir", this.repositoryPath, "branch", "-D", this.branch])
+                .run("git", ["--git-dir", this.repositoryPath, "worktree", "prune"])
                 .catch(() => undefined);
             await this.runner
-                .run("git", ["--git-dir", this.repositoryPath, "worktree", "prune"])
+                .run("git", ["--git-dir", this.repositoryPath, "branch", "-D", this.branch])
                 .catch(() => undefined);
         });
     }

package/dist/session.cjs

@@ -504,8 +504,15 @@ async function runSession(deps, claimed, sessionId) {
         clearInterval(heartbeatTimer);
         activeAbortController?.abort();
         secrets = {};
-        if (sandbox)
-            await sandbox.stop();
+        // A sandbox teardown failure must not skip worktree cleanup: a leftover
+        // task branch in the shared cache blocks the task's next retry.
+        try {
+            if (sandbox)
+                await sandbox.stop();
+        }
+        catch (stopErr) {
+            log.warn(`sandbox stop failed during teardown: ${String(stopErr)}`);
+        }
         await gitWorktree.cleanup();
         await node_fs_1.promises.rm(workDir, { recursive: true, force: true }).catch(() => undefined);
     }

package/package.json

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