@sagentlab/navarch-runtime 0.1.93 → 0.1.95

package/README.md

@@ -330,13 +330,14 @@ own budgets. An absolute limit covers all guidance/remediation turns within the
 claim, rather than resetting with each turn. These are runtime limits, not
 provider spending caps.
 
-After a watchdog stop or lease loss during a turn, before worktree cleanup, the runtime attempts a private
+After a watchdog stop, lease loss during a turn, or exhausted delivery correction
+turns, before worktree cleanup, the runtime attempts a private
 local recovery checkpoint at
 `<workspaceRoot>/checkpoints/<project>/<task>/<session>/`. It contains a Git
 bundle of committed history, a binary patch for dirty tracked files, untracked
 non-ignored files, and recovery instructions. The bundle excludes repository
 configuration and broker credentials. Checkpoints are not pushed or uploaded;
-timeout reports and runtime logs name their location. They survive session cleanup and need
+failure reports and runtime logs name their location. They survive session cleanup and need
 manual recovery and removal on that machine. Ignored files, agent conversation
 state, and checkpoints across machine/disk loss are not provided.
 
@@ -504,7 +505,9 @@ as an explicit read-only mount.
 - **Codex:** the runtime passes a one-off native permission profile with
   `approval_policy="on-request"` and `approvals_reviewer="auto_review"`.
   Codex's OS sandbox grants read/write access only to the allowed roots and
-  denies the surrounding multi-session workspace. Its network policy allows
+  denies the surrounding multi-session workspace. After preparing the worktree,
+  the runtime explicitly grants its resolved linked Git metadata directory write
+  access so staging and committing work inside the sandbox. Its network policy allows
   GitHub and GitHub-hosted content so authenticated `gh` and git operations
   required by the task stay inside the sandbox. Other destinations remain
   blocked and eligible escalations are decided by the automatic reviewer

package/dist/exit-conditions.cjs

@@ -359,7 +359,10 @@ function mapExitCondition(result) {
     // including when that response says the task could not start. Treat an
     // explicit leading blocked verdict as a failed lease so the dispatcher can
     // retry/escalate it instead of falsely moving unfinished work to Done.
-    if (/^blocked(?:\s|:|$)/i.test(reportText.trim())) {
+    // Build agents also use an explicit outcome marker. A zero process exit
+    // means the conversation finished, not that the requested build succeeded.
+    if (/^blocked(?:\s|:|$)/i.test(reportText.trim()) ||
+        /^Build outcome:\s*(?:FAILED|BLOCKED)\b/i.test(reportText.trim())) {
         return {
             leaseOutcome: "failed",
             exitStatus: "failed",

package/dist/session.cjs

@@ -232,13 +232,14 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
     let retainWorktree = false;
     let heartbeatInFlight = null;
     let heartbeatWorkspaceUpdate = null;
+    let completingLease = false;
     const sessionOutcome = {};
-    const checkpointForRecovery = async (result) => {
+    const checkpointForRecovery = async (result, reason) => {
         if (result.checkpointPath || result.retainedWorktreePath)
             return;
         try {
             result.checkpointPath = await gitWorktree.saveCheckpoint();
-            log.warn(`session ${leaseId} stopped for ${leaseLost ? "lease loss" : result.capacityError ? "provider capacity" : result.timeoutReason ?? "duration"}; recovery checkpoint: ${result.checkpointPath}`);
+            log.warn(`session ${leaseId} stopped for ${reason ?? (leaseLost ? "lease loss" : result.capacityError ? "provider capacity" : result.timeoutReason ?? "duration")}; recovery checkpoint: ${result.checkpointPath}`);
         }
         catch (error) {
             retainWorktree = true;
@@ -285,7 +286,15 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 log.warn(`lease heartbeat failed for ${leaseId}: ${String(err)} — retrying on the next heartbeat while the confirmed lease remains valid.`);
                 return;
             }
-            log.warn(`lease heartbeat failed for ${leaseId}: ${String(err)} — killing session.`);
+            if (completingLease && isTerminalLeaseHeartbeatError(err)) {
+                // Completion can release the lease before its HTTP response arrives.
+                // Keep awaiting/re-sending that report to resolve the ambiguous write;
+                // there is no agent turn to kill during this phase.
+                log.info(`lease ${leaseId} is no longer active while completion is pending; awaiting completion acknowledgement.`);
+            }
+            else {
+                log.warn(`lease heartbeat failed for ${leaseId}: ${String(err)} — killing session.`);
+            }
             leaseLost = true;
             leaseGone = isTerminalLeaseHeartbeatError(err);
             heartbeatGuard.stop();
@@ -385,14 +394,6 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 await node_fs_1.promises.mkdir(tmpDir, { recursive: true, mode: 0o700 });
                 Object.assign(sessionEnv, { TMPDIR: tmpDir, TMP: tmpDir, TEMP: tmpDir });
             }
-            codexGuardArgs = (0, worktree_guard_cjs_1.codexWorktreeGuardArgs)({
-                workDir,
-                worktreePath: gitWorktree.worktreePath,
-                repositoryPath: gitWorktree.repositoryPath,
-                workspaceRoot: config.workspaceRoot,
-                extraRoots: config.guardExtraRoots,
-                codexBin: config.codexBin,
-            });
         }
         else if (runtime === "gemini") {
             geminiGuardMounts = (0, worktree_guard_cjs_1.geminiSandboxMounts)({
@@ -465,6 +466,16 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             log.warn(`hosted checkpoint for ${leaseId} could not be restored: ` +
                 `${(0, redact_cjs_1.redactText)(gitWorktree.hostedCheckpointRestoreFailure, registry.list())}; starting without it.`);
         }
+        if (config.sandboxMode === "host" && config.worktreeGuard && runtime === "codex") {
+            codexGuardArgs = (0, worktree_guard_cjs_1.codexWorktreeGuardArgs)({
+                workDir,
+                worktreePath: gitWorktree.worktreePath,
+                repositoryPath: gitWorktree.repositoryPath,
+                workspaceRoot: config.workspaceRoot,
+                extraRoots: config.guardExtraRoots,
+                codexBin: config.codexBin,
+            });
+        }
         const restoredCheckpoint = gitWorktree.restoredHostedCheckpoint;
         if (restoredCheckpoint) {
             log.info(`resumed hosted checkpoint ${restoredCheckpoint.sha.slice(0, 12)} for ${leaseId} ` +
@@ -701,11 +712,14 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                         });
                         continue;
                     }
+                    await checkpointForRecovery(result, "incomplete delivery");
                     deliveryFailureSummary =
                         `Session ended without delivering the task: ${delivery.reason}. ` +
                             `${deliveryCorrectionRetries} correction turn(s) did not recover it. ` +
-                            "The session worktree is deleted at teardown. Pushed commits remain on origin; " +
-                            "uncommitted or unpushed work may be lost. The task needs another attempt.";
+                            (result.checkpointPath
+                                ? `Local recovery checkpoint: ${result.checkpointPath}. `
+                                : `Recovery worktree retained: ${result.retainedWorktreePath}. `) +
+                            "The task needs another attempt.";
                     log.warn(`failing ${leaseId}: ${deliveryFailureSummary}`);
                     mapping.leaseOutcome = "failed";
                     mapping.exitStatus = "failed";
@@ -757,6 +771,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 transcript_url: completion.transcript_url,
             };
             try {
+                completingLease = true;
                 await (0, completion_retry_cjs_1.completeWithTransientRetry)(() => api.completeLease(leaseId, completion), {
                     onRetry: (attempt, delayMs, err) => log.warn(`completion for ${leaseId} did not reach the control plane (${(0, redact_cjs_1.redactText)(String(err), knownSecrets)}); re-sending in ${delayMs / 1000}s (${attempt}).`),
                 });
@@ -778,10 +793,11 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 if (!rejection)
                     throw err;
                 const redactedRejection = (0, redact_cjs_1.redactText)(rejection.message, knownSecrets);
+                const rejectionDetail = describeResponseBody(`${(0, redact_cjs_1.redactText)(rejection.code, knownSecrets)}: ${redactedRejection}`);
                 const remediable = mapping.leaseOutcome === "completed" && rejection.remediable;
                 if (remediable && completionRemediationRetries < COMPLETION_REMEDIATION_RETRIES) {
                     completionRemediationRetries += 1;
-                    log.warn(`completion for ${leaseId} needs more work; restarting agent turn ${completionRemediationRetries}/${COMPLETION_REMEDIATION_RETRIES} in the same worktree.`);
+                    log.warn(`completion for ${leaseId} needs more work (${rejectionDetail}); restarting agent turn ${completionRemediationRetries}/${COMPLETION_REMEDIATION_RETRIES} in the same worktree.`);
                     // A new turn is a fresh agent invocation: the rejection alone would
                     // reach an agent that has never seen the task.
                     nextPrompt = (0, prompt_cjs_1.renderCompletionRemediationPrompt)({
@@ -794,22 +810,24 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                     continue;
                 }
                 if (remediable) {
-                    log.warn(`completion for ${leaseId} is still not ready after ${COMPLETION_REMEDIATION_RETRIES} retries; failing with the control-plane rejection.`);
+                    log.warn(`completion for ${leaseId} is still not ready after ${COMPLETION_REMEDIATION_RETRIES} retries (${rejectionDetail}); failing with the control-plane rejection.`);
                 }
                 else {
                     // Not something another turn can fix (e.g. review_evidence_tampered).
                     // Fail the lease once, keeping this attempt's real report, cost and
                     // evidence — this is a rejected attempt, not a crashed session.
-                    log.error(`completion for ${leaseId} was rejected as ${rejection.code}, which is not remediable; failing the lease.`);
+                    log.error(`completion for ${leaseId} was rejected (${rejectionDetail}), which is not remediable; failing the lease.`);
                 }
                 try {
                     await (0, completion_retry_cjs_1.completeWithTransientRetry)(() => api.completeLease(leaseId, {
                         ...completion,
                         status: "failed",
-                        report: remediable
-                            ? redactedRejection
-                            : `${redactedRejection}\n\n---\n\n${completion.report}`,
-                        failure_summary: redactedRejection,
+                        report: `${redactedRejection}\n\n---\n\n${completion.report}`,
+                        // Keep the agent's blocker first: the API bounds failure_summary,
+                        // and retry attribution must not lose it behind a delivery error.
+                        failure_summary: remediable
+                            ? `${completion.report.slice(0, 1000)}\n\nControl-plane rejection:\n${redactedRejection.slice(0, 800)}`
+                            : redactedRejection,
                         exit_status: "failed",
                     }));
                 }
@@ -824,6 +842,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 }
                 break;
             }
+            finally {
+                completingLease = false;
+            }
         }
     }
     catch (err) {

package/package.json

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