@pentoshi/clai 3.9.1 → 3.9.3

package/dist/agent/runner.js

@@ -1,17 +1,19 @@
 import chalk from "chalk";
 import { join } from "node:path";
-import { streamWithProvider, completeWithProvider, isEmptyCompletionError } from "../llm/router.js";
+import { completeWithProvider, streamWithProvider } from "../llm/router.js";
+import { streamAlreadyEmitted } from "../llm/stream-progress.js";
+import { classifyStreamFailure, planStreamRecovery, recordRecoveryAttempt, createStreamRecoveryState, resetStreamRecoveryState, } from "./stream-recovery.js";
 import { resolveToolDialect } from "../llm/capabilities.js";
 import { syntheticToolCallId, isTextOnlyModel, fromWireName, } from "../llm/tool-protocol.js";
 import { sanitizeAssistantText } from "../ui/ansi-box.js";
 import { randomUUID } from "node:crypto";
 import { jobManager, } from "../tools/jobs.js";
-import { responderContextMessage, upsertResponderContextMessage, upsertResponderResultLedger, } from "./responder-context.js";
+import { isResponderResultLedgerMessage, responderContextMessage, upsertResponderContextMessage, upsertResponderResultLedger, } from "./responder-context.js";
 import { agentModeDirective, planModeDirective, renderAgentSystemPrompt, renderCompactAgentSystemPrompt, scratchDirFor, toolNudge, } from "../prompts/index.js";
 import { getConfig } from "../store/config.js";
 import { beginSessionWorkspace, getActiveSessionWorkspace, } from "../store/session-workspace.js";
 import { groqInputTokenBudget } from "../llm/groq.js";
-import { classifyToolCall, isPentestToolCall, scopeHint, scopeTargetForToolCall, } from "../safety/classifier.js";
+import { classifyToolCall, isPentestToolCall, scopeTargetForToolCall, } from "../safety/classifier.js";
 /**
  * Scope/engagement classification runs on every tool call and parses
  * model-supplied arguments (URLs, hosts, commands). A malformed argument must
@@ -26,20 +28,20 @@ function safeScopeTargetForToolCall(call) {
         return undefined;
     }
 }
-function safeEngagementActionForToolCall(call) {
+function safeEngagementActionsForToolCall(call) {
     try {
-        return engagementActionForToolCall(call);
+        return engagementActionsForToolCall(call);
     }
     catch {
-        return undefined;
+        return [];
     }
 }
 import { availableToolNames, normalizeToolCall, runToolCall, BATCH_SAFE_TOOLS, } from "../tools/registry.js";
-import { getToolDefinitions, getCompactToolDefinitions, PLAN_TOOL_NAMES, } from "../tools/definitions.js";
+import { getToolDefinitions, getCompactToolDefinitions, RUNNER_META_TOOL_NAMES, } from "../tools/definitions.js";
 import { appendAssistantWithTools, ensureUniqueToolCallIds, appendToolResult, assertValidToolProtocol, fillMissingToolResults, repairToolProtocol, } from "./tool-history.js";
 import { formatViewportHint, registerViewport } from "../ui/output-pane.js";
 import { compactMessagesWithSummary, shouldApplyAutoCompact, COMPACTION_MEMORY_PREFIX, PLAN_IMPLEMENT_MEMORY_PREFIX, isCompactionMemoryMessage, } from "./context-manager.js";
-import { buildContextBreakdown, contextBreakdownAuditPayload, } from "./context-breakdown.js";
+import { buildContextBreakdown, contextBreakdownAuditPayload, describeDominantContextBlock, toolSchemaHash, } from "./context-breakdown.js";
 import { autoCompactTriggerTokens, dedupeToolContextOutput, freeTierGuardNotices, getReliabilityPolicy, resolveStepMaxTokens, } from "./reliability-policy.js";
 import { auditLog } from "../store/logs.js";
 import { loadProjectContext } from "../store/project.js";
@@ -52,24 +54,29 @@ import { safeCwd } from "../os/cwd.js";
 import { analyzeTask, formatTaskAnalysisHint, isNarrowExplicitNmapOperation, } from "./task-analyzer.js";
 import { computeMaxIterations, computeStepBudget } from "./step-budget.js";
 import { isScratchOnlyWrite } from "./scratch-write.js";
+import { buildDurableEnvelope, WorkLedger, } from "./durable-envelope.js";
 import { COMPACTION_SYSTEM_PROMPT, } from "./compaction-summary.js";
 import { maybeAppendPlanModeReminder, PLAN_REMINDER_TOAST, } from "./plan-mode-reminders.js";
 import { LoopGuard } from "./loop-guard.js";
-import { loadPlan, savePlan, markTask, appendPlanTask, readyPlanTasks, isPlanTerminal, isPlanSuccessful, } from "../store/plan.js";
-import { fsWrite, isOutsideWorkingDirectory, resolveFsToolPath, } from "../tools/fs.js";
+import { CompactionAttemptLedger, compactionAttemptKey, } from "./compaction-attempt.js";
+import { resolveRequestBudget } from "./request-budget.js";
+import { loadPlan, mutatePlan, markTask, appendPlanTask, readyPlanTasks, foregroundRemaining, responderOpenTasks, isPlanTerminal, isPlanSuccessful, } from "../store/plan.js";
+import { stat } from "node:fs/promises";
+import { isOutsideWorkingDirectory, resolveFsToolPath, } from "../tools/fs.js";
 import { stripSentinelTokens, parseToolCall, recognizeBareToolJson, looksLikeTruncatedToolCall, salvageTruncatedWrite, salvageTruncatedWriteFromNative, countToolFences, parseAllToolCalls, groupToolCallsForExecution, buildTurnHistory, collapseRepeatedText, textBeforeToolCall, formatToolArgs, looksLikePentestTask, looksLikeBuildTask, looksLikeInformationalQuery, looksLikeIdleOrSocialPrompt, looksLikeActionNarration, looksLikeWebActionNarration, looksLikePlanNarration, looksLikeErrorDiagnosisWithFixIntent, localHttpProbeIsFailure, localHttpProbeIsSuccess, requiresFreshWebSearch, freshnessGuardMessage, buildWorkflowDirective, narrowNmapOperationDirective, pentestWorkflowDirective, pentestNoLocalServerDirective, shouldDimToolChatter, looksLikePromptLeak, } from "./tool-call-parser.js";
 import { createSessionPolicy, isPreApprovalAllowedTool, isPlanModeAllowedShellCommand, isPlanModeAllowedTool, isPlanApprovedByStatus, planHasOpenWork, isAbortError, shouldEnableImageOcr, } from "./session-policy.js";
 import { saveToolOutput, summarizeOutput, formatToolContext, } from "./tool-output-formatting.js";
 import { codingSessionFromContext, isProtocolPlaceholderOutput, progressPauseMode, } from "./progress-pause-policy.js";
-import { renderPlanForTerminal, planContextMessage, handlePlanTool, resolvePlanTaskId, } from "./plan-tool.js";
-import { readTaskUpdateArgs, distinctAdvancingTaskIds, isSimultaneousTaskAdvance, batchUpdateSignature, buildMultiUpdateReminder, multiUpdateToast, } from "./task-sync.js";
-import { absorbLooseWorkIntoLedger, applyDestinationCwd, canMarkTaskDone, classifyTaskTitle, hasLocalRuntimeProof, hasRemoteWorkProof, isDevServerCall, isEvidenceWorkTool, isFeatureImplementationCall, isPackageInstallCommand, isPlanPreflightTool, isPortListeningOutput, isReadOnlyReconTool, isRemoteActiveTestCall, isRemoteObservationTask, isRemoteReconToolCall, isRuntimeObservationTask, isScaffoldCreateCommand, isServerReadyOutput, ledgerFromTaskEvidence, pickPendingTaskForToolCall, recordTaskWorkSuccess, resolveUserDestinationHint, taskEvidenceFromLedger, TOOL_ABORT_GRACE_MS, toolHardBudgetMs, toolStallBudgetMs, userAskedForFeatureApp, } from "./task-evidence.js";
+import { renderPlanForTerminal, planContextMessage, upsertPlanContextMessage, handlePlanTool, resolvePlanTaskId, } from "./plan-tool.js";
+import { readDeclaredParentTaskId, resolveResponderParent, isExplicitResponderDelegation, delegationTaskTitle, } from "./responder-parent.js";
+import { readTaskUpdateArgs, distinctAdvancingTaskIds, isSimultaneousTaskAdvance, batchUpdateSignature, buildMultiUpdateReminder, buildMultiOpenRejection, multiUpdateToast, multiOpenToast, openingTaskIds, } from "./task-sync.js";
+import { absorbLooseWorkIntoLedger, applyDestinationCwd, canMarkTaskDone, hasLocalRuntimeProof, hasRemoteWorkProof, isDevServerCall, isEvidenceWorkTool, isFeatureImplementationCall, isPackageInstallCommand, isPlanPreflightTool, isPortListeningOutput, isReadOnlyReconTool, isRemoteActiveTestCall, isRemoteObservationTask, isRemoteReconToolCall, isRuntimeObservationTask, isScaffoldCreateCommand, isServerReadyOutput, ledgerFromTaskEvidence, pickPendingTaskForToolCall, recordTaskWorkSuccess, resolveUserDestinationHint, taskEvidenceFromLedger, TOOL_ABORT_GRACE_MS, toolHardBudgetMs, toolStallBudgetMs, userAskedForFeatureApp, } from "./task-evidence.js";
 import { buildSessionStateBlock, inferNextHint, upsertSessionStateMessage, } from "./session-state.js";
-import { buildContinueOrientation } from "./continue-orient.js";
+import { buildContinueOrientation, } from "./continue-orient.js";
 import { detectPackageManager } from "./workspace-orient.js";
 import { budgetRemaining, consumeBudget, createRecoveryBudgets, freestyleClaimsAppReady, looksLikeShallowPentestReport, recoveryForErrorDiagnosis, recoveryForFailedProbe, recoveryForFreshness, recoveryForMissingFeature, recoveryForMissingPlan, recoveryForNarration, recoveryForPrematureComplete, recoveryForRuntimeVerify, recoveryForShallowPentest, } from "./must-continue.js";
-import { scopeContextMessage } from "./scope-context.js";
-import { EngagementPolicyEngine, actionFromUrl, engagementActionForToolCall, evaluateEngagementAction, } from "../safety/engagement-policy.js";
+import { outOfScopeToolMessage, scopeContextMessage } from "./scope-context.js";
+import { EngagementPolicyEngine, actionFromUrl, engagementActionsForToolCall, evaluateEngagementAction, } from "../safety/engagement-policy.js";
 import { patchPlanMeta } from "../store/plan.js";
 import { extractProjectRootFromPlan, extractProjectRootFromScaffold, extractProjectRootFromText, getActiveProjectRoot, setActiveProjectRootIfValid, } from "./project-root.js";
 import { buildWorkspaceOrientation, discoverImmediateProjectRoots, guessProjectFolderName, isBareParentDirectory, isScaffoldCancelledOutput, scaffoldLooksMaterialized, scaffoldTargetConflictMessage, resolveScaffoldTargetPath, } from "./workspace-orient.js";
@@ -79,28 +86,73 @@ import { composeAgentSystemPrompt } from "./prompt-composer.js";
 import { createGovernorState, governProgress, } from "./evidence-governor.js";
 import { createTurnState, transitionTurn, } from "./turn-state.js";
 import { deriveOutcomeStatus, inferOutcomeKind, openOutcomeState, recordAnswerEvidence, recordFailedHypothesis, recordToolEvidence, saveOutcomeState, validateCriterionEvidence, } from "./outcomes.js";
-import { createTurnOutcome, renderTurnOutcome } from "./turn-outcome.js";
+import { createTurnOutcome, normalizeTurnOutcomeInput, renderTurnOutcome, } from "./turn-outcome.js";
 import { beginEngagementAction, finishEngagementAction, recordEngagementCheckpoint, reconcileEngagementJob, openEngagement, saveEngagement, } from "../store/engagement.js";
 export * from "./tool-call-parser.js";
 export { createSessionPolicy, isPreApprovalAllowedTool, isPlanApprovedByStatus, planHasOpenWork, shouldEnableImageOcr, } from "./session-policy.js";
 export function styleToolChatter(call, text) {
     return shouldDimToolChatter(call) ? chalk.dim(text) : text;
 }
-export function shouldYieldForResponderBeforeReport(plan, runningJobs, notifications, currentNotificationId) {
+/**
+ * A foreground task waits for a responder child only when the plan
+ * Declares that dependency. Report titles carry no scheduling meaning: any
+ * Dependency-ready foreground work is executed while children keep running, and
+ * Their results arrive as addenda.
+ *
+ * A declared dependency blocks only while the child is genuinely live (running
+ * Job or an undelivered/unanalyzed receipt), so an orphaned child can never
+ * Stall the turn forever.
+ */
+export function shouldYieldForDeclaredResponderDependency(plan, runningJobs, notifications, currentNotificationId) {
     if (!plan)
         return false;
     const unfinished = plan.tasks.filter((task) => !task.responderOwned &&
         (task.state === "pending" || task.state === "in_progress"));
-    if (unfinished.length === 0 ||
-        !unfinished.every((task) => classifyTaskTitle(task.title, { planKind: plan.kind }) === "report")) {
+    if (unfinished.length === 0)
         return false;
-    }
-    return (runningJobs.some((job) => job.responder) ||
-        notifications.some((notification) => (!currentNotificationId || notification.id !== currentNotificationId) &&
-            notification.responder &&
+    const childById = new Map(plan.tasks.filter((task) => task.responderOwned).map((task) => [task.id, task]));
+    const isLive = (child) => {
+        if (child.state === "done" || child.state === "skipped" || child.state === "failed") {
+            return false;
+        }
+        const running = runningJobs.some((job) => job.responder &&
+            (job.taskId === child.id || (!!child.jobId && job.id === child.jobId)));
+        if (running)
+            return true;
+        return notifications.some((notification) => notification.responder &&
             !notification.archivedAt &&
             !notification.readAt &&
-            !notification.analyzedAt));
+            !notification.analyzedAt &&
+            (!currentNotificationId || notification.id !== currentNotificationId) &&
+            (notification.taskId === child.id ||
+                (!!child.jobId && notification.jobId === child.jobId)));
+    };
+    return unfinished.every((task) => (task.dependencies ?? []).some((dependency) => {
+        const child = childById.get(dependency);
+        return !!child && isLive(child);
+    }));
+}
+/**
+ * Cancellable backoff. Resolves after `ms`, or rejects immediately if the
+ * signal aborts (double-Esc) so recovery waits never trap a cancelled turn.
+ */
+function delay(ms, signal) {
+    if (ms <= 0)
+        return Promise.resolve();
+    if (signal?.aborted) {
+        return Promise.reject(signal.reason ?? new Error("Aborted"));
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason ?? new Error("Aborted"));
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
 }
 export async function runAgentTurn(prompt, options = {}) {
     const agentMode = options.mode === "plan" || options.mode === "agent" || options.mode === "ask"
@@ -223,33 +275,61 @@ export async function runAgentTurn(prompt, options = {}) {
     };
     /** Strip a known prefix from a string, returning the remainder unchanged. */
     const insertedText = (value, prefix) => value.startsWith(prefix) ? value.slice(prefix.length) : value;
-    /**
-     * Surface the compacted-context summary to both the TUI (via an event)
-     * and, when running with a direct stdout writer, as a rendered box.
-     * Token-count stats are always emitted for logs.
-     */
-    const writeCompacted = (summary, beforeTokens, afterTokens) => {
-        emit({ type: "compacted", summary, beforeTokens, afterTokens });
+    const writeCompactionStarted = (id, beforeTokens) => {
+        emit({ type: "compaction-start", id, beforeTokens });
+        if (writesDirectly) {
+            process.stdout.write(chalk.dim("  ✦ Compacted Context · streaming Markdown\n\n"));
+        }
+    };
+    const writeCompactionDelta = (id, text) => {
+        if (!text)
+            return;
+        emit({ type: "compaction-delta", id, text });
+        if (writesDirectly)
+            process.stdout.write(text);
+    };
+    const writeCompactionCompleted = (id, summary, beforeTokens, afterTokens) => {
+        emit({
+            type: "compaction-completed",
+            id,
+            summary,
+            beforeTokens,
+            afterTokens,
+        });
         if (writesDirectly) {
-            const header = chalk.dim("  \u2726 Compacted Context");
-            const footer = chalk.dim(`  ~${beforeTokens.toLocaleString()} \u2192 ~${afterTokens.toLocaleString()} tokens`);
-            const body = summary ? renderMarkdown(summary) : "(empty summary)";
-            process.stdout.write(`${header}\n\n${body}\n${footer}\n`);
+            const footer = chalk.dim(`\n  ~${beforeTokens.toLocaleString()} → ~${afterTokens.toLocaleString()} tokens`);
+            process.stdout.write(`${footer}\n`);
+        }
+    };
+    const writeCompactionFailed = (id, message, retainedTokens) => {
+        emit({ type: "compaction-failed", id, message, retainedTokens });
+        if (writesDirectly) {
+            process.stdout.write(chalk.yellow(`\n  Compaction failed: ${message} (~${retainedTokens.toLocaleString()} tokens retained)\n`));
         }
     };
     // Points at the live message array so finishTurn can hand the full
     // conversation back to the caller. Assigned once `messages` is built below;
     // all later mutations are in-place so this reference stays current.
     let liveMessages = [];
+    let suppressOutcomeDiagnostics = false;
+    const unreadResponderNotificationIds = new Set();
+    const releaseUnreadResponderClaims = () => {
+        for (const notificationId of unreadResponderNotificationIds) {
+            jobManager.releaseResponderNotificationClaim(notificationId);
+        }
+    };
     const finishTurn = (answer, steps, status = "succeeded", remainingCriteria = [], reason) => {
-        const outcome = createTurnOutcome({
+        releaseUnreadResponderClaims();
+        const outcome = createTurnOutcome(normalizeTurnOutcomeInput({
             status,
             answer,
             steps,
             remainingCriteria,
             reason,
+        }));
+        const rendered = renderTurnOutcome(outcome, {
+            diagnostics: !suppressOutcomeDiagnostics,
         });
-        const rendered = renderTurnOutcome(outcome);
         writeAssistantMessage(rendered);
         if (options.onMessages) {
             try {
@@ -300,6 +380,7 @@ export async function runAgentTurn(prompt, options = {}) {
         // freshness retries — a false "act don't narrate" path burned tokens on
         // web.search recovery loops after a simple "hi".
         const idleOrSocialPrompt = looksLikeIdleOrSocialPrompt(prompt);
+        suppressOutcomeDiagnostics = informationalQuery || idleOrSocialPrompt;
         const freshWebSearchRequired = !buildLikeTurn &&
             !pentestLikeTurn &&
             !idleOrSocialPrompt &&
@@ -325,7 +406,7 @@ export async function runAgentTurn(prompt, options = {}) {
             const base = compact
                 ? getCompactToolDefinitions()
                 : getToolDefinitions();
-            const allow = new Set([...toolNames, ...PLAN_TOOL_NAMES]);
+            const allow = new Set([...toolNames, ...RUNNER_META_TOOL_NAMES]);
             return base.filter((d) => allow.has(d.name));
         };
         let lastAnswer = "";
@@ -446,9 +527,9 @@ export async function runAgentTurn(prompt, options = {}) {
             return sections.join("\n\n");
         };
         const systemSections = [buildSystemContent(nativeToolsActive)];
-        if (activePlan) {
-            systemSections.push(planContextMessage(activePlan, session.planApproved.value));
-        }
+        // The live plan is mutable state: it is injected once as a keyed request
+        // suffix (upsertPlanContextMessage) instead of being frozen into the stable
+        // system prefix, so the model never sees a stale and a fresh plan together.
         // Soft mid-work recovery (any domain): re-attach to jobs / open tasks /
         // last tools after interrupt or "continue" — not a hard gate.
         if (!informationalQuery && !idleOrSocialPrompt) {
@@ -460,6 +541,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 recentJobs: jobManager.getRecentJobs(12, session.sessionId),
                 informationalQuery,
                 idleOrSocial: idleOrSocialPrompt,
+                ...(options.previousTurn ? { previousTurn: options.previousTurn } : {}),
             });
             if (continueBrief) {
                 systemSections.push(continueBrief);
@@ -562,7 +644,7 @@ export async function runAgentTurn(prompt, options = {}) {
             if (!has("plan")) {
                 sections.push({
                     kind: "plan",
-                    content: "ACTIVE PLAN\nNo persisted plan is active for this turn.",
+                    content: "PLAN PROTOCOL\nThe live plan, when one exists, is appended to this request as a single ACTIVE PLAN message. Treat that message as the only authoritative plan state; never rely on plan details quoted in earlier turns.",
                     mandatory: true,
                 });
             }
@@ -613,13 +695,31 @@ export async function runAgentTurn(prompt, options = {}) {
             userMessage,
         ];
         liveMessages = messages;
-        const responderWakeTurn = prompt.startsWith("Responder result arrived");
+        if (activePlan) {
+            upsertPlanContextMessage(messages, planContextMessage(activePlan, session.planApproved.value));
+        }
+        const responderWakeTurn = options.displayPrompt === null &&
+            prompt.startsWith("Responder result arrived");
         const responderWakeNotificationId = responderWakeTurn
             ? /^notification=(.+)$/m.exec(prompt)?.[1]?.trim()
             : undefined;
-        const unreadResponderNotificationIds = new Set();
-        if (responderWakeNotificationId) {
-            unreadResponderNotificationIds.add(responderWakeNotificationId);
+        const responderWakeJobId = responderWakeTurn
+            ? /^job=(.+)$/m.exec(prompt)?.[1]?.trim()
+            : undefined;
+        const responderWakeResultRevision = responderWakeTurn
+            ? Number(/^resultRevision=(\d+)$/m.exec(prompt)?.[1]) || undefined
+            : undefined;
+        const matchesWakeRevision = (notification) => responderWakeResultRevision === undefined ||
+            (notification.resultRevision ?? 1) === responderWakeResultRevision;
+        const wakeNotification = responderWakeNotificationId
+            ? jobManager
+                .getPendingNotifications(session.sessionId)
+                .find((notification) => notification.id === responderWakeNotificationId &&
+                (!responderWakeJobId || notification.jobId === responderWakeJobId) &&
+                matchesWakeRevision(notification))
+            : undefined;
+        if (wakeNotification) {
+            unreadResponderNotificationIds.add(wakeNotification.id);
         }
         const refreshResponderInbox = () => {
             const running = jobManager
@@ -630,6 +730,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     .getPendingNotifications(session.sessionId)
                     .filter((notification) => notification.responder &&
                     unreadResponderNotificationIds.has(notification.id) &&
+                    matchesWakeRevision(notification) &&
                     !notification.readAt &&
                     !notification.analyzedAt &&
                     !notification.archivedAt)
@@ -692,10 +793,44 @@ export async function runAgentTurn(prompt, options = {}) {
         };
         const loopGuard = new LoopGuard();
         const engagementPolicy = new EngagementPolicyEngine();
+        const probeStateKey = (call) => {
+            const project = (job) => job
+                ? [
+                    job.id,
+                    job.status,
+                    job.exitCode ?? null,
+                    job.signal ?? null,
+                    job.stdoutArtifact,
+                    job.artifacts.stdout.bytes,
+                    job.artifacts.stdout.sha256,
+                    job.stderrArtifact,
+                    job.artifacts.stderr.bytes,
+                    job.artifacts.stderr.sha256,
+                ]
+                : undefined;
+            if (call.name === "shell.tail" && typeof call.args.id === "string") {
+                const projected = project(jobManager.getJob(call.args.id));
+                return projected ? JSON.stringify(projected) : undefined;
+            }
+            if (call.name === "shell.jobs") {
+                return JSON.stringify(jobManager
+                    .getRecentJobs(100, session.sessionId)
+                    .map((job) => project(job))
+                    .filter(Boolean));
+            }
+            return undefined;
+        };
         // Track consecutive thinking-only responses so we can nudge the model
         // to actually act instead of silently returning an empty answer.
         let emptyVisibleRetries = 0;
         let retryWithoutThinking = false;
+        // Robust stream-failure recovery. When a provider stream/complete fails we
+        // try working approaches (backoff, compaction, thinking-off, provider
+        // fallback) before surrendering the turn — see ./stream-recovery. Both are
+        // reset on any successful stream so each failure episode gets a fresh
+        // budget and we only give up in the worst case.
+        let allowModelFallback = false;
+        const recoveryState = createStreamRecoveryState();
         // Track tool calls truncated by the token limit so we can ask the model
         // to retry in smaller pieces instead of leaking broken JSON as an answer.
         let truncatedToolRetries = 0;
@@ -777,7 +912,7 @@ export async function runAgentTurn(prompt, options = {}) {
             });
         };
         const reconcileOpenTaskBeforeFinalizing = async () => {
-            const plan = await loadPlan(session.sessionId).catch(() => undefined);
+            let plan = await loadPlan(session.sessionId).catch(() => undefined);
             const open = plan?.tasks.find((task) => task.state === "in_progress" && !task.responderOwned);
             if (!plan || !open)
                 return plan;
@@ -785,42 +920,80 @@ export async function runAgentTurn(prompt, options = {}) {
             if (!gate.ok)
                 return plan;
             const reconciledTaskIds = [open.id];
-            markTask(plan, open.id, "done", "Completion reconciled from verified task evidence.");
+            const working = plan;
+            markTask(working, open.id, "done", "Completion reconciled from verified task evidence.");
             while (true) {
-                const observation = readyPlanTasks(plan).find((task) => isRuntimeObservationTask(task.title) ||
-                    (plan.kind === "pentest" && isRemoteObservationTask(task.title)));
+                const observation = readyPlanTasks(working).find((task) => isRuntimeObservationTask(task.title) ||
+                    (working.kind === "pentest" && isRemoteObservationTask(task.title)));
                 if (!observation)
                     break;
-                const observationGate = completionGateForTask(plan, observation.id);
+                const observationGate = completionGateForTask(working, observation.id);
                 if (!observationGate.ok)
                     break;
-                markTask(plan, observation.id, "done", plan.kind === "pentest"
+                markTask(working, observation.id, "done", working.kind === "pentest"
                     ? "Satisfied by verified remote evidence from the preceding task."
                     : "Satisfied by the verified runtime evidence from the preceding task.");
                 reconciledTaskIds.push(observation.id);
             }
-            if (plan.status === "draft" || plan.status === "approved") {
-                plan.status = "in_progress";
+            if (working.status === "draft" || working.status === "approved") {
+                working.status = "in_progress";
             }
-            if (isPlanTerminal(plan)) {
-                plan.status = isPlanSuccessful(plan) ? "completed" : "abandoned";
+            if (isPlanTerminal(working)) {
+                working.status = isPlanSuccessful(working) ? "completed" : "abandoned";
             }
-            await savePlan(plan).catch(() => undefined);
+            // Replay the same reconciliation as a reducer so a concurrent
+            // responder settlement is preserved instead of overwritten.
+            const reconciledNotes = new Map(reconciledTaskIds.map((id) => [
+                id,
+                working.tasks.find((task) => task.id === id)?.note,
+            ]));
+            const reconcileResult = await mutatePlan(session.sessionId, (draft) => {
+                let changed = false;
+                for (const [id, note] of reconciledNotes) {
+                    const task = draft.tasks.find((candidate) => candidate.id === id);
+                    if (!task || task.state === "done")
+                        continue;
+                    task.state = "done";
+                    if (note !== undefined)
+                        task.note = note;
+                    changed = true;
+                }
+                if (draft.status === "draft" || draft.status === "approved") {
+                    draft.status = "in_progress";
+                    changed = true;
+                }
+                if (isPlanTerminal(draft)) {
+                    draft.status = isPlanSuccessful(draft) ? "completed" : "abandoned";
+                    changed = true;
+                }
+                return changed;
+            }).catch(() => undefined);
+            if (reconcileResult?.ok && reconcileResult.plan)
+                plan = reconcileResult.plan;
             writePlanUpdate(plan, renderPlanForTerminal(plan) + "\n");
             writeNotice("info", `reconciled ${reconciledTaskIds.map((id) => `[${id}]`).join(", ")} from verified evidence`, chalk.dim(`  ℹ reconciled ${reconciledTaskIds.map((id) => `[${id}]`).join(", ")} from verified evidence — no duplicate verification\n`));
             taskWorkLedger = null;
             return plan;
         };
         async function persistProjectRootOnPlan(root) {
-            const live = await loadPlan(session.sessionId).catch(() => undefined);
-            if (!live)
-                return;
             const pm = detectPackageManager(root);
-            patchPlanMeta(live, {
-                projectRoot: root,
-                ...(pm ? { packageManager: pm } : {}),
-            });
-            await savePlan(live).catch(() => undefined);
+            // Metadata patches go through the transactional boundary so a
+            // concurrent task transition or responder settlement is not clobbered.
+            await mutatePlan(session.sessionId, (draft) => {
+                patchPlanMeta(draft, {
+                    projectRoot: root,
+                    ...(pm ? { packageManager: pm } : {}),
+                });
+            }).catch(() => undefined);
+        }
+        /** Persist task evidence without rewriting the whole plan. */
+        async function persistTaskEvidence(taskId, evidence) {
+            await mutatePlan(session.sessionId, (draft) => {
+                const task = draft.tasks.find((candidate) => candidate.id === taskId);
+                if (!task)
+                    return false;
+                task.evidence = evidence;
+            }).catch(() => undefined);
         }
         refreshSessionState = (plan) => {
             if (idleOrSocialPrompt || informationalQuery)
@@ -871,6 +1044,11 @@ export async function runAgentTurn(prompt, options = {}) {
                     : undefined,
             };
             snap.nextHint = inferNextHint(snap);
+            // One live plan copy, refreshed at the same protocol-safe points as
+            // SESSION STATE so advancing tasks are never contradicted by a stale copy.
+            if (p) {
+                upsertPlanContextMessage(messages, planContextMessage(p, session.planApproved.value));
+            }
             upsertSessionStateMessage(messages, buildSessionStateBlock(snap));
         };
         refreshSessionState(activePlan);
@@ -907,7 +1085,10 @@ export async function runAgentTurn(prompt, options = {}) {
             kind: inferOutcomeKind({ userIntent: prompt, buildLike, pentestLike }),
             continueExisting: continueExistingOutcome,
         });
+        loopGuard.restoreCompletedOperations(outcomeState.completedOperations ?? []);
         await saveOutcomeState(outcomeState);
+        // Canonical mutation/artifact ledger feeding the durable compaction envelope.
+        const workLedger = new WorkLedger();
         let governorState = createGovernorState();
         let governorPauseReason;
         let turnState = createTurnState();
@@ -962,10 +1143,54 @@ export async function runAgentTurn(prompt, options = {}) {
                 return release;
             },
         };
+        /**
+         * Apply a salvaged partial write through the NORMAL tool path so the
+         * classifier, scope/engagement gates, confirmation prompt, and receipts
+         * all apply exactly as they would for a model-emitted call. Salvage must
+         * never mutate a file with `confirmed: true`, and an `fs.append` that was
+         * cut off must stay an append (with its precondition) instead of becoming
+         * a full overwrite.
+         */
+        async function applySalvagedWrite(salvaged) {
+            const args = {
+                path: salvaged.path,
+                content: salvaged.content,
+            };
+            if (salvaged.operation === "append") {
+                args.position = "end";
+                if (typeof salvaged.expectedPriorBytes === "number") {
+                    args.expectedPriorBytes = salvaged.expectedPriorBytes;
+                }
+            }
+            const call = {
+                name: salvaged.operation === "append" ? "fs.append" : "fs.write",
+                args,
+            };
+            const eventId = `tool-${++nextToolEventId}`;
+            const res = await executeSingleTool(call, eventId, options.signal || new AbortController().signal);
+            const ok = res.ok && res.result.ok;
+            let bytesOnDisk = Buffer.byteLength(salvaged.content, "utf8");
+            if (ok) {
+                try {
+                    const stats = await stat(resolveFsToolPath(salvaged.path));
+                    bytesOnDisk = stats.size;
+                }
+                catch {
+                    // Keep the content-length estimate when the file cannot be stat'ed.
+                }
+            }
+            return {
+                ok,
+                cancelled: Boolean(res.blockOrCancel),
+                output: res.result.output,
+                bytesOnDisk,
+            };
+        }
         async function executeSingleTool(rawCall, toolEventId, parentSignal) {
             const scratchDir = scratchDirFor(safeCwd());
             let call = normalizeToolCall(rawCall);
             let dispatchedTaskId;
+            let delegation;
             let engagementLease;
             let engagementGraph;
             let engagementRecord;
@@ -986,7 +1211,13 @@ export async function runAgentTurn(prompt, options = {}) {
                 return { ok: true, call, result, contextOutput: recoveryText };
             }
             if (narrowNmapOperation) {
-                const allowed = new Set(["net.scan", "shell.tail", "shell.jobs"]);
+                const allowed = new Set([
+                    "net.scan",
+                    "shell.tail",
+                    "shell.jobs",
+                    "job.read",
+                    "task.read",
+                ]);
                 if (!allowed.has(call.name)) {
                     const reason = `Narrow nmap request: ${call.name} was not run because the user requested only one nmap operation. ` +
                         `Call net.scan with the requested target/options; do not create a plan or add DNS, WHOIS, HTTP, recon, or vulnerability steps.`;
@@ -1026,17 +1257,27 @@ export async function runAgentTurn(prompt, options = {}) {
                     detail: String(retryReasonRaw.detail ?? ""),
                 }
                 : undefined;
-            // Only block identical *failed* re-tries without changed context.
-            // Successful re-calls always run for real — no "already succeeded /
-            // use prior results" nags (those caused model abnormalities).
+            const currentProbeState = probeStateKey(call);
             const loopCheck = loopGuard.shouldBlock(call.name, call.args, {
                 dependenciesChanged: retryDependenciesChanged,
                 environmentChanged: retryEnvironmentChanged,
+                ...(currentProbeState ? { stateKey: currentProbeState } : {}),
                 ...(retryReason ? { retryReason } : {}),
             });
             if (loopCheck.block) {
                 const reason = loopCheck.reason ??
                     `${call.name} previously failed with identical arguments. Change the command/args and retry.`;
+                if (loopCheck.kind === "unchanged-success") {
+                    const result = { ok: true, output: reason, exitCode: 0 };
+                    emitToolResult(toolEventId, result, reason);
+                    return {
+                        ok: true,
+                        call,
+                        result,
+                        contextOutput: reason,
+                        suppressedRepeat: true,
+                    };
+                }
                 writeNotice("warn", reason, chalk.yellow(`  ⚠ ${reason}\n`));
                 const result = { ok: false, output: reason, exitCode: 1 };
                 emitToolResult(toolEventId, result, reason);
@@ -1050,29 +1291,63 @@ export async function runAgentTurn(prompt, options = {}) {
             if (call.name === "plan.create" ||
                 call.name === "task.add" ||
                 call.name === "task.move" ||
+                call.name === "job.read" ||
                 call.name === "task.read" ||
                 call.name === "task.update") {
-                if (call.name === "task.read") {
-                    const notificationId = typeof call.args.notificationId === "string"
+                if (call.name === "job.read" || call.name === "task.read") {
+                    const requestedNotificationId = typeof call.args.notificationId === "string"
                         ? call.args.notificationId.trim()
                         : "";
-                    const notification = jobManager
-                        .getPendingNotifications(session.sessionId)
-                        .find((candidate) => candidate.id === notificationId);
-                    const visible = unreadResponderNotificationIds.has(notificationId);
-                    const marked = Boolean(notification &&
+                    const requestedJobId = typeof call.args.jobId === "string" ? call.args.jobId.trim() : "";
+                    const pending = jobManager.getPendingNotifications(session.sessionId);
+                    const eligible = responderWakeTurn
+                        ? pending.filter(matchesWakeRevision)
+                        : pending;
+                    const byNotification = requestedNotificationId
+                        ? eligible.find((candidate) => candidate.id === requestedNotificationId)
+                        : undefined;
+                    const byJob = requestedJobId
+                        ? eligible.find((candidate) => candidate.jobId === requestedJobId)
+                        : undefined;
+                    const identifiersConflict = Boolean((byNotification && requestedJobId && byNotification.jobId !== requestedJobId) ||
+                        (byJob && requestedNotificationId && byJob.id !== requestedNotificationId));
+                    const notification = identifiersConflict
+                        ? undefined
+                        : (byNotification ?? byJob);
+                    const visible = Boolean(notification && unreadResponderNotificationIds.has(notification.id));
+                    const wakeIdentityMatches = Boolean(responderWakeTurn &&
+                        (requestedNotificationId || requestedJobId) &&
+                        (!requestedNotificationId ||
+                            requestedNotificationId === responderWakeNotificationId) &&
+                        (!requestedJobId || requestedJobId === responderWakeJobId));
+                    const staleWakeSettled = wakeIdentityMatches && !identifiersConflict && !notification;
+                    const persistedRead = Boolean(notification &&
                         visible &&
-                        jobManager.markRead(notificationId, session.sessionId));
-                    const output = marked
-                        ? `Responder notification ${notificationId} marked delivered and read after model analysis.`
-                        : !notificationId
-                            ? "task.read failed: notificationId is required."
-                            : !visible
-                                ? `task.read failed: notification ${notificationId} was not delivered to this model turn. Analyze a delivered result before marking it read.`
-                                : `task.read failed: notification ${notificationId} is unavailable, archived, or its read state could not be persisted.`;
-                    if (marked && notification) {
+                        jobManager.markRead(notification.id, session.sessionId));
+                    const marked = persistedRead || staleWakeSettled;
+                    const identifier = requestedJobId || requestedNotificationId;
+                    const revisionLabel = responderWakeResultRevision
+                        ? ` revision ${responderWakeResultRevision}`
+                        : "";
+                    const output = persistedRead
+                        ? `Responder job ${notification.jobId} (${notification.id}) marked delivered and read after model analysis.`
+                        : staleWakeSettled
+                            ? `Responder result ${identifier}${revisionLabel} was already settled or discarded; the stale wake is acknowledged idempotently.`
+                            : !requestedNotificationId && !requestedJobId
+                                ? `${call.name} failed: jobId or notificationId is required.`
+                                : identifiersConflict
+                                    ? `${call.name} failed: jobId and notificationId refer to different Responder results.`
+                                    : !notification
+                                        ? `${call.name} failed: Responder result ${identifier} is unavailable, consumed, or archived.`
+                                        : !visible
+                                            ? `${call.name} failed: Responder result ${identifier} was not delivered to this model turn. Analyze a delivered result before marking it read.`
+                                            : `${call.name} failed: read state for Responder result ${identifier} could not be persisted.`;
+                    if (persistedRead && notification) {
                         upsertResponderResultLedger(messages, notification);
-                        unreadResponderNotificationIds.delete(notificationId);
+                        unreadResponderNotificationIds.delete(notification.id);
+                    }
+                    else if (staleWakeSettled && responderWakeNotificationId) {
+                        unreadResponderNotificationIds.delete(responderWakeNotificationId);
                     }
                     if (!alreadyPrintedIds.has(toolEventId)) {
                         const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
@@ -1189,7 +1464,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             taskWorkLedger = led;
                             if (planResult.plan && led && led.successWorkCount > 0 && persisted) {
                                 persisted.evidence = taskEvidenceFromLedger(led);
-                                await savePlan(planResult.plan).catch(() => undefined);
+                                await persistTaskEvidence(persisted.id, persisted.evidence);
                             }
                         }
                         else if (stateRaw === "done" && resolved) {
@@ -1198,7 +1473,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 const t = planResult.plan.tasks.find((x) => x.id === resolved);
                                 if (t) {
                                     t.evidence = taskEvidenceFromLedger(taskWorkLedger);
-                                    await savePlan(planResult.plan).catch(() => undefined);
+                                    await persistTaskEvidence(t.id, t.evidence);
                                 }
                             }
                             taskWorkLedger = null;
@@ -1327,7 +1602,18 @@ export async function runAgentTurn(prompt, options = {}) {
                                     livePlanForGate.status === "approved") {
                                     livePlanForGate.status = "in_progress";
                                 }
-                                await savePlan(livePlanForGate).catch(() => undefined);
+                                // Opening a task is a transition applied by
+                                // the reducer, which also enforces the single-active invariant.
+                                await mutatePlan(session.sessionId, (draft) => {
+                                    const target = draft.tasks.find((candidate) => candidate.id === nextPending.id);
+                                    if (!target || target.state === "in_progress")
+                                        return false;
+                                    target.state = "in_progress";
+                                    if (draft.status === "draft" || draft.status === "approved") {
+                                        draft.status = "in_progress";
+                                    }
+                                    return true;
+                                }).catch(() => undefined);
                                 // Preserve evidence already credited to this task (e.g. pentest
                                 // recon that ran before the task was formally opened).
                                 if (!taskWorkLedger ||
@@ -1385,22 +1671,29 @@ export async function runAgentTurn(prompt, options = {}) {
                 alreadyPrintedIds.add(toolEventId);
             }
             const scopeTarget = safeScopeTargetForToolCall(call);
-            const engagementAction = pentestSession || isPentestToolCall(call) || Boolean(scope)
-                ? safeEngagementActionForToolCall(call)
-                : undefined;
-            const engagementDecision = engagementAction
-                ? evaluateEngagementAction(scope, engagementAction)
-                : undefined;
-            if (engagementAction && engagementDecision) {
+            const engagementActions = pentestSession || isPentestToolCall(call) || Boolean(scope)
+                ? safeEngagementActionsForToolCall(call)
+                : [];
+            // The primary action carries the URL/port/path detail used for leases and
+            // network-hop authorization; every action (one per named target) must pass
+            // the scope check below before the tool runs.
+            const engagementAction = engagementActions[0];
+            let engagementDecision;
+            for (const action of engagementActions) {
+                const decisionForAction = evaluateEngagementAction(scope, action);
+                if (!decisionForAction)
+                    continue;
+                if (action === engagementAction)
+                    engagementDecision = decisionForAction;
                 if (scope) {
                     engagementGraph = await openEngagement(scope);
                     engagementRecord = beginEngagementAction(engagementGraph, {
                         tool: call.name,
-                        target: engagementDecision.normalizedTarget || engagementAction.target,
-                        phase: engagementDecision.phase,
-                        capability: engagementDecision.capability,
-                        authorized: engagementDecision.allowed,
-                        reason: engagementDecision.reason,
+                        target: decisionForAction.normalizedTarget || action.target,
+                        phase: decisionForAction.phase,
+                        capability: decisionForAction.capability,
+                        authorized: decisionForAction.allowed,
+                        reason: decisionForAction.reason,
                     });
                     await saveEngagement(engagementGraph);
                 }
@@ -1408,16 +1701,22 @@ export async function runAgentTurn(prompt, options = {}) {
                     ...(engagementGraph ? { engagementId: engagementGraph.id } : {}),
                     ...(engagementRecord ? { actionId: engagementRecord.id } : {}),
                     tool: call.name,
-                    target: engagementDecision.normalizedTarget,
-                    phase: engagementDecision.phase,
-                    capability: engagementDecision.capability,
-                    allowed: engagementDecision.allowed,
-                    reason: engagementDecision.reason,
+                    target: decisionForAction.normalizedTarget,
+                    phase: decisionForAction.phase,
+                    capability: decisionForAction.capability,
+                    allowed: decisionForAction.allowed,
+                    reason: decisionForAction.reason,
                 });
-                if (!engagementDecision.allowed) {
-                    const target = engagementDecision.normalizedTarget || scopeTarget || engagementAction.target;
-                    const reason = `Blocked engagement action for ${target}: ${engagementDecision.reason}. ` +
-                        scopeHint(target);
+                if (!decisionForAction.allowed) {
+                    const target = decisionForAction.normalizedTarget ||
+                        action.target ||
+                        scopeTarget ||
+                        "requested target";
+                    const reason = outOfScopeToolMessage({
+                        target,
+                        reason: decisionForAction.reason,
+                        allowed: scope?.authorizedTargets,
+                    });
                     writeToolBlocked(toolEventId, call.name, reason, chalk.red(`  ✗ ${reason}\n`));
                     const result = { ok: false, output: reason, exitCode: 1 };
                     emitToolResult(toolEventId, result, reason);
@@ -1524,6 +1823,53 @@ export async function runAgentTurn(prompt, options = {}) {
                 const candidate = pickPendingTaskForToolCall(readyPlanTasks(planAtDispatch), call, planAtDispatch.tasks.map((task) => task.title));
                 dispatchedTaskId = candidate?.id;
             }
+            // An explicitly declared responder parent wins over inference.
+            const declaredParent = readDeclaredParentTaskId(call);
+            if (declaredParent) {
+                const resolvedParent = resolveResponderParent({
+                    plan: planAtDispatch,
+                    declared: declaredParent,
+                    activeForegroundTaskIds: dispatchedTaskId ? [dispatchedTaskId] : [],
+                });
+                if (!resolvedParent.ok) {
+                    const reason = `${call.name} failed: ${resolvedParent.reason}`;
+                    const result = { ok: false, output: reason, exitCode: 1 };
+                    emitToolResult(toolEventId, result, reason);
+                    return { ok: false, call, result, contextOutput: reason };
+                }
+                dispatchedTaskId = resolvedParent.taskId ?? dispatchedTaskId;
+            }
+            // For an explicit delegation, create the child subtask before the
+            // Process starts and launch the job already bound to it. The job therefore
+            // Never carries the foreground parent in `taskId`, and settlement has a
+            // Durable row to advance even if this turn dies right after spawn.
+            if (isExplicitResponderDelegation(call) && planAtDispatch) {
+                delegation = { id: `dg-${randomUUID().slice(0, 8)}` };
+                const created = await mutatePlan(session.sessionId, (draft) => {
+                    const parentExists = !!dispatchedTaskId &&
+                        draft.tasks.some((task) => task.id === dispatchedTaskId);
+                    const child = appendPlanTask(draft, {
+                        title: delegationTaskTitle(call),
+                        state: "in_progress",
+                        note: `delegation=${delegation.id} awaiting launch`,
+                        dependencies: [],
+                        resourceLocks: [],
+                        ...(parentExists ? { parentTaskId: dispatchedTaskId } : {}),
+                        responderOwned: true,
+                        delegationId: delegation.id,
+                    });
+                    delegation.taskId = child.id;
+                    return true;
+                }).catch(() => undefined);
+                if (!created?.ok || !delegation.taskId) {
+                    delegation = undefined;
+                    writeNotice("warn", "Responder delegation record could not be persisted — the job will be linked after launch", chalk.yellow("  ⚠ responder delegation record not persisted; linking after launch\n"));
+                }
+                else if (created.plan) {
+                    pendingSessionStatePlan = created.plan;
+                    writePlanUpdate(created.plan, renderPlanForTerminal(created.plan) + "\n");
+                }
+            }
             if (dispatchedTaskId &&
                 (!taskWorkLedger || taskWorkLedger.taskId !== dispatchedTaskId)) {
                 const dispatchedTask = planAtDispatch?.tasks.find((task) => task.id === dispatchedTaskId);
@@ -1532,7 +1878,12 @@ export async function runAgentTurn(prompt, options = {}) {
             if (engagementAction) {
                 engagementLease = engagementPolicy.acquire(scope, engagementAction);
                 if (!engagementLease.decision.allowed) {
-                    const reason = `Blocked engagement action: ${engagementLease.decision.reason}`;
+                    const target = engagementLease.decision.normalizedTarget || engagementAction.target;
+                    const reason = outOfScopeToolMessage({
+                        target,
+                        reason: engagementLease.decision.reason,
+                        allowed: scope?.authorizedTargets,
+                    });
                     const result = { ok: false, output: reason, exitCode: 1 };
                     emitToolResult(toolEventId, result, reason);
                     return { ok: false, call, result, contextOutput: reason };
@@ -1634,7 +1985,9 @@ export async function runAgentTurn(prompt, options = {}) {
                     confirmed: true,
                     userPrompt: prompt,
                     sessionId: session.sessionId,
-                    ...(dispatchedTaskId ? { taskId: dispatchedTaskId } : {}),
+                    ...(delegation?.taskId ? { taskId: delegation.taskId } : {}),
+                    ...(delegation ? { delegationId: delegation.id } : {}),
+                    ...(dispatchedTaskId ? { parentTaskId: dispatchedTaskId } : {}),
                     wakeOnCompletion: true,
                     monitor: {
                         toolName: call.name,
@@ -1745,13 +2098,18 @@ export async function runAgentTurn(prompt, options = {}) {
                 // User Esc/Ctrl+C: force-settle may resolve with a cancel result
                 // instead of throwing — still end the turn as aborted.
                 if (parentSignal.aborted && !stalledByWatchdog && !hardTimedOut) {
-                    writeAbort();
+                    const result = {
+                        ok: false,
+                        output: "Cancelled by user.",
+                        exitCode: 130,
+                    };
+                    emitToolResult(toolEventId, result, result.output);
                     return {
                         ok: false,
                         call,
-                        result: { ok: false, output: "Aborted." },
-                        contextOutput: "Aborted.",
-                        lastAnswer: "Aborted.",
+                        result,
+                        contextOutput: result.output,
+                        aborted: true,
                     };
                 }
                 if (liveBytes > 0) {
@@ -1763,13 +2121,18 @@ export async function runAgentTurn(prompt, options = {}) {
                 jobManager.updateJobStatus(jobId, "failed", 1);
                 if (isAbortError(toolError, toolAc.signal) || forceSettled) {
                     if (parentSignal.aborted && !stalledByWatchdog && !hardTimedOut) {
-                        writeAbort();
+                        const result = {
+                            ok: false,
+                            output: "Cancelled by user.",
+                            exitCode: 130,
+                        };
+                        emitToolResult(toolEventId, result, result.output);
                         return {
                             ok: false,
                             call,
-                            result: { ok: false, output: "Aborted." },
-                            contextOutput: "Aborted.",
-                            lastAnswer: "Aborted.",
+                            result,
+                            contextOutput: result.output,
+                            aborted: true,
                         };
                     }
                     result = {
@@ -1873,6 +2236,27 @@ export async function runAgentTurn(prompt, options = {}) {
                     writeNotice("info", `project root → ${fromScaffold}`, chalk.dim(`  ℹ project root set to ${fromScaffold}\n`));
                 }
             }
+            if (delegation?.taskId && !result.backgroundJob) {
+                // The delegation never became a durable job: settle its child instead of
+                // Leaving a permanently yellow subtask behind.
+                const delegationId = delegation.id;
+                const settledState = result.ok ? "skipped" : "failed";
+                const settlement = await mutatePlan(session.sessionId, (draft) => {
+                    const child = draft.tasks.find((task) => task.delegationId === delegationId);
+                    if (!child)
+                        return false;
+                    child.state = settledState;
+                    child.note = result.ok
+                        ? `delegation=${delegationId} ran in the foreground; no durable job was created`
+                        : `delegation=${delegationId} failed to launch`;
+                    return true;
+                }).catch(() => undefined);
+                if (settlement?.ok && settlement.plan) {
+                    pendingSessionStatePlan = settlement.plan;
+                    writePlanUpdate(settlement.plan, renderPlanForTerminal(settlement.plan) + "\n");
+                }
+                delegation = undefined;
+            }
             if (result.backgroundJob) {
                 const durableJob = jobManager.getJob(result.backgroundJob.id);
                 // Responder linkage is opt-in: only jobs launched with responder:true
@@ -1880,9 +2264,10 @@ export async function runAgentTurn(prompt, options = {}) {
                 // Plain background jobs stay pollable (shell.jobs/shell.tail) as before.
                 if (durableJob?.responder) {
                     const livePlan = await loadPlan(session.sessionId).catch(() => undefined);
-                    let linkedTaskId = dispatchedTaskId;
+                    let linkedTaskId = delegation?.taskId;
                     let linkedParentTaskId;
                     let responderTaskId;
+                    let responderChildId;
                     if (durableJob && livePlan) {
                         const existing = livePlan.tasks.find((task) => task.jobId === durableJob.id);
                         const parentTaskId = dispatchedTaskId && livePlan.tasks.some((task) => task.id === dispatchedTaskId)
@@ -1897,46 +2282,64 @@ export async function runAgentTurn(prompt, options = {}) {
                                 : "in_progress";
                         const note = `job=${durableJob.id} pid=${durableJob.pid ?? "?"} status=${durableJob.status} ` +
                             `artifact=${durableJob.stdoutArtifact}`;
-                        const responderTask = existing ?? appendPlanTask(livePlan, {
-                            title: `Responder · ${durableJob.name ?? durableJob.commandDisplay.slice(0, 96)}`,
-                            state: terminalState,
-                            note,
-                            dependencies: [],
-                            resourceLocks: [],
-                            parentTaskId,
-                            jobId: durableJob.id,
-                            processId: durableJob.pid,
-                            responderOwned: true,
-                        });
-                        responderTask.state = terminalState;
-                        responderTask.note = note;
-                        responderTask.jobId = durableJob.id;
-                        responderTask.processId = durableJob.pid;
-                        responderTask.responderOwned = true;
-                        if (parentTaskId)
-                            responderTask.parentTaskId = parentTaskId;
-                        if (isPlanTerminal(livePlan)) {
-                            livePlan.status = isPlanSuccessful(livePlan)
-                                ? "completed"
-                                : "abandoned";
-                        }
-                        else if (livePlan.status !== "draft") {
-                            livePlan.status = "in_progress";
-                        }
-                        let responderPlanSaved = false;
-                        try {
-                            await savePlan(livePlan);
-                            responderPlanSaved = true;
-                        }
-                        catch {
+                        const responderTitle = `Responder · ${durableJob.name ?? durableJob.commandDisplay.slice(0, 96)}`;
+                        // Upsert the child by delegation/job identity
+                        // inside the transactional boundary. A concurrent settlement that
+                        // already turned the child green is therefore never reverted, and the
+                        // child is never written as the foreground parent.
+                        const upsert = await mutatePlan(session.sessionId, (draft) => {
+                            const target = (durableJob.delegationId
+                                ? draft.tasks.find((task) => task.delegationId === durableJob.delegationId)
+                                : undefined) ??
+                                draft.tasks.find((task) => task.jobId === durableJob.id);
+                            const child = target ??
+                                appendPlanTask(draft, {
+                                    title: responderTitle,
+                                    state: terminalState,
+                                    note,
+                                    dependencies: [],
+                                    resourceLocks: [],
+                                    parentTaskId,
+                                    jobId: durableJob.id,
+                                    processId: durableJob.pid,
+                                    responderOwned: true,
+                                    ...(durableJob.delegationId
+                                        ? { delegationId: durableJob.delegationId }
+                                        : {}),
+                                });
+                            // Never regress a child that process settlement already finished.
+                            const settledTerminal = child.state === "done" || child.state === "failed";
+                            if (!settledTerminal) {
+                                child.state = terminalState;
+                                child.note = note;
+                            }
+                            child.jobId = durableJob.id;
+                            child.processId = durableJob.pid;
+                            child.responderOwned = true;
+                            if (durableJob.delegationId) {
+                                child.delegationId = durableJob.delegationId;
+                            }
+                            if (parentTaskId)
+                                child.parentTaskId = parentTaskId;
+                            if (isPlanTerminal(draft)) {
+                                draft.status = isPlanSuccessful(draft) ? "completed" : "abandoned";
+                            }
+                            else if (draft.status !== "draft") {
+                                draft.status = "in_progress";
+                            }
+                            responderChildId = child.id;
+                            return true;
+                        }).catch(() => undefined);
+                        if (!upsert?.ok || !responderChildId) {
                             writeNotice("warn", `Responder job ${durableJob.id} started, but its plan subtask could not be persisted`, chalk.yellow(`  ⚠ job ${durableJob.id} is running, but task linkage persistence failed\n`));
                         }
-                        if (responderPlanSaved) {
-                            linkedTaskId = responderTask.id;
+                        else {
+                            linkedTaskId = responderChildId;
                             linkedParentTaskId = parentTaskId;
-                            responderTaskId = responderTask.id;
-                            pendingSessionStatePlan = livePlan;
-                            writePlanUpdate(livePlan, renderPlanForTerminal(livePlan) + "\n");
+                            responderTaskId = responderChildId;
+                            pendingSessionStatePlan = upsert.plan ?? livePlan;
+                            const rendered = upsert.plan ?? livePlan;
+                            writePlanUpdate(rendered, renderPlanForTerminal(rendered) + "\n");
                         }
                     }
                     if (durableJob) {
@@ -2021,13 +2424,17 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
                 await saveEngagement(engagementGraph);
             }
+            workLedger.recordToolCall(call, result.ok, savedOutputPath);
+            const completedProbeState = probeStateKey(call);
             const newEvidence = recordToolEvidence(outcomeState, {
                 tool: call.name,
                 callId: toolEventId,
                 ok: result.ok,
+                ...(result.exitCode !== undefined ? { exitCode: result.exitCode } : {}),
                 output: result.output,
                 ...(savedOutputPath ? { artifact: savedOutputPath } : {}),
                 ...(dispatchedTaskId ? { taskId: dispatchedTaskId } : {}),
+                ...(completedProbeState ? { stateKey: completedProbeState } : {}),
                 args: call.args,
             });
             let hypothesisDelta = 0;
@@ -2100,7 +2507,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
             }
             await saveOutcomeState(outcomeState);
-            loopGuard.recordAttempt(step, call.name, call.args, result.ok, result.exitCode, result.output);
+            loopGuard.recordAttempt(step, call.name, call.args, result.ok, result.exitCode, result.output, completedProbeState ? { stateKey: completedProbeState } : undefined);
             // Evidence for verify-before-done: only successful real work counts.
             if (result.ok && isEvidenceWorkTool(call.name)) {
                 const liveAfter = await loadPlan(session.sessionId).catch(() => undefined);
@@ -2172,7 +2579,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                     taskWorkLedger.successWorkCount < absorbed.successWorkCount) {
                                     taskWorkLedger = absorbed;
                                 }
-                                await savePlan(liveAfter).catch(() => undefined);
+                                await persistTaskEvidence(task.id, task.evidence);
                             }
                         }
                     }
@@ -2181,7 +2588,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     const task = liveAfter.tasks.find((candidate) => candidate.id === creditId);
                     if (task) {
                         task.evidence = taskEvidenceFromLedger(taskWorkLedger);
-                        await savePlan(liveAfter).catch(() => undefined);
+                        await persistTaskEvidence(task.id, task.evidence);
                     }
                 }
                 // Do NOT refreshSessionState here. executeSingleTool often finishes
@@ -2249,13 +2656,24 @@ export async function runAgentTurn(prompt, options = {}) {
         // Align with /compact default: small recency + dense memory (not keepRecent=6 fat tails).
         const AUTO_COMPACT_KEEP_RECENT = 2;
         let lastCompactionMsgCount = 0;
+        const compactionAttempts = new CompactionAttemptLedger();
+        let activeCompactionId;
         /** E5: identical tool bodies within this turn → pointer instead of re-append. */
         const toolResultHashes = new Map();
         /** E4: consecutive free-tier stream failures this turn. */
         let freeTierConsecutiveFailures = 0;
         let freeTierLargeContextWarned = false;
-        const summarizeForCompaction = async (summaryPrompt) => {
-            const response = await completeWithProvider({
+        // Surface the free-tier "failed N times / switch provider" advisory at most
+        // once per turn — the recovery planner already narrates each retry, so
+        // repeating this on every failure just adds noise.
+        let freeTierAdvisoryShown = false;
+        const summarizeForCompaction = async (summaryPrompt, stage) => {
+            const streamFinalSummary = stage?.phase !== "map";
+            const compactionId = streamFinalSummary ? activeCompactionId : undefined;
+            const deltaParser = compactionId
+                ? createThinkingStreamParser((text) => writeCompactionDelta(compactionId, text), undefined, { remember: false })
+                : undefined;
+            const request = {
                 provider,
                 model,
                 messages: [
@@ -2263,11 +2681,32 @@ export async function runAgentTurn(prompt, options = {}) {
                     { role: "user", content: summaryPrompt },
                 ],
                 temperature: 0.1,
-                // Prefer dense memory; enough room for findings without forcing a tiny stub.
                 maxTokens: 2_048,
                 signal: options.signal,
+            };
+            const response = await streamWithProvider(request, (token) => deltaParser?.push(token), { onStatus: () => undefined });
+            deltaParser?.finish();
+            const parsed = stripThinking(response.text);
+            if (parsed.visible.trim() || !parsed.hasThinking)
+                return response.text;
+            const retry = await completeWithProvider({
+                ...request,
+                messages: [
+                    {
+                        role: "system",
+                        content: `${COMPACTION_SYSTEM_PROMPT}\nReturn only the continuation-memory summary. Do not include analysis, reasoning, or <think> tags.`,
+                    },
+                    { role: "user", content: summaryPrompt },
+                ],
+                temperature: 0,
+                maxTokens: 8_192,
+                thinking: { enabled: false, effort: "none" },
             });
-            return response.text;
+            const retryVisible = stripThinking(retry.text).visible.trim();
+            if (retryVisible && compactionId) {
+                writeCompactionDelta(compactionId, retryVisible);
+            }
+            return retry.text;
         };
         /**
          * Estimate the complete next model request, including attached native-tool
@@ -2280,20 +2719,85 @@ export async function runAgentTurn(prompt, options = {}) {
             const nextTools = selectToolDefs(native, useCompactSystemPrompt);
             return buildContextBreakdown(contextMessages, nextTools).estimatedTotalTokens;
         };
+        /**
+         * Canonical state that must survive compaction verbatim. Built from the
+         * plan store, outcome contract, responder ledger and mutation ledger — never
+         * from the narrative summary.
+         */
+        async function buildTurnDurableEnvelope() {
+            const plan = (await loadPlan(session.sessionId).catch(() => undefined)) ?? undefined;
+            const root = getActiveProjectRoot() ?? plan?.meta?.projectRoot;
+            const consumed = [];
+            for (const message of messages) {
+                if (!isResponderResultLedgerMessage(message))
+                    continue;
+                for (const line of message.content.split("\n")) {
+                    const match = /notification=(\S+)/.exec(line);
+                    if (match?.[1])
+                        consumed.push(match[1]);
+                }
+            }
+            const unread = jobManager
+                .getPendingNotifications(session.sessionId)
+                .map((notification) => notification.id);
+            const toEnvelopeJob = (job) => ({
+                id: job.id,
+                status: job.status,
+                command: job.commandDisplay || job.command,
+                ...(job.taskId ? { taskId: job.taskId } : {}),
+                ...(job.stdoutArtifact ? { artifact: job.stdoutArtifact } : {}),
+            });
+            const liveJobs = jobManager
+                .getRunningJobs(session.sessionId)
+                .map(toEnvelopeJob);
+            const liveIds = new Set(liveJobs.map((job) => job.id));
+            const finishedJobs = jobManager
+                .getRecentJobs(12, session.sessionId)
+                .filter((job) => !liveIds.has(job.id))
+                .map(toEnvelopeJob);
+            return buildDurableEnvelope({
+                ...(plan ? { plan } : {}),
+                outcome: outcomeState,
+                ledger: workLedger,
+                ...(root ? { projectRoot: root } : {}),
+                ...(root
+                    ? { packageManager: plan?.meta?.packageManager ?? detectPackageManager(root) }
+                    : {}),
+                responder: { unread, consumed: [...new Set(consumed)] },
+                ...(liveJobs.length > 0 ? { liveJobs } : {}),
+                ...(finishedJobs.length > 0 ? { finishedJobs } : {}),
+            });
+        }
         async function maybeAutoCompact(reason, force = false) {
             const beforeTokens = estimateNextRequestTokens(messages);
-            // E1: auto-compact trigger (default 72k soft; hard ceiling 100k).
-            const compactTrigger = autoCompactTriggerTokens();
+            const budget = resolveRequestBudget({ provider, model });
+            const compactTrigger = budget.effectiveTrigger;
             if (!force && beforeTokens < compactTrigger)
                 return;
+            // Structural eligibility only: there must be closed history to summarize.
             if (messages.length <= AUTO_COMPACT_KEEP_RECENT + 2)
                 return;
-            // Avoid compaction loops: don't re-compact until enough new messages have
-            // accumulated since the last compaction.
-            if (messages.length <= lastCompactionMsgCount + 4)
+            const durableEnvelope = await buildTurnDurableEnvelope();
+            const attemptKey = compactionAttemptKey({
+                messages,
+                provider,
+                model,
+                dialect: toolDialect,
+                triggerTokens: compactTrigger,
+                schemaHash: toolSchemaHash(selectToolDefs(nativeToolsActive, useCompactSystemPrompt)),
+                ...(durableEnvelope ? { durableEnvelope } : {}),
+            });
+            if (!force && compactionAttempts.isSuppressed(attemptKey))
                 return;
+            const compactionId = `compact-${randomUUID().slice(0, 12)}`;
+            activeCompactionId = compactionId;
+            writeCompactionStarted(compactionId, beforeTokens);
             try {
-                const result = await compactMessagesWithSummary(messages, summarizeForCompaction, { budgetTokens: 0, keepRecent: AUTO_COMPACT_KEEP_RECENT });
+                const result = await compactMessagesWithSummary(messages, summarizeForCompaction, {
+                    budgetTokens: 0,
+                    keepRecent: AUTO_COMPACT_KEEP_RECENT,
+                    ...(durableEnvelope ? { durableEnvelope } : {}),
+                });
                 const summaryBody = result.messages.find((m) => isCompactionMemoryMessage(m))?.content ??
                     "";
                 if (!shouldApplyAutoCompact({
@@ -2303,9 +2807,27 @@ export async function runAgentTurn(prompt, options = {}) {
                     afterTokens: result.afterTokens,
                     afterMessages: result.messages,
                 })) {
+                    writeCompactionFailed(compactionId, "The generated summary was not accepted; the original context was retained.", beforeTokens);
+                    return;
+                }
+                // otherwise the oversized request is sent anyway and corrective
+                // compaction is suppressed as "already compacted".
+                const candidateTokens = estimateNextRequestTokens(result.messages);
+                if (!force && candidateTokens >= compactTrigger) {
+                    const dominant = describeDominantContextBlock(result.messages);
+                    compactionAttempts.recordFailure(attemptKey);
+                    await auditLog("agent.compact.overflow", {
+                        reason,
+                        candidateTokens,
+                        trigger: compactTrigger,
+                        dominant,
+                    });
+                    writeNotice("warn", `context is still ~${candidateTokens.toLocaleString()} tokens after compaction (limit ~${compactTrigger.toLocaleString()}) — largest block: ${dominant}`, chalk.yellow(`  ⚠ context still ~${candidateTokens.toLocaleString()} tokens after compaction; largest block: ${dominant}\n`));
+                    writeCompactionFailed(compactionId, `Summary remained over the context limit; largest block: ${dominant}.`, beforeTokens);
                     return;
                 }
                 messages.splice(0, messages.length, ...result.messages);
+                compactionAttempts.recordSuccess(attemptKey);
                 loopGuard.resetReadOnly();
                 // Token stats use the same complete request estimate as the trigger.
                 const compactedTokens = estimateNextRequestTokens(messages);
@@ -2313,10 +2835,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 // after older turns (which carried the plan context) were summarized.
                 const livePlan = await loadPlan(session.sessionId).catch(() => undefined);
                 if (livePlan) {
-                    messages.push({
-                        role: "system",
-                        content: planContextMessage(livePlan, session.planApproved.value),
-                    });
+                    upsertPlanContextMessage(messages, planContextMessage(livePlan, session.planApproved.value));
                 }
                 // Re-inject live SESSION STATE after compaction (older flags survive).
                 refreshSessionState(livePlan);
@@ -2337,22 +2856,25 @@ export async function runAgentTurn(prompt, options = {}) {
                             ? PLAN_IMPLEMENT_MEMORY_PREFIX
                             : COMPACTION_MEMORY_PREFIX);
                 // Card shows pre/post of the summarization; plan re-injection is noted.
-                writeCompacted(summaryText, beforeTokens, compactedTokens);
+                writeCompactionCompleted(compactionId, summaryText, beforeTokens, compactedTokens);
                 const planNote = afterTokens > compactedTokens
                     ? ` (compacted to ~${compactedTokens.toLocaleString()}, +plan → ~${afterTokens.toLocaleString()})`
                     : "";
                 writeNotice("info", `context auto-compacted to fit the window (~${beforeTokens.toLocaleString()} → ~${compactedTokens.toLocaleString()} tokens${planNote})`, chalk.dim(`  ℹ context auto-compacted (~${beforeTokens.toLocaleString()} → ~${compactedTokens.toLocaleString()} tokens${planNote})\n`));
             }
             catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeCompactionFailed(compactionId, /aborted/i.test(message) ? "Compaction was cancelled." : message, beforeTokens);
                 if (error instanceof Error &&
                     (error.name === "AbortError" || error.message.includes("aborted"))) {
                     throw error;
                 }
-                // Summarization failed — DO NOT fall back to a mechanical dump. Keep the
-                // current context and continue; we'll try again as it keeps growing.
-                await auditLog("agent.compact.failed", {
-                    reason: error instanceof Error ? error.message : String(error),
-                });
+                compactionAttempts.recordFailure(attemptKey);
+                await auditLog("agent.compact.failed", { reason: message });
+            }
+            finally {
+                if (activeCompactionId === compactionId)
+                    activeCompactionId = undefined;
             }
         }
         for (let iteration = 0; iteration < maxIterations; iteration += 1) {
@@ -2515,16 +3037,17 @@ export async function runAgentTurn(prompt, options = {}) {
                     });
                     try {
                         if (responderDelivery &&
-                            !jobManager.markDelivered(responderDelivery.id)) {
+                            !jobManager.markDeliveryStarted(responderDelivery.id, session.sessionId)) {
                             jobManager.releaseResponderNotificationClaim(responderDelivery.id);
-                            throw new Error(`failed to mark responder notification ${responderDelivery.id} delivered`);
+                            throw new Error(`failed to record responder delivery attempt ${responderDelivery.id}`);
                         }
                         completion = await streamWithProvider({
                             provider,
                             model,
-                            allowModelFallback: false,
+                            allowModelFallback,
                             messages,
-                            temperature: /minimax-m3/i.test(model) ? 1.0 : 0.2,
+                            // Sampling is provider/model policy (llm/sampling.ts).
+                            // Sending a fixed 0.2 here overrode it for every model.
                             maxTokens: stepMaxTokens,
                             signal: options.signal,
                             thinking: retryWithoutThinking
@@ -2663,42 +3186,88 @@ export async function runAgentTurn(prompt, options = {}) {
                             }
                         });
                         freeTierConsecutiveFailures = 0;
+                        // Stream succeeded → the failure episode is over. Reset the recovery
+                        // budget and the one-shot fallback flag so a later, unrelated failure
+                        // starts fresh (and we never give up while making progress).
+                        resetStreamRecoveryState(recoveryState);
+                        allowModelFallback = false;
                     }
                     catch (streamError) {
+                        // User cancelled (double-Esc) — never try to recover, just stop.
+                        if (options.signal?.aborted)
+                            throw streamError;
                         // E4: track free-tier failures for advisory notices (never blocks).
                         freeTierConsecutiveFailures += 1;
-                        for (const notice of freeTierGuardNotices({
-                            provider,
-                            estimatedInputTokens: contextBreakdown.estimatedTotalTokens,
-                            consecutiveFailures: freeTierConsecutiveFailures,
-                        })) {
-                            if (notice.includes("Large context"))
-                                continue; // already shown above
-                            writeNotice("warn", notice, chalk.yellow(`  ⚠ ${notice}\n`));
-                        }
-                        // A fully empty model completion (no text, no tool calls) must not
-                        // kill the turn. It shows up most after auto-compaction, when the
-                        // tail ends on re-injected system context and the model has nothing
-                        // to answer. Append a trailing user nudge (so the turn no longer
-                        // ends on system messages) and retry, bounded like the
-                        // successful-but-empty path below.
-                        if (!options.signal?.aborted &&
-                            isEmptyCompletionError(streamError) &&
-                            emptyVisibleRetries < 3) {
-                            emptyVisibleRetries += 1;
-                            writeNotice("warn", "model streamed an empty response — nudging it to continue", chalk.yellow("  ⚠ model streamed an empty response — nudging it to continue\n"));
-                            messages.push(recoveryUserMessage("Your previous response was empty. Continue the task now: emit your next tool call, " +
-                                "or give your final answer if every required step is already complete and verified. " +
-                                "Do not reply with an empty message."));
-                            continue;
+                        if (!freeTierAdvisoryShown) {
+                            for (const notice of freeTierGuardNotices({
+                                provider,
+                                estimatedInputTokens: contextBreakdown.estimatedTotalTokens,
+                                consecutiveFailures: freeTierConsecutiveFailures,
+                            })) {
+                                if (notice.includes("Large context"))
+                                    continue; // already shown above
+                                writeNotice("warn", notice, chalk.yellow(`  ⚠ ${notice}\n`));
+                                freeTierAdvisoryShown = true;
+                            }
                         }
-                        throw streamError;
+                        // Robust recovery: a single flaky provider/model (empty admission,
+                        // connection glitch, capacity 5xx, rate limit, or an oversized
+                        // request) must not kill the turn. Classify the failure and take a
+                        // bounded, escalating recovery step — back off, compact, drop
+                        // thinking, or let the router fall back to another provider/model.
+                        // We only rethrow (stop the turn) in the worst case: every approach
+                        // for that failure class is exhausted or the total budget is spent.
+                        const failureKind = classifyStreamFailure(streamError);
+                        const plan = planStreamRecovery({
+                            kind: failureKind,
+                            state: recoveryState,
+                        });
+                        if (plan.action === "give-up") {
+                            throw streamError;
+                        }
+                        recordRecoveryAttempt(recoveryState, failureKind);
+                        // The router refuses transparent retries after emission,
+                        // but the recovery ladder may still re-run the step. Say so, since
+                        // the visible answer restarts from scratch.
+                        if (streamAlreadyEmitted(streamError)) {
+                            const restartNotice = "partial answer discarded after a mid-stream failure — the reply restarts below";
+                            writeNotice("warn", restartNotice, chalk.yellow(`  ⚠ ${restartNotice}\n`));
+                        }
+                        if (plan.notice) {
+                            writeNotice("warn", plan.notice, chalk.yellow(`  ⚠ ${plan.notice}\n`));
+                        }
+                        if (plan.disableThinking)
+                            retryWithoutThinking = true;
+                        if (plan.allowModelFallback)
+                            allowModelFallback = true;
+                        if (plan.forceCompact) {
+                            await maybeAutoCompact(`stream-recovery:${failureKind}`, true);
+                        }
+                        if (plan.nudge) {
+                            messages.push(recoveryUserMessage(plan.nudge));
+                        }
+                        if (plan.delayMs > 0) {
+                            emit({
+                                type: "status",
+                                text: `retrying in ${Math.ceil(plan.delayMs / 1000)}s (${failureKind})`,
+                            });
+                            await delay(plan.delayMs, options.signal);
+                        }
+                        continue;
                     }
                 }
                 finally {
                     // Always clear the spinner — abort, network error, or success.
                     spinner.stop();
                 }
+                if (responderDelivery) {
+                    // The result text is now part of this turn, so consumption is durable.
+                    // A stream that aborted or threw above never reaches this point and the
+                    // receipt stays deliverable.
+                    if (!jobManager.markDelivered(responderDelivery.id, session.sessionId)) {
+                        jobManager.releaseResponderNotificationClaim(responderDelivery.id);
+                    }
+                }
                 provider = completion.provider;
                 model = completion.model;
                 if (completion.usage) {
@@ -2707,6 +3276,22 @@ export async function runAgentTurn(prompt, options = {}) {
                         usage: completion.usage,
                         model: completion.model,
                     });
+                    // Cache telemetry: without read/create counts there is no way to tell
+                    // whether the stable prefix is actually being reused.
+                    const cacheRead = completion.usage.cachedPromptTokens ?? 0;
+                    const cacheCreated = completion.usage.cacheCreationTokens ?? 0;
+                    if (cacheRead > 0 || cacheCreated > 0) {
+                        await auditLog("agent.prompt.cache", {
+                            provider: completion.provider,
+                            model: completion.model,
+                            promptTokens: completion.usage.promptTokens,
+                            cacheReadTokens: cacheRead,
+                            cacheCreationTokens: cacheCreated,
+                            hitRatio: completion.usage.promptTokens > 0
+                                ? Number((cacheRead / completion.usage.promptTokens).toFixed(3))
+                                : 0,
+                        });
+                    }
                 }
                 deltaParser?.finish();
                 // Sticky text-only may have flipped dialect during stream retry.
@@ -2838,25 +3423,28 @@ export async function runAgentTurn(prompt, options = {}) {
                             truncatedToolRetries += 1;
                             if (truncatedToolRetries <= 5) {
                                 try {
-                                    const writeResult = await fsWrite(salvaged.path, salvaged.content, { confirmed: true });
+                                    const writeResult = await applySalvagedWrite(salvaged);
                                     if (writeResult.ok) {
                                         const lineCount = salvaged.content.split("\n").length;
                                         writeNotice("info", `native tool call was truncated — salvaged ${lineCount} lines and wrote to ${salvaged.path}`, chalk.cyan(`  ℹ native tool call was truncated — salvaged ${lineCount} lines to ${salvaged.path}\n`));
                                         // Pair assistant tool_calls with synthetic results so the
                                         // next turn is not orphaned, then nudge for append.
-                                        appendAssistantWithTools(messages, assistantText.visible, nativeToolCalls);
+                                        appendAssistantWithTools(messages, assistantText.visible, nativeToolCalls, completion.reasoningBlock);
                                         for (const tc of nativeToolCalls) {
                                             appendToolResult(messages, tc.id, tc.id === writeTc.id
                                                 ? `Tool ${tc.name} result (exit=0, ok=true):\nSalvaged partial write: ${lineCount} lines to ${salvaged.path}`
                                                 : `Tool ${tc.name} result (exit=1, ok=false):\nCancelled — sibling write was truncated and salvaged.`, tc.name, tc.id === writeTc.id);
                                         }
-                                        const priorBytes = Buffer.byteLength(salvaged.content, "utf8");
+                                        const priorBytes = writeResult.bytesOnDisk;
+                                        const salvagedToolName = salvaged.operation === "append"
+                                            ? "fs.append"
+                                            : "fs.write";
                                         const appendNudge = toolsAttached
-                                            ? `Your ${writeTc.name} tool call was cut off at the token limit, but the system salvaged the partial content and wrote ${lineCount} lines (${priorBytes} bytes) to ${salvaged.path}. ` +
+                                            ? `Your ${salvagedToolName} tool call was cut off at the token limit, but the system salvaged the partial content and wrote ${lineCount} lines (file is now ${priorBytes} bytes) to ${salvaged.path}. ` +
                                                 `The file ends with: ${JSON.stringify(salvaged.lastLine)}\n\n` +
                                                 `CONTINUE by calling fs.append now with path=${JSON.stringify(salvaged.path)}, expectedPriorBytes=${priorBytes}, and content set to ONLY the remaining content not already on disk (prefer hundreds of lines per call). ` +
                                                 `Do not re-read the full file; do not re-send content already saved. Use the platform tool interface — no markdown fences.`
-                                            : `Your fs.write tool call was cut off at the token limit, but the system salvaged the partial content and wrote ${lineCount} lines (${priorBytes} bytes) to ${salvaged.path}. ` +
+                                            : `Your ${salvagedToolName} tool call was cut off at the token limit, but the system salvaged the partial content and wrote ${lineCount} lines (file is now ${priorBytes} bytes) to ${salvaged.path}. ` +
                                                 `The file ends with: ${JSON.stringify(salvaged.lastLine)}\n\n` +
                                                 `CONTINUE with ONE large fs.append of the remaining content:\n` +
                                                 '```tool\n{"name":"fs.append","args":{"path":' +
@@ -2990,23 +3578,23 @@ export async function runAgentTurn(prompt, options = {}) {
                         truncatedToolRetries += 1;
                         const salvaged = salvageTruncatedWrite(assistantText.visible);
                         if (salvaged && truncatedToolRetries <= 5) {
-                            // Write the salvaged partial content
+                            // Write the salvaged partial content through the normal
+                            // authorization path (classifier + confirmation + receipt).
                             try {
-                                const writeResult = await fsWrite(salvaged.path, salvaged.content, {
-                                    confirmed: true,
-                                });
+                                const writeResult = await applySalvagedWrite(salvaged);
                                 if (writeResult.ok) {
                                     const lineCount = salvaged.content.split("\n").length;
                                     writeNotice("info", `tool call was truncated — salvaged ${lineCount} lines and wrote to ${salvaged.path}`, chalk.cyan(`  ℹ tool call was truncated — salvaged ${lineCount} lines to ${salvaged.path}\n`));
                                     pushAssistantHistory(stripThinking(assistantText.visible).visible);
-                                    const priorBytes = Buffer.byteLength(salvaged.content, "utf8");
+                                    const priorBytes = writeResult.bytesOnDisk;
+                                    const salvagedToolName = salvaged.operation === "append" ? "fs.append" : "fs.write";
                                     messages.push({
                                         role: "user",
                                         content: toolsAttached
-                                            ? `Your fs.write tool call was cut off at the token limit, but the system salvaged the partial content and wrote ${lineCount} lines (${priorBytes} bytes) to ${salvaged.path}. ` +
+                                            ? `Your ${salvagedToolName} tool call was cut off at the token limit, but the system salvaged the partial content and wrote ${lineCount} lines (file is now ${priorBytes} bytes) to ${salvaged.path}. ` +
                                                 `The file ends with: ${JSON.stringify(salvaged.lastLine)}\n\n` +
                                                 `CONTINUE by calling fs.append now with path=${JSON.stringify(salvaged.path)}, expectedPriorBytes=${priorBytes}, and content set to ONLY the remaining content (prefer large chunks). Use the platform tool interface — no markdown fences.`
-                                            : `Your fs.write tool call was cut off at the token limit, but the system salvaged the partial content and wrote ${lineCount} lines (${priorBytes} bytes) to ${salvaged.path}. ` +
+                                            : `Your ${salvagedToolName} tool call was cut off at the token limit, but the system salvaged the partial content and wrote ${lineCount} lines (file is now ${priorBytes} bytes) to ${salvaged.path}. ` +
                                                 `The file ends with: ${JSON.stringify(salvaged.lastLine)}\n\n` +
                                                 `CONTINUE with ONE large fs.append of the remaining content (prefer hundreds of lines per call — do NOT use tiny ~100-line chunks):\n` +
                                                 '```tool\n{"name":"fs.append","args":{"path":' +
@@ -3055,9 +3643,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         const salvaged = salvageTruncatedWrite(assistantText.visible);
                         if (salvaged) {
                             try {
-                                const writeResult = await fsWrite(salvaged.path, salvaged.content, {
-                                    confirmed: true,
-                                });
+                                const writeResult = await applySalvagedWrite(salvaged);
                                 if (writeResult.ok) {
                                     const lineCount = salvaged.content.split("\n").length;
                                     writeNotice("info", `malformed tool call salvaged — wrote ${lineCount} lines to ${salvaged.path}`, chalk.cyan(`  ℹ malformed tool call salvaged — wrote ${lineCount} lines to ${salvaged.path}\n`));
@@ -3104,7 +3690,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         const unread = [...unreadResponderNotificationIds];
                         pushAssistantHistory(assistantText.visible);
                         messages.push(recoveryUserMessage(`You have ${unread.length} delivered Responder result(s) that remain unread: ${unread.join(", ")}. ` +
-                            "If analysis is incomplete, call the necessary bounded evidence tool now. If you have seen and analyzed each result and are satisfied its responder subtask is finished, you MUST call task.read for each exact notificationId before giving a final response. Do not merely say it is read."));
+                            "If analysis is incomplete, call only the bounded evidence tool needed now. If each result has been analyzed and is satisfactory, you MUST call job.read with its jobId or exact notificationId before giving a final response. job.read does not require an active plan; do not create or update a plan merely to acknowledge a result."));
                         continue;
                     }
                     const narratedAction = looksLikeActionNarration(cleaned);
@@ -3283,7 +3869,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         const livePlan = await loadPlan(session.sessionId).catch(() => undefined);
                         const unfinished = livePlan?.tasks.filter((task) => !task.responderOwned &&
                             (task.state === "pending" || task.state === "in_progress"));
-                        const deferReport = shouldYieldForResponderBeforeReport(livePlan, jobManager.getRunningJobs(session.sessionId), jobManager.getPendingNotifications(session.sessionId), responderWakeNotificationId);
+                        const deferReport = shouldYieldForDeclaredResponderDependency(livePlan, jobManager.getRunningJobs(session.sessionId), jobManager.getPendingNotifications(session.sessionId), responderWakeNotificationId);
                         if (livePlan &&
                             unfinished &&
                             unfinished.length > 0 &&
@@ -3305,9 +3891,17 @@ export async function runAgentTurn(prompt, options = {}) {
                     const remainingCriteria = [];
                     if (session.planApproved.value) {
                         const livePlan = await loadPlan(session.sessionId).catch(() => undefined);
-                        const unfinished = livePlan?.tasks.filter((t) => t.state === "pending" || t.state === "in_progress") ?? [];
-                        const failedTasks = livePlan?.tasks.filter((t) => t.state === "failed") ?? [];
+                        // Foreground work decides the turn outcome. Responder children run
+                        // concurrently by design and are reported separately.
+                        const unfinished = livePlan ? foregroundRemaining(livePlan) : [];
+                        const failedTasks = livePlan?.tasks.filter((task) => !task.responderOwned && task.state === "failed") ?? [];
                         remainingCriteria.push(...unfinished.map((task) => `[${task.id}] ${task.title}`), ...failedTasks.map((task) => `[${task.id}] retry failed task: ${task.title}`));
+                        const openResponderChildren = livePlan
+                            ? responderOpenTasks(livePlan)
+                            : [];
+                        if (openResponderChildren.length > 0) {
+                            remainingCriteria.push(...openResponderChildren.map((task) => `[${task.id}] responder result awaiting analysis: ${task.title}`));
+                        }
                         if (failedTasks.length > 0)
                             outcomeStatus = "failed";
                         else if (unfinished.length > 0)
@@ -3449,7 +4043,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     writeToolCall(deferred.eventId, deferred.call, deferred.rendered);
                 }
                 if (historyNativeCalls.length) {
-                    appendAssistantWithTools(messages, beforeTool ?? "", historyNativeCalls);
+                    appendAssistantWithTools(messages, beforeTool ?? "", historyNativeCalls, completion.reasoningBlock);
                 }
                 else {
                     const standardizedContent = (beforeTool ? beforeTool.trim() + "\n\n" : "") +
@@ -3498,7 +4092,8 @@ export async function runAgentTurn(prompt, options = {}) {
                     if (res.ok && res.call.name === "plan.create") {
                         planCreatedThisTurn = true;
                     }
-                    productiveSteps += 1;
+                    if (!res.suppressedRepeat)
+                        productiveSteps += 1;
                     // E5: collapse identical large tool bodies within this turn to a pointer.
                     const deduped = dedupeToolContextOutput({
                         content: res.contextOutput,
@@ -3663,7 +4258,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     }
                     // User Esc/Ctrl+C only — never cancel siblings because a delete failed
                     // or a confirm was declined; the model must see every tool result.
-                    if (res.lastAnswer === "Aborted.")
+                    if (res.aborted)
                         aborted = true;
                 };
                 // Multi-task sync guard: when one model message advances more than one
@@ -3684,7 +4279,24 @@ export async function runAgentTurn(prompt, options = {}) {
                             : parsed.taskId;
                         intents.push({ call: b.call, taskId: resolvedId, state: parsed.state });
                     }
-                    if (isSimultaneousTaskAdvance(intents)) {
+                    const openIds = openingTaskIds(intents);
+                    if (openIds.length > 1) {
+                        // A multi-open is never confirmable; the store keeps at
+                        // most one active foreground task.
+                        session.pendingTaskBatch.value = undefined;
+                        const openDescriptors = openIds.map((taskId) => ({
+                            taskId,
+                            title: livePlanForBatch?.tasks.find((t) => t.id === taskId)?.title ?? "",
+                            targetState: "in_progress",
+                        }));
+                        batchReminderNote = buildMultiOpenRejection(openDescriptors);
+                        for (const intent of intents) {
+                            if (intent.state === "in_progress")
+                                batchRemindCalls.add(intent.call);
+                        }
+                        writeNotice("warn", multiOpenToast(openIds.length), chalk.yellow(`  ⚠ ${multiOpenToast(openIds.length)}\n`));
+                    }
+                    else if (isSimultaneousTaskAdvance(intents)) {
                         const signature = batchUpdateSignature(intents);
                         if (session.pendingTaskBatch.value === signature) {
                             session.pendingTaskBatch.value = undefined;
@@ -3805,7 +4417,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     return finishTurn("", productiveSteps, "partial", ["Approve or revise the draft plan before implementation."]);
                 }
                 if (aborted) {
-                    lastAnswer = "Aborted.";
+                    lastAnswer = "";
                     outcomeState.outcome.status = "aborted";
                     await saveOutcomeState(outcomeState);
                     moveTurn("aborted", "turn aborted");
@@ -3836,11 +4448,12 @@ export async function runAgentTurn(prompt, options = {}) {
     }
     catch (error) {
         const isAbort = isAbortError(error, options.signal);
-        const msg = isAbort ? "Aborted." : `Error: ${error instanceof Error ? error.message : String(error)}`;
         if (isAbort) {
             writeAbort();
-            return finishTurn(msg, 0, "aborted", [], "The turn was aborted.");
+            return finishTurn("", 0, "aborted");
         }
+        releaseUnreadResponderClaims();
+        const msg = `Error: ${error instanceof Error ? error.message : String(error)}`;
         if (options.onMessages) {
             try {
                 options.onMessages(buildTurnHistory(liveMessages, msg));