@agentclientprotocol/claude-agent-acp 0.77.1-preview.2 → 0.77.1-preview.4

package/dist/acp-agent.js

@@ -27,9 +27,10 @@ import { decodeClaudePermissionResponse } from "./permissions/response.js";
 import { SettingsManager } from "./settings.js";
 import { activeUsageLimitMessage, airSessionFailureCapabilityMeta, assistantMessageText, createSessionFailureState, isSyntheticUsageLimitMessage, providerFailureCategory, SessionFailureController, sessionFailureMeta, supportsAirSessionFailures, } from "./session-failure-extension.js";
 import { billsClaudeSubscription, CLAUDE_SUBSCRIPTION_NOT_SUPPORTED_MESSAGE, CLAUDE_SUBSCRIPTION_NOT_SUPPORTED_REASON, claudeLoginRequiredError, claudeSubscriptionNotSupportedError, holdsNonSubscriptionCredential, refuseClaudeSubscriptionTurn, shouldHideClaudeAuth, warnClaudeSubscriptionGuardDegraded, } from "./hide-claude-auth.js";
-import { AGENT_FILE_CHANGE_REPORT_CAPABILITY, agentFileChangeReportMeta, agentFileChangeReportRequestId, containsFileChangeAuditMarker, createFileChangeAuditSupport, createFileChangeAuditTurnState, FILE_CHANGE_AUDIT_SERVER_NAME, isFileChangeAuditReportPhase, isFileChangeAuditTool, supportsAgentFileChangeReport, } from "./file-change-audit.js";
+import { AGENT_FILE_CHANGE_REPORT_CAPABILITY, agentFileChangeReportMeta, createNativeFileChangeReporter, supportsAgentFileChangeReport, } from "./file-change-audit.js";
 import { ContextCompactionLifecycle, clientSupportsCompactionUpdates, contextCompactionMetadataFromBoundary, isCompactSummaryMessage, } from "./context-compaction.js";
-import { applyTaskCreate, applyTaskList, applyTaskUpdate, clearHookCallbacks, completeHookCallback, createPostToolUseHook, createTaskHook, parseTaskCreateOutput, parseTaskListOutput, parseTaskUpdateOutput, planEntries, registerHookCallback, taskStateToPlanEntries, toolInfoFromToolUse, toolUpdateFromDiffToolResponse, toolUpdateFromToolResult, unregisterHookCallback, } from "./tools.js";
+import { applyTaskCreate, applyTaskList, applyTaskUpdate, clearHookCallbacks, completeHookCallback, createPostToolUseHook, createTaskHook, parseTaskCreateOutput, parseTaskListOutput, parseTaskUpdateOutput, planEntries, registerHookCallback, taskStateToPlanEntries, toolInfoFromToolUse, toolUpdateFromToolResult, unregisterHookCallback, } from "./tools.js";
+import { toolUpdateFromDiffToolResponse } from "./diff.js";
 import { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
 import { acceptedPlanToolResult, ExitPlanCoordinator, executionDiagnostic, exitPlanModeRawOutput, observeExitPlanToolResults, } from "./exit-plan.js";
 import { parseToolResultMeta } from "./tool-result-meta.js";
@@ -779,13 +780,13 @@ export class ClaudeAcpAgent {
             },
             settleCancelledTurn: (original, session, turn) => {
                 disarmForceCancel(session);
-                this.finishFileChangeAudit(session, turn, "cancelled");
+                session.fileChangeReporter?.finish(turn.fileChangeReport, "cancelled");
                 turn.settled = true;
                 turn.resolve({ stopReason: "cancelled", usage: sessionUsage(original) });
             },
             settleFailedTurn: (session, turn, error) => {
                 disarmForceCancel(session);
-                this.finishFileChangeAudit(session, turn, "providerError");
+                session.fileChangeReporter?.finish(turn.fileChangeReport, "providerError");
                 turn.settled = true;
                 turn.reject(error);
             },
@@ -1420,15 +1421,7 @@ export class ClaudeAcpAgent {
         // user message, so the consumer can't promote the turn from the echo.
         const firstText = params.prompt[0]?.type === "text" ? params.prompt[0].text : "";
         const isLocalOnlyCommand = firstText.startsWith("/") && LOCAL_ONLY_COMMANDS.has(firstText.split(" ", 1)[0]);
-        const fileChangeReportRequestId = supportsAgentFileChangeReport(this.clientCapabilities)
-            ? agentFileChangeReportRequestId(params._meta)
-            : undefined;
-        let fileChangeAudit;
-        if (fileChangeReportRequestId &&
-            !session.fileChangeReportRequestIds.has(fileChangeReportRequestId)) {
-            session.fileChangeReportRequestIds.add(fileChangeReportRequestId);
-            fileChangeAudit = createFileChangeAuditTurnState(fileChangeReportRequestId);
-        }
+        const fileChangeReport = session.fileChangeReporter?.request(params._meta);
         const isUsageCommand = params.prompt.length === 1 &&
             params.prompt[0]?.type === "text" &&
             isUsageCommandText(params.prompt[0].text);
@@ -1443,7 +1436,7 @@ export class ClaudeAcpAgent {
             isLocalOnlyCommand,
             ...(isUsageCommand ? { isUsageCommand: true } : {}),
             ...(usageMarkdownAbort ? { usageMarkdownAbort } : {}),
-            ...(fileChangeAudit ? { fileChangeAudit } : {}),
+            ...(fileChangeReport ? { fileChangeReport } : {}),
             settled: false,
             resolve: () => { },
             reject: () => { },
@@ -1803,15 +1796,6 @@ export class ClaudeAcpAgent {
             throw error;
         }
     }
-    /** Publish the audit terminal for every turn path that did not reach the
-     *  report tool. The support flips the turn state synchronously before its
-     *  transport await, so callers can stay fail-open and settle the ACP prompt
-     *  immediately without allowing a racing lifecycle path to publish twice. */
-    finishFileChangeAudit(session, turn, reason) {
-        if (!turn.fileChangeAudit || !session.fileChangeAuditSupport)
-            return;
-        void session.fileChangeAuditSupport.finishUnavailable(turn.fileChangeAudit, reason);
-    }
     /** Lazily start the per-session consumer that drains the SDK query stream for
      *  the session's whole life. Idempotent: only the first `prompt()` starts it. */
     ensureConsumer(session, sessionId) {
@@ -1915,16 +1899,6 @@ export class ClaudeAcpAgent {
                 }
                 return;
             }
-            if (isFileChangeAuditReportPhase(session.activeTurn?.fileChangeAudit) &&
-                (update.sessionUpdate === "agent_message_chunk" ||
-                    update.sessionUpdate === "agent_thought_chunk" ||
-                    update.sessionUpdate === "user_message_chunk" ||
-                    update.sessionUpdate === "tool_call" ||
-                    update.sessionUpdate === "tool_call_update" ||
-                    update.sessionUpdate === "compaction_update" ||
-                    update.sessionUpdate === "compaction_summary_chunk")) {
-                return;
-            }
             if (update.sessionUpdate === "agent_message_chunk") {
                 if (!claudeMeta?.parentToolUseId &&
                     update.content.type === "text" &&
@@ -2093,7 +2067,7 @@ export class ClaudeAcpAgent {
          *  a stamp naming an orphaned command consumes the result outright, and a
          *  stamp naming anything else positively refutes "this is a dead turn's
          *  result", so the dup-over-loss one-skip must not eat it. */
-        const ensureActiveTurn = (resultUserMessageUuid) => {
+        const ensureActiveTurn = async (resultUserMessageUuid) => {
             if (session.activeTurn) {
                 if (!isHeldOpen(session.activeTurn)) {
                     return;
@@ -2115,7 +2089,7 @@ export class ClaudeAcpAgent {
                 // promoted command's own delivery decision is not judged against the
                 // held turn's followup text (issue #453) — the caller snapshots the
                 // flag AFTER this runs.
-                settleActive(session.activeTurn.deferredSettle);
+                await settleActive(session.activeTurn.deferredSettle);
             }
             // Orphan accounting runs BEFORE the head check: an orphan's echo-less
             // result can arrive with an EMPTY queue (the common post-cancel
@@ -2276,10 +2250,10 @@ export class ClaudeAcpAgent {
         /** Settle the active turn's stored deferred outcome once none of its
          *  spawned subagents is live. The single drain rule shared by the
          *  followup-result and idle settle sites, so the two lanes can't drift. */
-        const settleDeferredIfDrained = () => {
+        const settleDeferredIfDrained = async () => {
             const turn = session.activeTurn;
             if (isHeldOpen(turn) && !turnAwaitingSubagents(turn)) {
-                settleActive(turn.deferredSettle);
+                await settleActive(turn.deferredSettle);
             }
         };
         /** Settle the active turn with `outcome` now — unless subagents it
@@ -2288,7 +2262,7 @@ export class ClaudeAcpAgent {
          *  turn that can have spawned subagents must route through here: a site
          *  calling settleActive directly bypasses the hold and re-opens the
          *  out-of-turn permission deadlock (issue #866) through its lane. */
-        const settleOrDefer = (outcome) => {
+        const settleOrDefer = async (outcome) => {
             // No result ends a steered turn: the steer aborted the cycle this result
             // may belong to, and the steered one is still to come. Record the outcome
             // for the idle lane (see Turn.steeredEchoes); later cycles overwrite it,
@@ -2303,19 +2277,29 @@ export class ClaudeAcpAgent {
                 session.activeTurn.deferredSettle = outcome;
             }
             else {
-                settleActive(outcome);
+                await settleActive(outcome);
             }
         };
-        /** Settle the active turn's deferred exactly once, disarm the force-cancel
-         *  backstop (the turn is over), and drop it from the queue. */
-        const settleActive = (result, auditReason = result.stopReason === "cancelled"
+        /** At the actual turn boundary, preview its checkpoint, settle the active
+         *  turn exactly once, disarm the force-cancel backstop, and drop it from
+         *  the queue. Cancellation and provider failures skip checkpoint I/O. */
+        const settleActive = async (result, reportReason = result.stopReason === "cancelled"
             ? "cancelled"
             : "notReported") => {
             const turn = session.activeTurn;
-            if (!turn || turn.settled) {
+            if (!turn || turn.settled || turn.settling) {
                 return;
             }
-            this.finishFileChangeAudit(session, turn, auditReason);
+            turn.settling = true;
+            turn.settlingOutcome = result;
+            if (reportReason === "notReported") {
+                await session.fileChangeReporter?.report(turn, session.query);
+                // cancel() can settle a held turn while the bounded checkpoint preview
+                // is in flight. Its cancellation outcome wins; never settle twice.
+                if (turn.settled || session.activeTurn !== turn)
+                    return;
+            }
+            session.fileChangeReporter?.finish(turn.fileChangeReport, reportReason);
             // Captured before the settled flip below (isHeldOpen tests !settled).
             const wasHeld = isHeldOpen(turn);
             turn.settled = true;
@@ -2350,7 +2334,7 @@ export class ClaudeAcpAgent {
                 this.logger.error(`Session ${params.sessionId}: cannot fail active turn because no unsettled active turn exists: ${error}`);
                 return;
             }
-            this.finishFileChangeAudit(session, turn, "providerError");
+            session.fileChangeReporter?.finish(turn.fileChangeReport, "providerError");
             turn.settled = true;
             session.turnQueue = (session.turnQueue ?? []).filter((t) => t !== turn);
             session.activeTurn = null;
@@ -2413,7 +2397,7 @@ export class ClaudeAcpAgent {
                 return;
             }
             sessionFailures.recordActive(failure);
-            settleActive(turnOutcome(session, "end_turn", sessionFailureMeta(failure)), "providerError");
+            await settleActive(turnOutcome(session, "end_turn", sessionFailureMeta(failure)), "providerError");
         };
         /** Reject every in-flight turn — used when the stream dies. */
         const failAllTurns = (error) => {
@@ -2425,7 +2409,7 @@ export class ClaudeAcpAgent {
             session.turnQueue = [];
             for (const turn of turns) {
                 if (!turn.settled) {
-                    this.finishFileChangeAudit(session, turn, "providerError");
+                    session.fileChangeReporter?.finish(turn.fileChangeReport, "providerError");
                     const wasHeld = isHeldOpen(turn);
                     turn.settled = true;
                     if (wasHeld) {
@@ -2512,7 +2496,7 @@ export class ClaudeAcpAgent {
                             this.trackOrphanCommand(session, active.promptUuid, "started");
                         }
                     }
-                    settleActive(turnOutcome(session, "cancelled"));
+                    await settleActive(turnOutcome(session, "cancelled"));
                     // The cancelled turn's result may never come (that's why the
                     // backstop fired) — close its delivery stretch here so partial
                     // streamed text can't suppress the next turn's issue-#453 fallback.
@@ -2567,7 +2551,7 @@ export class ClaudeAcpAgent {
                     // it), but the stored one is the authoritative source.
                     const inFlight = session.activeTurn;
                     await finishLifecycle(session.cancelled ? "cancelled" : "failed", session.cancelled ? "stopped" : "failed", "at end of stream");
-                    settleActive(session.cancelled
+                    await settleActive(session.cancelled
                         ? turnOutcome(session, "cancelled")
                         : (inFlight?.deferredSettle ?? turnOutcome(session, stopReason)));
                     // Queued turns the SDK never started never ran, so reject them rather
@@ -2577,7 +2561,7 @@ export class ClaudeAcpAgent {
                     // still here was enqueued afterward and was not part of the cancel.)
                     for (const queued of [...(session.turnQueue ?? [])]) {
                         if (!queued.settled) {
-                            this.finishFileChangeAudit(session, queued, "providerError");
+                            session.fileChangeReporter?.finish(queued.fileChangeReport, "providerError");
                             queued.settled = true;
                             queued.reject(RequestError.internalError(undefined, SESSION_ENDED_MESSAGE));
                         }
@@ -2849,7 +2833,7 @@ export class ClaudeAcpAgent {
                                     // when the cancel pre-empted the result (wedge/force-cancel).
                                     if (session.cancelled && session.activeTurn && !session.activeTurn.settled) {
                                         await compaction.reset();
-                                        settleActive(turnOutcome(session, "cancelled"));
+                                        await settleActive(turnOutcome(session, "cancelled"));
                                         // An interrupt can pre-empt the turn's result entirely
                                         // (nothing ran the result-case `finally`), so close the
                                         // delivery stretch here: idle is the SDK's authoritative
@@ -2875,7 +2859,7 @@ export class ClaudeAcpAgent {
                                         if (session.owedTrailingIdles > 0) {
                                             session.owedTrailingIdles--;
                                         }
-                                        settleDeferredIfDrained();
+                                        await settleDeferredIfDrained();
                                     }
                                     else if (session.owedTrailingIdles > 0) {
                                         // Absorb a settled turn's trailing idle. Also covers a
@@ -2907,7 +2891,7 @@ export class ClaudeAcpAgent {
                                             steered.deferredSettle = steered.steeredSettle;
                                             steered.steeredEchoes = undefined;
                                             steered.steeredSettle = undefined;
-                                            settleDeferredIfDrained();
+                                            await settleDeferredIfDrained();
                                         }
                                     }
                                     else if (!session.cancelled &&
@@ -3390,7 +3374,7 @@ export class ClaudeAcpAgent {
                             // the map in that case).
                             if (!isAutonomousResult) {
                                 recordResultForOrphanCommands();
-                                ensureActiveTurn(message.user_message_uuid);
+                                await ensureActiveTurn(message.user_message_uuid);
                                 // Once the submitted goal command has produced its own result,
                                 // no older runtime update can still precede it in the ordered
                                 // SDK stream. Stop suppressing updates even when this runtime
@@ -3560,7 +3544,7 @@ export class ClaudeAcpAgent {
                             // failActive a live turn (the held one, or the user's next
                             // prompt) whose own result recorded a different outcome.
                             if (isAutonomousResult) {
-                                settleDeferredIfDrained();
+                                await settleDeferredIfDrained();
                                 // With no turn in flight OR QUEUED (also after the settle
                                 // above), the stretch holds only autonomous prose — close
                                 // it, so a replayed next prompt isn't silently suppressed by
@@ -3635,7 +3619,7 @@ export class ClaudeAcpAgent {
                                     return;
                                 }
                                 stopReason = "cancelled";
-                                settleOrDefer(turnOutcome(session, "cancelled"));
+                                await settleOrDefer(turnOutcome(session, "cancelled"));
                                 break;
                             }
                             if (pendingExitPlanModeInterruption) {
@@ -3667,7 +3651,7 @@ export class ClaudeAcpAgent {
                                 // settling it out from under them would strand their output
                                 // and permission requests out-of-turn (issue #866's deadlock,
                                 // through the refusal lane).
-                                settleOrDefer(turnOutcome(session, "refusal"));
+                                await settleOrDefer(turnOutcome(session, "refusal"));
                                 break;
                             }
                             // A priority:'now' steer can make the SDK terminate the
@@ -3678,7 +3662,7 @@ export class ClaudeAcpAgent {
                             if (message.is_error &&
                                 isSteering(session.activeTurn) &&
                                 session.activeTurn.steeredEchoes.size > 0) {
-                                settleOrDefer(turnOutcome(session, "end_turn"));
+                                await settleOrDefer(turnOutcome(session, "end_turn"));
                                 break;
                             }
                             if (!message.is_error && lastAssistantModel !== null) {
@@ -3816,7 +3800,7 @@ export class ClaudeAcpAgent {
                                 await compaction.reset();
                             }
                             if (!session.cancelled) {
-                                settleOrDefer(turnOutcome(session, stopReason));
+                                await settleOrDefer(turnOutcome(session, stopReason));
                             }
                         }
                         finally {
@@ -4010,7 +3994,7 @@ export class ClaudeAcpAgent {
                                             session.owedTrailingIdles++;
                                             // Before activateTurn resets the accumulator, so the
                                             // usage still belongs to the cancelled turn.
-                                            settleActive(turnOutcome(session, "cancelled"));
+                                            await settleActive(turnOutcome(session, "cancelled"));
                                         }
                                         else if (isHeldOpen(session.activeTurn)) {
                                             // A turn held open for its background subagents (see
@@ -4020,7 +4004,7 @@ export class ClaudeAcpAgent {
                                             // subagent, but it must not rewrite the stop reason
                                             // either. Its trailing-idle debt stands and is absorbed
                                             // when the drain idle eventually arrives.
-                                            settleActive(session.activeTurn.deferredSettle);
+                                            await settleActive(session.activeTurn.deferredSettle);
                                         }
                                         else if (isSteering(session.activeTurn) &&
                                             session.activeTurn.steeredSettle !== undefined) {
@@ -4036,10 +4020,10 @@ export class ClaudeAcpAgent {
                                             // turn and false-fails it (issue #825). Harmless if it
                                             // never comes: the debt absorbs one future idle.
                                             session.owedTrailingIdles++;
-                                            settleActive(session.activeTurn.steeredSettle);
+                                            await settleActive(session.activeTurn.steeredSettle);
                                         }
                                         else {
-                                            settleActive(turnOutcome(session, "end_turn"));
+                                            await settleActive(turnOutcome(session, "end_turn"));
                                         }
                                     }
                                     // Unlike the no-result teardown lanes, this hand-off must
@@ -4512,7 +4496,7 @@ export class ClaudeAcpAgent {
         if (session.turnQueue) {
             for (const turn of session.turnQueue) {
                 if (turn !== session.activeTurn && !turn.settled) {
-                    this.finishFileChangeAudit(session, turn, "cancelled");
+                    session.fileChangeReporter?.finish(turn.fileChangeReport, "cancelled");
                     turn.settled = true;
                     // Deliberately no `usage`: a queued turn never ran, so the session
                     // accumulator (the active turn's tally) is not its spend.
@@ -4583,20 +4567,18 @@ export class ClaudeAcpAgent {
                 session.pendingEmptyInterruptionDiagnosticCommands.add(turn.promptUuid);
             }
         }
-        // A deferred active turn (see Turn.deferredSettle) already has its
-        // result — it is only held open for its background subagents, which the
-        // interrupt below tears down. Settle it "cancelled" NOW: during the hold
-        // the session is typically already in state idle (the CLI's trailer
-        // fired at the result), so the interrupt may produce no fresh idle for
-        // the consumer's cancelled-settle path to run on, and the cancel would
-        // otherwise stall until the force-cancel backstop. Any outstanding
-        // trailer debt is absorbed by the idle handler when its idle does come.
-        // The turn's own usage snapshot is reported per the cancelled-usage
-        // contract (issue #844).
+        // A deferred active turn (see Turn.deferredSettle) already has its result
+        // and is only held open for subagents. A settling turn likewise has its
+        // result but is awaiting the bounded checkpoint preview. Settle either one
+        // "cancelled" NOW: the consumer cannot process the interrupt's trailing
+        // idle while blocked in that preview, and a held turn may already be idle.
+        // The captured outcome preserves usage and metadata (issue #844), while
+        // reporter state makes a late checkpoint response harmless.
         {
             const active = session.activeTurn;
-            if (isHeldOpen(active)) {
-                this.finishFileChangeAudit(session, active, "cancelled");
+            const pendingOutcome = active?.deferredSettle ?? active?.settlingOutcome;
+            if (active && pendingOutcome && (isHeldOpen(active) || active.settling)) {
+                session.fileChangeReporter?.finish(active.fileChangeReport, "cancelled");
                 active.settled = true;
                 // Mirror settleActive's invariants (it is consumer-scoped and
                 // unreachable from here): disarm the backstop — none should be
@@ -4634,8 +4616,8 @@ export class ClaudeAcpAgent {
                 // from it here.
                 active.resolve({
                     stopReason: "cancelled",
-                    usage: active.deferredSettle.usage,
-                    ...(active.deferredSettle._meta ? { _meta: active.deferredSettle._meta } : {}),
+                    usage: pendingOutcome.usage,
+                    ...(pendingOutcome._meta ? { _meta: pendingOutcome._meta } : {}),
                 });
             }
         }
@@ -4917,13 +4899,6 @@ export class ClaudeAcpAgent {
             })
             : undefined;
         let replayTurnId;
-        // Stop-hook additionalContext is persisted as an internal user message.
-        // Once that marker (or the internal tool itself) appears, suppress the
-        // whole audit exchange until its tool result. This also hides a disobedient
-        // model's separate prose message, while an ordinary next user prompt safely
-        // ends an incomplete audit lane.
-        let replayingFileChangeAudit = false;
-        const replayFileChangeAuditToolUseIds = new Set();
         const nativeReplayEnabled = clientSupportsSubagents(this.clientCapabilities);
         const replayCompactionUpdates = clientSupportsCompactionUpdates(this.clientCapabilities);
         const replayTerminalStates = new Map();
@@ -5075,57 +5050,6 @@ export class ClaudeAcpAgent {
                 if (content === null)
                     continue;
             }
-            const auditBlocks = Array.isArray(content)
-                ? content.filter((block) => typeof block === "object" && block !== null)
-                : [];
-            const hasFileChangeAuditMarker = (typeof content === "string" && containsFileChangeAuditMarker(content)) ||
-                auditBlocks.some((block) => typeof block.text === "string" && containsFileChangeAuditMarker(block.text));
-            const fileChangeAuditToolUseIds = auditBlocks.flatMap((block) => (block.type === "tool_use" ||
-                block.type === "server_tool_use" ||
-                block.type === "mcp_tool_use") &&
-                typeof block.name === "string" &&
-                isFileChangeAuditTool(block.name) &&
-                typeof block.id === "string"
-                ? [block.id]
-                : []);
-            const replayMessageRole = message.message
-                ?.role;
-            if (hasFileChangeAuditMarker || fileChangeAuditToolUseIds.length > 0) {
-                replayingFileChangeAudit = true;
-                for (const toolUseId of fileChangeAuditToolUseIds) {
-                    replayFileChangeAuditToolUseIds.add(toolUseId);
-                }
-                continue;
-            }
-            if (replayingFileChangeAudit) {
-                const toolResultIds = auditBlocks.flatMap((block) => (block.type === "tool_result" || block.type === "mcp_tool_result") &&
-                    typeof block.tool_use_id === "string"
-                    ? [block.tool_use_id]
-                    : []);
-                let completedReport = false;
-                for (const toolUseId of toolResultIds) {
-                    if (replayFileChangeAuditToolUseIds.delete(toolUseId))
-                        completedReport = true;
-                }
-                if (completedReport && replayFileChangeAuditToolUseIds.size === 0) {
-                    replayingFileChangeAudit = false;
-                    continue;
-                }
-                // A denied attempt to call another tool is still part of the hidden
-                // lane. Its result must not end replay suppression before the report.
-                if (toolResultIds.length > 0) {
-                    continue;
-                }
-                // The next real user prompt is already represented by the client and
-                // starts a new turn; do not let a missing audit result hide it or the
-                // rest of the replay.
-                if (replayMessageRole === "user") {
-                    replayingFileChangeAudit = false;
-                }
-                else {
-                    continue;
-                }
-            }
             // Claude persists the retained summary as a user message framed with
             // continuation instructions for the model. Clients on the compaction
             // contract get it materialized as the completed compaction entity at
@@ -5308,26 +5232,6 @@ export class ClaudeAcpAgent {
                     message: "Session not found",
                 };
             }
-            const fileChangeAudit = session.activeTurn?.fileChangeAudit;
-            if (isFileChangeAuditReportPhase(fileChangeAudit)) {
-                // The hidden continuation is an audit-only lane: it may submit the
-                // wrapper-owned report, but it must not run another command after the
-                // user-visible answer has already completed.
-                if (isFileChangeAuditTool(toolName) && fileChangeAudit?.phase === "collecting") {
-                    return { behavior: "allow", updatedInput: toolInput };
-                }
-                return {
-                    behavior: "deny",
-                    message: "Only the internal file-change report is allowed during the audit.",
-                };
-            }
-            // The tool is intentionally unusable outside a negotiated audit turn.
-            if (isFileChangeAuditTool(toolName)) {
-                return {
-                    behavior: "deny",
-                    message: "No file-change report was requested for this turn.",
-                };
-            }
             // When the tool call originates inside a subagent, attribute the eagerly
             // emitted tool_call (and the permission request itself) to the Agent/Task
             // tool call that spawned the subagent, mirroring the streamed subagent
@@ -6042,18 +5946,17 @@ export class ClaudeAcpAgent {
         // below) so the TaskCreated/TaskCompleted hook callbacks can close over
         // the same Map that the streaming message handler will read from.
         const taskState = new Map();
-        // Resolve every workspace root once. The hidden report tool uses this same
-        // set for lexical path validation, and the SDK receives it below.
+        // Resolve every workspace root once. The native checkpoint report uses
+        // this same set for lexical path validation, and the SDK receives it below.
         const acpAdditionalDirectories = params.additionalDirectories ?? sessionMeta?.additionalRoots ?? [];
         const additionalDirectories = [
             ...(userProvidedOptions?.additionalDirectories ?? []),
             ...acpAdditionalDirectories,
         ];
-        const fileChangeAuditSupport = supportsAgentFileChangeReport(this.clientCapabilities)
-            ? createFileChangeAuditSupport({
+        const fileChangeReporter = supportsAgentFileChangeReport(this.clientCapabilities)
+            ? createNativeFileChangeReporter({
                 cwd: params.cwd,
                 additionalDirectories,
-                getActiveState: () => this.sessions[sessionId]?.activeTurn?.fileChangeAudit,
                 publish: async (result) => {
                     await this.client.sessionUpdate({
                         sessionId,
@@ -6118,6 +6021,10 @@ export class ClaudeAcpAgent {
             settingSources: ["user", "project", "local"],
             ...(thinking !== undefined && { thinking }),
             ...userProvidedOptions,
+            // Claude Code uses the same checkpoint store for /rewind. Enable it only
+            // for clients that negotiated per-turn file-change reports; this avoids
+            // snapshot I/O for every other session.
+            ...(fileChangeReporter ? { enableFileCheckpointing: true } : {}),
             ...(settings && { settings }),
             env,
             // Override certain fields that must be controlled by ACP
@@ -6127,9 +6034,6 @@ export class ClaudeAcpAgent {
             mcpServers: {
                 ...(userProvidedOptions?.mcpServers || {}),
                 ...mcpServers,
-                ...(fileChangeAuditSupport
-                    ? { [FILE_CHANGE_AUDIT_SERVER_NAME]: fileChangeAuditSupport.mcpServer }
-                    : {}),
             },
             allowDangerouslySkipPermissions: allowBypass,
             permissionMode: initialPermissionMode,
@@ -6162,14 +6066,6 @@ export class ClaudeAcpAgent {
             tools,
             hooks: {
                 ...userProvidedOptions?.hooks,
-                ...(fileChangeAuditSupport
-                    ? {
-                        PreToolUse: [
-                            ...(userProvidedOptions?.hooks?.PreToolUse || []),
-                            { hooks: [fileChangeAuditSupport.preToolUseHook] },
-                        ],
-                    }
-                    : {}),
                 PostToolUse: [
                     ...(userProvidedOptions?.hooks?.PostToolUse || []),
                     {
@@ -6240,14 +6136,6 @@ export class ClaudeAcpAgent {
                         ],
                     },
                 ],
-                ...(fileChangeAuditSupport
-                    ? {
-                        Stop: [
-                            ...(userProvidedOptions?.hooks?.Stop || []),
-                            { hooks: [fileChangeAuditSupport.stopHook] },
-                        ],
-                    }
-                    : {}),
                 TaskCreated: [
                     ...(userProvidedOptions?.hooks?.TaskCreated || []),
                     {
@@ -6503,8 +6391,7 @@ export class ClaudeAcpAgent {
                 sessionFailureState: createSessionFailureState(),
                 claudeSubscriptionGuard,
                 accountKind: fromAccountInfo(initializationResult.account)?.kind,
-                fileChangeReportRequestIds: new Set(),
-                fileChangeAuditSupport,
+                fileChangeReporter,
             };
             timing.phase("register");
             return {
@@ -7184,7 +7071,7 @@ function isTaskTool(toolName) {
  *  permission-surfaced tool_call for them (see `ensureToolCallEmitted`) must be
  *  resolved explicitly at tool_result time. */
 function shouldEmitToolCall(toolName) {
-    return toolName !== "TodoWrite" && !isTaskTool(toolName) && !isFileChangeAuditTool(toolName);
+    return toolName !== "TodoWrite" && !isTaskTool(toolName);
 }
 /** Build the Claude Code-specific metadata for a tool call. Bash descriptions
  *  are kept out of ACP's standard `title`, which clients may use as the shell
@@ -7354,7 +7241,7 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, clien
     const registerHooks = options?.registerHooks !== false;
     const supportsTerminalOutput = options?.clientCapabilities?._meta?.["terminal_output"] === true;
     if (typeof content === "string") {
-        if (content.length === 0 || containsFileChangeAuditMarker(content)) {
+        if (content.length === 0) {
             return [];
         }
         const update = {
@@ -7388,13 +7275,6 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, clien
     // Unlike `tool_use_result`, entries carry their own tool_use_id, so batched
     // messages need no single-block guard.
     const toolResultMeta = parseToolResultMeta(options?.toolResultMeta);
-    // A report-phase assistant message may contain a short text preface and the
-    // internal tool call in the same content array. Hide the whole message, not
-    // only the tool block, so it stays absent on session replay as well as live.
-    const containsFileChangeAuditToolUse = content.some((chunk) => (chunk.type === "tool_use" ||
-        chunk.type === "server_tool_use" ||
-        chunk.type === "mcp_tool_use") &&
-        isFileChangeAuditTool(chunk.name));
     const output = [];
     // Only handle the first chunk for streaming; extend as needed for batching
     for (const chunk of content) {
@@ -7402,9 +7282,7 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, clien
         switch (chunk.type) {
             case "text":
             case "text_delta": {
-                if (chunk.text &&
-                    !containsFileChangeAuditToolUse &&
-                    !containsFileChangeAuditMarker(chunk.text)) {
+                if (chunk.text) {
                     update = {
                         sessionUpdate: role === "assistant" ? "agent_message_chunk" : "user_message_chunk",
                         content: {
@@ -7416,22 +7294,21 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, clien
                 break;
             }
             case "image":
-                if (!containsFileChangeAuditToolUse)
-                    update = {
-                        sessionUpdate: role === "assistant" ? "agent_message_chunk" : "user_message_chunk",
-                        content: {
-                            type: "image",
-                            data: chunk.source.type === "base64" ? chunk.source.data : "",
-                            mimeType: chunk.source.type === "base64" ? chunk.source.media_type : "",
-                            uri: chunk.source.type === "url" ? chunk.source.url : undefined,
-                        },
-                    };
+                update = {
+                    sessionUpdate: role === "assistant" ? "agent_message_chunk" : "user_message_chunk",
+                    content: {
+                        type: "image",
+                        data: chunk.source.type === "base64" ? chunk.source.data : "",
+                        mimeType: chunk.source.type === "base64" ? chunk.source.media_type : "",
+                        uri: chunk.source.type === "url" ? chunk.source.url : undefined,
+                    },
+                };
                 break;
             case "thinking":
             case "thinking_delta": {
                 // Recent models default `thinking.display` to "omitted", which streams
                 // signature-only thinking blocks whose text is empty.
-                if (chunk.thinking && !containsFileChangeAuditToolUse) {
+                if (chunk.thinking) {
                     update = {
                         sessionUpdate: "agent_thought_chunk",
                         content: {
@@ -7447,11 +7324,7 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, clien
             case "mcp_tool_use": {
                 const alreadyCached = chunk.id in toolUseCache;
                 toolUseCache[chunk.id] = chunk;
-                if (isFileChangeAuditTool(chunk.name)) {
-                    // Wrapper-owned audit protocol: never surface or register generic
-                    // PostToolUse callbacks for the internal tool.
-                }
-                else if (chunk.name === "TodoWrite") {
+                if (chunk.name === "TodoWrite") {
                     // @ts-expect-error - sometimes input is empty object or undefined
                     if (Array.isArray(chunk.input?.todos)) {
                         update = {
@@ -7579,10 +7452,6 @@ export function toAcpNotifications(content, role, sessionId, toolUseCache, clien
                     logger.error(`[claude-agent-acp] Got a tool result for tool use that wasn't tracked: ${chunk.tool_use_id}`);
                     break;
                 }
-                if (isFileChangeAuditTool(toolUse.name)) {
-                    delete toolUseCache[chunk.tool_use_id];
-                    break;
-                }
                 // A permission request may have surfaced a plan-rendered (TodoWrite) or
                 // suppressed (Task*) tool as a real tool_call so the request referenced
                 // a tool call the client knows about (see `ensureToolCallEmitted`,