@sagentlab/navarch-runtime 0.1.121 → 0.1.122

package/README.md

@@ -278,16 +278,23 @@ instance during an automatic-update handoff.
 Guidance added to a task that is already running is delivered on that
 task's next lease heartbeat (every
 `NAVARCH_LEASE_HEARTBEAT_INTERVAL_MS`, five minutes by default). The runtime
-stops the current agent process and starts a **new agent turn** with the
-original task context plus all guidance received so far. This is a turn
-restart, not a new dispatch:
+stops the current agent process and starts a **new agent turn**. This is a
+turn restart, not a new dispatch:
 
 - The task keeps the same session and lease, and lease heartbeats continue.
 - The replacement turn uses the same worktree (and the same sandbox container
   in Docker mode), so committed and uncommitted changes from the interrupted
   turn remain available. It should inspect those changes before continuing.
-- The replacement turn is not a resumed agent CLI conversation.
-  The corrected prompt carries the prior task context and guidance instead.
+- Claude Code and Codex resume the interrupted turn's CLI conversation
+  (`claude -p --resume <session>`, `codex exec resume <thread> -`) and are
+  sent only the task's one-line summary and the guidance that conversation has
+  not seen. Delivery-correction and completion-remediation turns resume the
+  same way. Every other agent, a turn that left no session id, and a resume
+  the CLI refuses before starting get a fresh invocation with the full task
+  context plus every guidance entry received since the claim. Guidance present
+  at claim time is already in the task context and is not repeated.
+  `prompt.md` in the session directory always holds what the last invocation
+  was actually sent.
 - Transcript, token, and cost accounting is cumulative across turns: the
   upload includes every turn under a separate label, and reported token and
   cost totals include every turn. The lease is completed only after the

package/dist/adapters/claude.cjs

@@ -12,6 +12,12 @@ const FALLBACK_CLAUDE_MODEL = "claude-opus-5-5";
 function hasFlag(args, flag) {
     return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
 }
+const CLAUDE_SESSION_ID = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+/** Operator flags that pick the conversation themselves; Navarch then never resumes one. */
+const OPERATOR_SESSION_FLAGS = ["--resume", "-r", "--continue", "-c", "--session-id", "--fork-session"];
+function operatorOwnsSession(extraArgs) {
+    return OPERATOR_SESSION_FLAGS.some((flag) => hasFlag(extraArgs, flag));
+}
 /**
  * Headless Claude Code adapter (project-plan.md §3.9 / implementation-plan.md
  * WP-07): `claude -p --mcp-config platform-mcp.json --output-format stream-json --verbose`
@@ -53,13 +59,13 @@ async function runClaudeCodeAdapter(options) {
     if (!parsed?.is_error || !(0, adapter_capacity_cjs_1.detectAdapterCapacityLimit)(primary))
         return primary;
     const canResume = typeof parsed.session_id === "string" &&
-        /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(parsed.session_id) &&
+        CLAUDE_SESSION_ID.test(parsed.session_id) &&
         !hasFlag(options.extraArgs, "--no-session-persistence");
     // Never replay a task that may already have side effects without its saved
     // conversation. A structured zero-turn rejection is safe to start afresh.
     if (!canResume && parsed.num_turns !== 0)
         return primary;
-    if (["--resume", "-r", "--continue", "-c", "--session-id", "--fork-session"].some((flag) => hasFlag(options.extraArgs, flag)))
+    if (operatorOwnsSession(options.extraArgs))
         return primary;
     const fallback = await runClaudeAttempt({
         ...options,
@@ -68,9 +74,9 @@ async function runClaudeCodeAdapter(options) {
         prompt: canResume
             ? "Continue the interrupted task from the saved conversation. Check existing work before taking further action."
             : options.prompt,
-        extraArgs: canResume
-            ? [...options.extraArgs, "--resume", parsed.session_id]
-            : options.extraArgs,
+        // A zero-turn rejection without a session id reruns this same turn, which
+        // may itself be a resumed correction turn.
+        resumeSessionId: canResume ? parsed.session_id : options.resumeSessionId,
     }, false);
     return {
         ...fallback,
@@ -93,6 +99,19 @@ function addUsage(first, second) {
     return first === undefined && second === undefined ? undefined : (first ?? 0) + (second ?? 0);
 }
 async function runClaudeAttempt(options, automaticFallback) {
+    if (options.resumeSessionId &&
+        (!CLAUDE_SESSION_ID.test(options.resumeSessionId) || operatorOwnsSession(options.extraArgs))) {
+        // Never hand an unvalidated id to argv, and never stack a second
+        // conversation selector on an operator's own. Nothing ran.
+        return {
+            exitCode: null,
+            timedOut: false,
+            killedByLeaseLoss: false,
+            stdout: "",
+            stderr: "Navarch did not resume the Claude session: the session id is invalid or the operator selects the conversation.",
+            resumeRejected: true,
+        };
+    }
     const args = ["-p"];
     const hasSettingSources = options.extraArgs.some((arg) => arg === "--setting-sources" || arg.startsWith("--setting-sources="));
     const hasExplicitPermissionMode = options.extraArgs.some((arg) => ["--permission-mode", "--permission-prompt-tool", "--dangerously-skip-permissions"].some((flag) => arg === flag || arg.startsWith(`${flag}=`)));
@@ -145,6 +164,8 @@ async function runClaudeAttempt(options, automaticFallback) {
             args.push("--verbose");
     }
     args.push(...options.extraArgs);
+    if (options.resumeSessionId)
+        args.push("--resume", options.resumeSessionId);
     // Project/task policy is appended after machine-wide extra arguments so a
     // dispatched session consistently uses the settings recorded by Navarch.
     if (options.model)
@@ -160,7 +181,54 @@ async function runClaudeAttempt(options, automaticFallback) {
         }
         : options;
     const raw = runOptions.dockerExec ? await runViaDocker(runOptions, args) : await runOnHost(runOptions, args);
-    return attachUsage(raw);
+    return attachSession(attachUsage(raw), options);
+}
+/**
+ * Reports the conversation this attempt ran in, so a later correction turn in
+ * the same lease can `--resume` it and send only what changed. Claude Code
+ * prints the session id on its first stream-json record (`system`/`init`) and
+ * again on the final result, so a turn cut short by guidance still has one.
+ * Nothing is reported when session persistence is off or an operator flag
+ * selects the conversation: there is then nothing Navarch may resume.
+ *
+ * `--resume` with an unknown id exits 1 with a zero-turn error result and no
+ * `init` record ("No conversation found with session ID"); that is the only
+ * case flagged `resumeRejected`, since no agent work can have started.
+ */
+function attachSession(result, options) {
+    let sessionId;
+    let started = false;
+    for (const line of result.stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (typeof record !== "object" || record === null || Array.isArray(record))
+            continue;
+        const { type, subtype, session_id: id, num_turns: turns } = record;
+        if ((type === "system" && subtype === "init") || type === "assistant" || type === "user" ||
+            (type === "result" && typeof turns === "number" && turns > 0)) {
+            started = true;
+        }
+        if (typeof id === "string" && CLAUDE_SESSION_ID.test(id) && (type === "system" || type === "result")) {
+            sessionId = id;
+        }
+    }
+    const resumable = !hasFlag(options.extraArgs, "--no-session-persistence") &&
+        !operatorOwnsSession(options.extraArgs);
+    const rejected = Boolean(options.resumeSessionId) && !started && result.exitCode !== 0 &&
+        !result.timedOut && !result.killedByLeaseLoss;
+    return {
+        ...result,
+        ...(resumable && sessionId && !rejected ? { agentSessionId: sessionId } : {}),
+        ...(rejected ? { resumeRejected: true } : {}),
+    };
 }
 /** Parses the final `claude -p --output-format stream-json` result record for usage and folds it onto the raw result (best-effort; leaves tokensIn/tokensOut/costUsd unset when parsing fails). */
 function attachUsage(result) {
@@ -282,5 +350,8 @@ function shellQuote(value) {
 exports.claudeCodeAdapter = {
     agentType: "claude-code",
     run: runClaudeCodeAdapter,
+    resumesTurns: true,
+    // `usage` is per turn; `total_cost_usd` covers the whole resumed conversation.
+    cumulativeResumeUsage: ["costUsd"],
     conversation: claude_conversation_cjs_1.claudeConversationRunner,
 };

package/dist/adapters/codex.cjs

@@ -48,7 +48,22 @@ const kill_agent_cjs_1 = require("../kill-agent.cjs");
  *   approval-bypass flag) without an adapter code change.
  */
 async function runCodexAdapter(options) {
-    const args = ["exec", "-"];
+    const resumable = codexCanResume(options.extraArgs);
+    if (options.resumeSessionId && (!resumable || !CODEX_THREAD_ID.test(options.resumeSessionId))) {
+        return {
+            exitCode: null,
+            timedOut: false,
+            killedByLeaseLoss: false,
+            stdout: "",
+            stderr: "Navarch did not resume the Codex thread: the thread id is invalid or the operator arguments do not apply to `codex exec resume`.",
+            resumeRejected: true,
+        };
+    }
+    // `codex exec resume <thread> -` continues a recorded thread with the
+    // stdin prompt (verified against codex-cli 0.163.0). Every other argument
+    // below is accepted by both forms, so the guard profile and MCP servers are
+    // re-applied identically on the resumed turn.
+    const args = options.resumeSessionId ? ["exec", "resume", options.resumeSessionId, "-"] : ["exec", "-"];
     const env = { ...options.env };
     if (options.mcpConfigPath)
         args.push(...(await codexMcpArgs(options.mcpConfigPath, env)));
@@ -68,7 +83,53 @@ async function runCodexAdapter(options) {
     const raw = runOptions.dockerExec
         ? await runViaDocker(runOptions, args)
         : await runOnHost(runOptions, args);
-    return attachUsage(raw, options.model);
+    return attachThread(attachUsage(raw, options.model), options, resumable);
+}
+const CODEX_THREAD_ID = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+/**
+ * `codex exec` options that `codex exec resume` does not accept (codex-cli
+ * 0.163.0 `--help`), plus `--ephemeral`, which records no thread to resume.
+ * An operator argument from this list keeps every turn a fresh `codex exec`.
+ */
+const CODEX_NON_RESUMABLE_ARGS = [
+    "--ephemeral",
+    "--sandbox",
+    "-s",
+    "--profile",
+    "-p",
+    "--cd",
+    "-C",
+    "--add-dir",
+    "--oss",
+    "--local-provider",
+    "--color",
+    "--approve-for-me",
+];
+function codexCanResume(extraArgs) {
+    return !extraArgs.some((arg) => CODEX_NON_RESUMABLE_ARGS.some((flag) => arg === flag || (flag.startsWith("--") && arg.startsWith(`${flag}=`))));
+}
+/**
+ * Reports the thread this run recorded (`thread.started.thread_id`) so a later
+ * correction turn in the same lease can resume it. `codex exec resume` with an
+ * unknown id exits 1 before `turn.started` ("no rollout found for thread
+ * id"); only that shape is flagged `resumeRejected`, since no agent work ran.
+ */
+function attachThread(result, options, resumable) {
+    const events = (0, exit_conditions_cjs_1.parseCodexJsonEvents)(result.stdout);
+    const started = events.some((event) => event.type === "turn.started");
+    let threadId;
+    for (const event of events) {
+        const id = event.thread_id;
+        if (event.type === "thread.started" && typeof id === "string" && CODEX_THREAD_ID.test(id))
+            threadId = id;
+    }
+    const rejected = Boolean(options.resumeSessionId) && !started && result.exitCode !== 0 &&
+        !result.timedOut && !result.killedByLeaseLoss;
+    return {
+        ...result,
+        ...(resumable && threadId && !rejected ? { agentSessionId: threadId } : {}),
+        ...(rejected ? { resumeRejected: true } : {}),
+    };
 }
 /** Operator policy wins over Navarch's generated host-mode profile. */
 function hasExplicitPermissionPolicy(args) {
@@ -274,4 +335,7 @@ function shellQuote(value) {
 exports.codexAdapter = {
     agentType: "codex",
     run: runCodexAdapter,
+    resumesTurns: true,
+    // `exec resume` reports the thread's total_token_usage, not the turn's.
+    cumulativeResumeUsage: ["tokensIn", "tokensOut", "cacheHitTokensIn", "costUsd"],
 };

package/dist/delivery.cjs

@@ -24,7 +24,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probeWorktreeDelivery = probeWorktreeDelivery;
 exports.evaluateDelivery = evaluateDelivery;
 exports.renderDeliveryCorrectionPrompt = renderDeliveryCorrectionPrompt;
+exports.renderResumedDeliveryCorrectionPrompt = renderResumedDeliveryCorrectionPrompt;
 const sandbox_cjs_1 = require("./sandbox.cjs");
+const prompt_cjs_1 = require("./prompt.cjs");
 const GIT_TIMEOUT_MS = 30_000;
 /**
  * Reads the worktree's delivery state.
@@ -153,6 +155,19 @@ function renderDeliveryCorrectionPrompt(args) {
     return [
         args.originalPrompt.trim(),
         "",
+        ...deliveryIncompleteSection(args),
+        ...(clippedReport ? ["", "### Previous turn's final report", "", clippedReport] : []),
+    ].join("\n");
+}
+/**
+ * The resumed counterpart of renderDeliveryCorrectionPrompt: the brief and
+ * the previous turn's final report are both already in the conversation.
+ */
+function renderResumedDeliveryCorrectionPrompt(args) {
+    return [(0, prompt_cjs_1.renderResumedTurnPreamble)(args.task), "", ...deliveryIncompleteSection(args)].join("\n");
+}
+function deliveryIncompleteSection(args) {
+    return [
         "## Delivery is incomplete",
         "",
         `Your previous turn ended without delivering the task: ${args.reason}.`,
@@ -181,6 +196,5 @@ function renderDeliveryCorrectionPrompt(args) {
         "",
         "Your final report replaces the previous one. Restate it in full in the required format, preserving",
         "the verdict, reviewed head, findings, and validation limitations. Do not claim delivery you cannot verify.",
-        ...(clippedReport ? ["", "### Previous turn's final report", "", clippedReport] : []),
-    ].join("\n");
+    ];
 }

package/dist/prompt.cjs

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderPrompt = renderPrompt;
 exports.renderGuidanceCorrectionPrompt = renderGuidanceCorrectionPrompt;
+exports.renderMidFlightGuidanceSection = renderMidFlightGuidanceSection;
+exports.renderResumedTurnPreamble = renderResumedTurnPreamble;
+exports.renderResumedGuidancePrompt = renderResumedGuidancePrompt;
 exports.renderCompletionRemediationPrompt = renderCompletionRemediationPrompt;
+exports.renderResumedCompletionRemediationPrompt = renderResumedCompletionRemediationPrompt;
 exports.renderHostedCheckpointNote = renderHostedCheckpointNote;
 const CODE_GRAPH_GUIDANCE = "For JS/TS dependency inspection, the runtime provides `navarch-runtime code-graph --query <symbol-or-file> --mode search|callers|callees|impact --commit HEAD`. If the runtime is not on PATH, use its installed entry point; do not install another copy mid-task. Results describe committed source and include commit/freshness warnings; inspect current files for uncommitted changes and unresolved dependencies.";
 const PROCESS_GUIDANCE = "Process management: this host may run other agent sessions. Keep the PID or tool handle of each preview server you start and stop only that owned process. Never use broad process-name or command-line matching (pkill, killall) to clean up servers: the agent launcher carries the task prompt in its arguments and can match those patterns, terminating your own session. Use a different port when a port is occupied by a process you do not own. Keep scratch files in the current worktree; paths in previous transcripts belong to earlier sessions. Before your final report, inspect `git status --short`, including untracked files. Preserve required evidence in task artifacts, then remove only temporary files you created and restore only tracked edits you made solely for local checks. Do not delete unfamiliar or pre-existing changes, hide leftovers with ignore rules, or commit scratch files merely to make the worktree clean. Review tasks deliver a native review and attestation, never commits, pushes, or a new PR.";
@@ -64,9 +68,12 @@ function renderPrompt(task, bundle) {
  * partial edits instead of discarding mid-flight work.
  */
 function renderGuidanceCorrectionPrompt(originalPrompt, guidance) {
+    return [originalPrompt.trim(), renderMidFlightGuidanceSection(guidance)].join("\n");
+}
+/** The guidance section shared by the full-brief and resumed guidance turns. */
+function renderMidFlightGuidanceSection(guidance) {
     const corrections = guidance.map((entry) => `- **${entry.given_at}**: ${entry.content}`);
     return [
-        originalPrompt.trim(),
         "## Mid-flight human guidance",
         "",
         "The task was actively steered while you were working. Human guidance takes precedence over earlier context. Continue in the same worktree: inspect the current changes, correct course, and then finish the task.",
@@ -75,6 +82,24 @@ function renderGuidanceCorrectionPrompt(originalPrompt, guidance) {
         "",
     ].join("\n");
 }
+/**
+ * Opens every turn that resumes the previous agent conversation
+ * (`AgentAdapter.resumesTurns`). The brief is already in that conversation,
+ * so the turn names the task in one line and says the brief still applies
+ * instead of re-sending 35–80K characters of it. A turn that cannot resume
+ * uses the full-brief renderers, which keep #1978's fix: a fresh agent never
+ * receives a correction without its task.
+ */
+function renderResumedTurnPreamble(task) {
+    return [
+        `Task: ${task.summary} (Navarch task ${task.id}).`,
+        "This turn continues the conversation above. The full task brief earlier in this conversation still applies and is not repeated here.",
+    ].join("\n");
+}
+/** A resumed guidance turn: only the guidance this conversation has not seen. */
+function renderResumedGuidancePrompt(task, guidance) {
+    return [renderResumedTurnPreamble(task), "", renderMidFlightGuidanceSection(guidance)].join("\n");
+}
 /** Keeps a long previous report from crowding the brief out of the prompt. */
 const REMEDIATION_REPORT_LIMIT = 8_000;
 /**
@@ -93,21 +118,33 @@ function renderCompletionRemediationPrompt(args) {
     return [
         args.originalPrompt.trim(),
         "",
+        ...completionRejectedSection(args),
+        ...(clipped
+            ? ["", "### Previous turn's final report", "", clipped]
+            : []),
+        "",
+    ].join("\n");
+}
+/**
+ * The resumed counterpart of renderCompletionRemediationPrompt: the brief and
+ * the previous turn's final report are both already in the conversation.
+ */
+function renderResumedCompletionRemediationPrompt(args) {
+    return [renderResumedTurnPreamble(args.task), "", ...completionRejectedSection(args), ""].join("\n");
+}
+function completionRejectedSection(args) {
+    return [
         "## Completion was rejected",
         "",
         "Your previous turn on this task finished, but the Navarch control plane rejected its completion:",
         "",
         ...args.rejection.trim().split("\n").map((line) => `> ${line}`),
         "",
-        `This is correction turn ${args.attempt} of ${args.maxAttempts}. The task above is unchanged, and you are in the`,
+        `This is correction turn ${args.attempt} of ${args.maxAttempts}. The task is unchanged, and you are in the`,
         "same worktree, so earlier edits, commits, and branches are still here. Reuse the work and findings from",
         "the previous turn instead of starting over, fix what the rejection names, and finish the task.",
         "Your final report replaces the previous one, so restate it in full in the required format.",
-        ...(clipped
-            ? ["", "### Previous turn's final report", "", clipped]
-            : []),
-        "",
-    ].join("\n");
+    ];
 }
 /**
  * Tells the agent its worktree starts from a hosted attempt's checkpoint

package/dist/session.cjs

@@ -529,7 +529,22 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         });
         const agentBudgetStartedAt = node_perf_hooks_1.performance.now();
         const maxRuntimeMs = task.max_runtime_ms ?? config.sessionTimeoutMs;
-        let nextPrompt = null;
+        // A correction turn in two forms: `full` restates the task brief for a
+        // fresh agent; `resumed` is only the correction, for an adapter that
+        // continues the previous turn's conversation (AgentAdapter.resumesTurns).
+        let nextCorrection = null;
+        // The conversation the next turn may resume, and the mid-flight guidance
+        // that conversation has already been sent.
+        let resumableSessionId;
+        let conversationGuidanceIds = new Set();
+        // Running usage totals the resumable conversation last reported, for the
+        // fields its adapter reports cumulatively (AgentAdapter.cumulativeResumeUsage).
+        let conversationUsage = {};
+        // Claim-time guidance is part of the brief (task_context's "Human
+        // guidance" section, lib/navarch/context.ts), so guidance turns carry only
+        // what arrived after the claim.
+        const briefGuidanceIds = new Set((bundle.guidance ?? []).map((entry) => entry.id));
+        const resumedTask = { id: task.id, summary: task.summary };
         let completionRemediationRetries = 0;
         let deliveryCorrectionRetries = 0;
         let deliveredPullRequest = false;
@@ -540,58 +555,85 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             // It is already included in deliveredGuidance, so clear the pending
             // notification and start the first turn with the corrected prompt.
             pendingGuidance = [];
-            activeAbortController = new AbortController();
+            const turnAbort = new AbortController();
+            activeAbortController = turnAbort;
             if (leaseLost || deps.shutdownSignal?.aborted)
-                activeAbortController.abort();
+                turnAbort.abort();
             // The task brief plus any mid-flight guidance. Correction turns build on
             // this rather than on the previous turn's prompt so they never nest.
-            const briefPrompt = deliveredGuidance.length > (bundle.guidance?.length ?? 0)
-                ? (0, prompt_cjs_1.renderGuidanceCorrectionPrompt)(promptText, deliveredGuidance)
+            const midFlightGuidance = deliveredGuidance.filter((entry) => !briefGuidanceIds.has(entry.id));
+            const briefPrompt = midFlightGuidance.length > 0
+                ? (0, prompt_cjs_1.renderGuidanceCorrectionPrompt)(promptText, midFlightGuidance)
                 : promptText;
-            const runPrompt = nextPrompt ?? briefPrompt;
-            nextPrompt = null;
-            await node_fs_1.promises.writeFile(node_path_1.default.join(workDir, "prompt.md"), runPrompt, "utf8");
+            const fullPrompt = nextCorrection ? nextCorrection.full(briefPrompt) : briefPrompt;
+            // Resume only to deliver something new: a correction, or guidance this
+            // conversation has not been sent. The brief is already in it.
+            const unsentGuidance = midFlightGuidance.filter((entry) => !conversationGuidanceIds.has(entry.id));
+            const resumeSessionId = adapter.resumesTurns && (nextCorrection || unsentGuidance.length > 0)
+                ? resumableSessionId
+                : undefined;
+            const resumedPrompt = resumeSessionId
+                ? nextCorrection
+                    ? [nextCorrection.resumed, ...(unsentGuidance.length > 0 ? [(0, prompt_cjs_1.renderMidFlightGuidanceSection)(unsentGuidance)] : [])].join("\n\n")
+                    : (0, prompt_cjs_1.renderResumedGuidancePrompt)(resumedTask, unsentGuidance)
+                : null;
+            nextCorrection = null;
             adapterStarted = true;
             adapterRunning = true;
             agentTurnStartedAt = Date.now();
             outputReportedAt = agentTurnStartedAt;
             outputUpdates = 0;
             reportActivity("running");
-            const remainingRuntimeMs = maxRuntimeMs > 0
-                ? maxRuntimeMs - (node_perf_hooks_1.performance.now() - agentBudgetStartedAt)
-                : 0;
-            const turnResult = maxRuntimeMs > 0 && remainingRuntimeMs <= 0
-                ? { exitCode: null, timedOut: true, timeoutReason: "duration", killedByLeaseLoss: false, stdout: "", stderr: "" }
-                : await (0, adapter_watchdog_cjs_1.runWithActivityWatchdog)(adapter, {
-                    prompt: runPrompt,
-                    mcpConfigPath,
-                    mcpMetadataDir: workDir,
-                    bin,
-                    extraArgs,
-                    model: execution.model,
-                    reasoningEffort: execution.reasoning_effort,
-                    timeoutMs: remainingRuntimeMs,
-                    env: sessionEnv,
-                    settingsPath: claudeSettingsPath,
-                    codexGuardArgs,
-                    antigravityHostGuard: runtime === "antigravity" && config.sandboxMode === "host" && config.worktreeGuard,
-                    antigravityResume,
-                    museHostGuard: config.sandboxMode === "host" && config.worktreeGuard,
-                    resumeSessionId: runtime === "muse" ? museSessionId : undefined,
-                    opencodeHostGuard: runtime === "opencode" && config.sandboxMode === "host" && config.worktreeGuard,
-                    // ACP requires an absolute session cwd. Docker mounts the worktree at
-                    // this same absolute path, while the other Docker adapters ignore cwd.
-                    cwd: gitWorktree.worktreePath,
-                    dockerExec: sandbox ? { containerName: sandbox.name, runner: sandbox_cjs_1.nodeCommandRunner } : undefined,
-                    signal: activeAbortController.signal,
-                    onActivity: () => { outputObservedAt = Date.now(); outputUpdates += 1; },
-                    onOutput: (stream, chunk) => {
-                        if (stream !== "stdout")
-                            return;
-                        liveStdout += chunk;
-                        liveTranscript?.markDirty();
-                    },
-                }, task.idle_timeout_ms ?? config.sessionIdleTimeoutMs ?? 45 * 60_000, runtime === "opencode" ? config.opencodeStartupTimeoutMs : 0);
+            const runTurn = async (prompt, resumeId) => {
+                // prompt.md records exactly what this invocation is sent.
+                await node_fs_1.promises.writeFile(node_path_1.default.join(workDir, "prompt.md"), prompt, "utf8");
+                const remainingRuntimeMs = maxRuntimeMs > 0
+                    ? maxRuntimeMs - (node_perf_hooks_1.performance.now() - agentBudgetStartedAt)
+                    : 0;
+                return maxRuntimeMs > 0 && remainingRuntimeMs <= 0
+                    ? { exitCode: null, timedOut: true, timeoutReason: "duration", killedByLeaseLoss: false, stdout: "", stderr: "" }
+                    : await (0, adapter_watchdog_cjs_1.runWithActivityWatchdog)(adapter, {
+                        prompt,
+                        mcpConfigPath,
+                        mcpMetadataDir: workDir,
+                        bin,
+                        extraArgs,
+                        model: execution.model,
+                        reasoningEffort: execution.reasoning_effort,
+                        timeoutMs: remainingRuntimeMs,
+                        env: sessionEnv,
+                        settingsPath: claudeSettingsPath,
+                        codexGuardArgs,
+                        antigravityHostGuard: runtime === "antigravity" && config.sandboxMode === "host" && config.worktreeGuard,
+                        antigravityResume,
+                        museHostGuard: config.sandboxMode === "host" && config.worktreeGuard,
+                        resumeSessionId: runtime === "muse" ? museSessionId : resumeId,
+                        opencodeHostGuard: runtime === "opencode" && config.sandboxMode === "host" && config.worktreeGuard,
+                        // ACP requires an absolute session cwd. Docker mounts the worktree at
+                        // this same absolute path, while the other Docker adapters ignore cwd.
+                        cwd: gitWorktree.worktreePath,
+                        dockerExec: sandbox ? { containerName: sandbox.name, runner: sandbox_cjs_1.nodeCommandRunner } : undefined,
+                        signal: turnAbort.signal,
+                        onActivity: () => { outputObservedAt = Date.now(); outputUpdates += 1; },
+                        onOutput: (stream, chunk) => {
+                            if (stream !== "stdout")
+                                return;
+                            liveStdout += chunk;
+                            liveTranscript?.markDirty();
+                        },
+                    }, task.idle_timeout_ms ?? config.sessionIdleTimeoutMs ?? 45 * 60_000, runtime === "opencode" ? config.opencodeStartupTimeoutMs : 0);
+            };
+            let turnResult = await runTurn(resumedPrompt ?? fullPrompt, resumeSessionId);
+            let resumed = Boolean(resumeSessionId);
+            if (resumeSessionId && turnResult.resumeRejected && !leaseLost && !turnAbort.signal.aborted) {
+                // The CLI refused the session before any work started (expired or
+                // unknown id). Nothing ran, so send the full brief to a fresh agent.
+                log.warn(`could not resume the agent conversation for ${leaseId} ` +
+                    `(${(0, redact_cjs_1.redactText)(turnResult.stderr.trim().slice(0, 300), registry.list())}); re-sending the full task brief.`);
+                liveStdout = "";
+                turnResult = await runTurn(fullPrompt, undefined);
+                resumed = false;
+            }
             activeAbortController = null;
             adapterRunning = false;
             if (turnResult.timedOut || leaseLost)
@@ -603,6 +645,34 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             antigravityResume = turnResult.antigravityResume;
             if (runtime === "muse")
                 museSessionId = turnResult.agentSessionId;
+            if (adapter.cumulativeResumeUsage) {
+                // A resumed run reports the conversation's running total: record only
+                // this turn's increase. A fresh conversation starts its own total.
+                if (!resumed)
+                    conversationUsage = {};
+                for (const key of adapter.cumulativeResumeUsage) {
+                    const total = turnResult[key];
+                    if (total === undefined)
+                        continue;
+                    turnResult[key] = Math.max(0, total - (conversationUsage[key] ?? 0));
+                    conversationUsage[key] = total;
+                }
+            }
+            if (adapter.resumesTurns) {
+                resumableSessionId = turnResult.resumeRejected ? undefined : turnResult.agentSessionId;
+                if (!resumableSessionId) {
+                    conversationGuidanceIds = new Set();
+                }
+                else if (resumed) {
+                    for (const entry of unsentGuidance)
+                        conversationGuidanceIds.add(entry.id);
+                }
+                else {
+                    // A fresh conversation was sent the full brief, which carries every
+                    // mid-flight guidance entry received so far.
+                    conversationGuidanceIds = new Set(midFlightGuidance.map((entry) => entry.id));
+                }
+            }
             attempts.push(turnResult);
             liveStdout = "";
             liveTranscript.markDirty();
@@ -735,14 +805,18 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                         deliveryCorrectionRetries += 1;
                         log.warn(`session ${leaseId} finished without delivering (${delivery.reason}); ` +
                             `restarting agent turn ${deliveryCorrectionRetries}/${DELIVERY_CORRECTION_RETRIES} in the same worktree.`);
-                        nextPrompt = (0, delivery_cjs_1.renderDeliveryCorrectionPrompt)({
-                            originalPrompt: briefPrompt,
+                        const correction = {
                             taskType: task.task_type,
-                            previousReport: previousTurnReport(),
                             reason: delivery.reason,
                             attempt: deliveryCorrectionRetries,
                             maxAttempts: DELIVERY_CORRECTION_RETRIES,
-                        });
+                        };
+                        const previousReport = previousTurnReport();
+                        nextCorrection = {
+                            full: (brief) => (0, delivery_cjs_1.renderDeliveryCorrectionPrompt)({ ...correction, originalPrompt: brief, previousReport }),
+                            // The resumed conversation already holds the previous report.
+                            resumed: (0, delivery_cjs_1.renderResumedDeliveryCorrectionPrompt)({ ...correction, task: resumedTask }),
+                        };
                         continue;
                     }
                     await checkpointForRecovery(result, "incomplete delivery");
@@ -831,15 +905,19 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 if (remediable && completionRemediationRetries < COMPLETION_REMEDIATION_RETRIES) {
                     completionRemediationRetries += 1;
                     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)({
-                        originalPrompt: briefPrompt,
+                    // A fresh agent invocation needs the brief: the rejection alone would
+                    // reach an agent that has never seen the task (#1978). A resumed
+                    // conversation already holds the brief and the previous report.
+                    const correction = {
                         rejection: redactedRejection,
-                        previousReport: previousTurnReport(),
                         attempt: completionRemediationRetries,
                         maxAttempts: COMPLETION_REMEDIATION_RETRIES,
-                    });
+                    };
+                    const previousReport = previousTurnReport();
+                    nextCorrection = {
+                        full: (brief) => (0, prompt_cjs_1.renderCompletionRemediationPrompt)({ ...correction, originalPrompt: brief, previousReport }),
+                        resumed: (0, prompt_cjs_1.renderResumedCompletionRemediationPrompt)({ ...correction, task: resumedTask }),
+                    };
                     continue;
                 }
                 if (remediable) {

package/package.json

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