@sagentlab/navarch-runtime 0.1.22 → 0.1.24

package/dist/exit-conditions.cjs

@@ -5,6 +5,7 @@ exports.extractUsageFromClaudeJson = extractUsageFromClaudeJson;
 exports.parseCodexJsonEvents = parseCodexJsonEvents;
 exports.extractUsageFromCodexEvents = extractUsageFromCodexEvents;
 exports.extractFinalMessageFromCodexEvents = extractFinalMessageFromCodexEvents;
+exports.leadingVerificationVerdict = leadingVerificationVerdict;
 exports.mapExitCondition = mapExitCondition;
 /**
  * Best-effort parse of `claude -p --output-format json` stdout into the
@@ -158,6 +159,21 @@ function extractFinalMessageFromCodexEvents(events) {
     }
     return null;
 }
+/**
+ * Parses the leading `Verification verdict:` line convention shared with the
+ * control plane (lib/navarch/verification-verdict.ts). Verify completions
+ * must open with `Verification verdict: PASS|FAIL|BLOCKED`, and the
+ * completion API rejects a completion whose verdict contradicts its lease
+ * outcome, keeping the lease active.
+ */
+function leadingVerificationVerdict(report) {
+    const firstLine = report
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+    const match = /^Verification verdict:\s*(PASS|FAIL|BLOCKED)\b/i.exec(firstLine ?? "");
+    return match?.[1] ? match[1].toLowerCase() : null;
+}
 function summarize(text, maxLen = 500) {
     const trimmed = text.trim();
     if (!trimmed)
@@ -234,6 +250,19 @@ function mapExitCondition(result) {
     // parseClaudeJsonResult's doc comment).
     const reportText = result.reportText ?? parsedJson?.result ?? result.stdout;
     const reportSummary = summarize(reportText) || "Adapter completed with no report text.";
+    // A verify agent's FAIL/BLOCKED verdict is a successful agent run whose
+    // conclusion is that the delivery did not pass. The completion API only
+    // accepts those verdicts with a failed outcome, so map them to a failed
+    // lease instead of posting a "completed" the control plane must reject.
+    const verdict = leadingVerificationVerdict(reportText);
+    if (verdict === "fail" || verdict === "blocked") {
+        return {
+            leaseOutcome: "failed",
+            exitStatus: "failed",
+            reportSummary,
+            evidenceUrls,
+        };
+    }
     // Headless agent CLIs normally exit 0 after producing a final response,
     // including when that response says the task could not start. Treat an
     // explicit leading blocked verdict as a failed lease so the dispatcher can

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

@@ -107,7 +107,7 @@ async function runSession(deps, claimed, sessionId) {
         const failureSummary = `Project ${task.project_id} has no GitHub repository URL. Set it in Project settings before dispatching work.`;
         await api.completeLease(leaseId, {
             status: "failed",
-            report: failureSummary,
+            report: verificationFailureReport(task.task_type, failureSummary),
             failure_summary: failureSummary,
             evidence_urls: [],
             cost: { tokens_in: 0, tokens_out: 0, cost_usd: 0 },
@@ -181,7 +181,7 @@ async function runSession(deps, claimed, sessionId) {
         await api
             .completeLease(leaseId, {
             status: "failed",
-            report: "Docker sandbox unavailable on this machine.",
+            report: verificationFailureReport(task.task_type, "Docker sandbox unavailable on this machine."),
             failure_summary: "Docker sandbox unavailable on this machine.",
             evidence_urls: [],
             cost: { tokens_in: 0, tokens_out: 0, cost_usd: 0 },
@@ -395,9 +395,12 @@ async function runSession(deps, claimed, sessionId) {
                 // redact it like every other warn in this block.
                 log.warn(`transcript upload failed for ${leaseId}: ${(0, redact_cjs_1.redactText)(String(err), knownSecrets)}`);
             }
+            const redactedReport = (0, redact_cjs_1.redactText)(mapping.reportSummary, knownSecrets);
             const completion = {
                 status: mapping.leaseOutcome,
-                report: (0, redact_cjs_1.redactText)(mapping.reportSummary, knownSecrets),
+                report: mapping.leaseOutcome === "failed"
+                    ? verificationFailureReport(task.task_type, redactedReport)
+                    : redactedReport,
                 evidence_urls: mapping.evidenceUrls,
                 cost: {
                     ...(result.tokensIn !== undefined ? { tokens_in: result.tokensIn } : {}),
@@ -448,9 +451,9 @@ async function runSession(deps, claimed, sessionId) {
                     await api.completeLease(leaseId, {
                         ...completion,
                         status: "failed",
-                        report: remediable
+                        report: verificationFailureReport(task.task_type, remediable
                             ? redactedRejection
-                            : `${redactedRejection}\n\n---\n\n${completion.report}`,
+                            : `${redactedRejection}\n\n---\n\n${completion.report}`),
                         failure_summary: redactedRejection,
                         exit_status: "failed",
                     });
@@ -482,9 +485,9 @@ async function runSession(deps, claimed, sessionId) {
         await api
             .completeLease(leaseId, {
             status: "failed",
-            report: lastCompletion
+            report: verificationFailureReport(task.task_type, lastCompletion
                 ? `${lastCompletion.report}\n\n---\n\n${failureSummary}`
-                : failureSummary,
+                : failureSummary),
             failure_summary: failureSummary,
             evidence_urls: lastCompletion?.evidence_urls ?? [],
             cost: lastCompletion?.cost ?? { tokens_in: 0, tokens_out: 0, cost_usd: 0 },
@@ -501,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);
     }
@@ -525,6 +535,24 @@ function sumReportedUsage(attempts, key) {
     });
     return reported.length > 0 ? reported.reduce((sum, value) => sum + value, 0) : undefined;
 }
+/**
+ * The control plane refuses to release a verify lease whose failed completion
+ * does not open with `Verification verdict: FAIL` or `BLOCKED`
+ * (verification_verdict_invalid), and that gate applies to runtime-authored
+ * failure reports too. When the report carries no usable verdict — the agent
+ * crashed, timed out, exited non-zero, or opened with PASS despite the failed
+ * outcome — label it BLOCKED: the failure prevented an acceptance decision.
+ * Without this, the failure completion is itself rejected, the session
+ * crashes, and the lease dangles until expiry.
+ */
+function verificationFailureReport(taskType, report) {
+    if (taskType !== "verify")
+        return report;
+    const verdict = (0, exit_conditions_cjs_1.leadingVerificationVerdict)(report);
+    if (verdict === "fail" || verdict === "blocked")
+        return report;
+    return `Verification verdict: BLOCKED — the session ended before verification reached an acceptance decision.\n\n${report}`;
+}
 /** Rejection codes another agent turn in the same worktree can plausibly fix. */
 const REMEDIABLE_REJECTION_CODES = new Set([
     "pr_required",
@@ -536,6 +564,12 @@ const REMEDIABLE_REJECTION_CODES = new Set([
     // The marker is already on the right head; the reviewer only has to relabel
     // the body, which is exactly what a remediation turn can do.
     "review_evidence_mislabeled",
+    // A verify agent that exited zero without the mandated leading
+    // `Verification verdict:` line only has to restate its report; the
+    // rejection prose spells out the exact format. Failed outcomes never reach
+    // remediation (see the leaseOutcome === "completed" gate) — their reports
+    // are verdict-labelled by verificationFailureReport before posting.
+    "verification_verdict_invalid",
 ]);
 /**
  * A 409 the control plane raised to reject *this* completion's contents (as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.22",
+  "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",