@sagentlab/navarch-runtime 0.1.120 → 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
@@ -815,6 +822,21 @@ to OpenCode's remote-server config with OAuth disabled and environment-backed
 headers. Missing accounting fields stay absent rather than becoming a
 fabricated zero.
 
+Host OpenCode sessions preserve operator provider definitions from
+`$XDG_CONFIG_HOME/opencode/opencode.json(c)` (default
+`~/.config/opencode/opencode.json(c)`), then `OPENCODE_CONFIG`, configs in
+`OPENCODE_CONFIG_DIR`, and finally `OPENCODE_CONFIG_CONTENT`. JSONC comments
+and trailing commas are supported. Nested provider settings merge in that
+order; later arrays replace earlier arrays. Legacy `provider` entries work
+with V1 and V2; native `providers` entries are included for V2. Custom model
+IDs, metadata, and variants are preserved, so a pin such as
+`--model magpie/openrouter/deepseek/deepseek-v4.1-flash-1017` works without
+duplicating the provider configuration. API keys and header values become
+child environment references, and file references resolve relative to their
+original config file. Provider settings are the only imported configuration:
+Navarch still generates the session's MCP and permissions and disables
+project config discovery. Docker sessions do not import host providers.
+
 OpenCode also runs with `--print-logs --log-level ERROR` by default (see its
 [CLI flags](https://opencode.ai/docs/cli/#global-flags)), so provider errors
 that are missing from assistant messages still reach the runtime. A rate or

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/adapters/opencode-providers.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOpenCodeProviders = loadOpenCodeProviders;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const jsonc_parser_1 = require("jsonc-parser");
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function merge(base, override) {
+    return Object.fromEntries([...new Set([...Object.keys(base), ...Object.keys(override)])].map((key) => {
+        const previous = base[key];
+        const next = override[key];
+        if (!Object.hasOwn(override, key))
+            return [key, previous];
+        return [key, isObject(previous) && isObject(next) ? merge(previous, next) : next];
+    }));
+}
+/** Import operator providers only, before the adapter replaces OpenCode's paths.
+ * OpenCode V2 accepts legacy `provider` entries alongside native `providers`;
+ * let its own compatibility loader handle model capabilities and variants.
+ * Never discover repository config or import its plugins, MCP, or permissions.
+ */
+async function loadOpenCodeProviders(env, generation) {
+    const setting = (name) => env[name] ?? process.env[name];
+    const home = setting("HOME") || node_os_1.default.homedir();
+    const expand = (file) => file.startsWith("~/") ? node_path_1.default.join(home, file.slice(2)) : file;
+    const globalDir = node_path_1.default.join(setting("XDG_CONFIG_HOME") || node_path_1.default.join(home, ".config"), "opencode");
+    let result = {};
+    let secretIndex = 0;
+    // Resolve file references against their original config, then keep credentials
+    // out of both the generated file and OPENCODE_CONFIG_CONTENT. Existing env
+    // references remain references and are resolved by the OpenCode child.
+    async function prepare(value, directory, sensitive = false) {
+        if (Array.isArray(value))
+            return Promise.all(value.map((item) => prepare(item, directory, sensitive)));
+        if (isObject(value)) {
+            return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, item]) => [
+                key, await prepare(item, directory, sensitive || /^(?:api[_-]?key|token|password|secret|headers)$/i.test(key)),
+            ])));
+        }
+        if (typeof value !== "string")
+            return value;
+        const fromFile = /\{file:[^}]+\}/.test(value);
+        if (!fromFile && (!sensitive || !value || /^\{env:[^}]+\}$/.test(value)))
+            return value;
+        // Mixed strings such as "Bearer {env:TOKEN}" need expansion before moving
+        // the whole header into another env var; substitutions are not recursive.
+        let resolved = value.replace(/\{env:([^}]+)\}/g, (_match, name) => setting(name) ?? "");
+        for (const match of value.matchAll(/\{file:([^}]+)\}/g)) {
+            const file = node_path_1.default.resolve(directory, expand(match[1]));
+            const contents = (await node_fs_1.promises.readFile(file, "utf8")).trim();
+            resolved = resolved.replace(match[0], () => contents);
+        }
+        let name;
+        do {
+            name = `NAVARCH_OPENCODE_PROVIDER_${secretIndex++}`;
+        } while (setting(name) !== undefined);
+        env[name] = resolved;
+        return `{env:${name}}`;
+    }
+    async function include(text, source, directory) {
+        const errors = [];
+        const config = (0, jsonc_parser_1.parse)(text, errors, { allowTrailingComma: true });
+        if (errors.length || !isObject(config)) {
+            // Parser diagnostics can contain literal credentials; report only source.
+            throw new Error(`Invalid OpenCode JSON/JSONC configuration in ${source}.`);
+        }
+        const picked = {};
+        for (const key of generation === 1 ? ["provider"] : ["provider", "providers"]) {
+            if (config[key] === undefined)
+                continue;
+            if (!isObject(config[key]))
+                throw new Error(`OpenCode ${key} must be an object in ${source}.`);
+            picked[key] = await prepare(config[key], directory);
+        }
+        result = merge(result, picked);
+    }
+    async function file(filePath, optional) {
+        const absolute = node_path_1.default.resolve(expand(filePath));
+        let text;
+        try {
+            text = await node_fs_1.promises.readFile(absolute, "utf8");
+        }
+        catch (error) {
+            if (optional && error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        await include(text, absolute, node_path_1.default.dirname(absolute));
+    }
+    for (const name of ["opencode.json", "opencode.jsonc"])
+        await file(node_path_1.default.join(globalDir, name), true);
+    const explicit = setting("OPENCODE_CONFIG");
+    if (explicit)
+        await file(explicit, false);
+    const directory = setting("OPENCODE_CONFIG_DIR");
+    if (directory) {
+        for (const name of ["opencode.json", "opencode.jsonc"])
+            await file(node_path_1.default.join(expand(directory), name), true);
+    }
+    const inline = setting("OPENCODE_CONFIG_CONTENT");
+    if (inline)
+        await include(inline, "OPENCODE_CONFIG_CONTENT", process.cwd());
+    return result;
+}

package/dist/adapters/opencode.cjs

@@ -12,6 +12,7 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const config_cjs_1 = require("../config.cjs");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const opencode_providers_cjs_1 = require("./opencode-providers.cjs");
 /**
  * Headless OpenCode adapter, fixture-pinned to the OpenCode JSON event
  * contract shared by V1 and V2 (verified against 1.19.1, 2.0.6 and 2.0.17):
@@ -34,8 +35,9 @@ const kill_agent_cjs_1 = require("../kill-agent.cjs");
  * so each Navarch session gets an isolated XDG/config directory, disables
  * project discovery, and supplies its complete policy as both a private file
  * and the highest-precedence inline config. Provider credentials remain in
- * OpenCode's data store or the child environment; only MCP env references are
- * written to disk.
+ * OpenCode's data store or the child environment. Operator provider definitions
+ * are copied without importing unrelated global config; credential and MCP
+ * values use env references in the generated file.
  */
 async function runOpenCodeAdapter(options) {
     if (options.opencodeHostGuard && !options.dockerExec) {
@@ -178,10 +180,14 @@ async function prepareOpenCodeConfig(mcpConfigPath, env, inDocker, generation) {
         };
     }
     const managedDirectories = await openCodeManagedDirectories(env, inDocker);
+    // Host provider endpoints and credentials belong to the operator's host.
+    // Docker continues to use its own provider setup, never the host's files.
+    const providers = inDocker ? {} : await (0, opencode_providers_cjs_1.loadOpenCodeProviders)(env, generation);
     // Same policy in both dialects; in each the last matching rule wins.
     const config = generation === 1
         ? {
             $schema: "https://opencode.ai/config.json",
+            ...providers,
             autoupdate: false,
             share: "disabled",
             plugin: [],
@@ -197,6 +203,7 @@ async function prepareOpenCodeConfig(mcpConfigPath, env, inDocker, generation) {
         }
         : {
             $schema: "https://opencode.ai/config.json",
+            ...providers,
             update: "disable",
             share: "disabled",
             plugins: [],

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