Load full thread history on session resume

Closes #206

Author: benbrandt

src/CodexAcpClient.ts

@@ -230,14 +230,18 @@ export class CodexAcpClient {
             threadId: request.sessionId,
         });
         onSubscribed?.();
+        const historyResponse = await this.codexClient.threadRead({
+            threadId: response.thread.id,
+            includeTurns: true,
+        });
         const codexModels = await this.fetchAvailableModels();
         const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
         return {
             sessionId: request.sessionId,
             currentModelId: currentModelId,
             models: codexModels,
             currentServiceTier: response.serviceTier as ServiceTier ?? null,
-            thread: response.thread,
+            thread: historyResponse.thread,
         };
     }
 

src/CodexAcpServer.ts

@@ -33,6 +33,7 @@ import {CodexCommands} from "./CodexCommands";
 import type {QuotaMeta} from "./QuotaMeta";
 import {logger} from "./Logger";
 import {sanitizeMcpServerName} from "./McpServerName";
+import {createResponseItemHistoryFallbackUpdates} from "./ResponseItemHistoryFallback";
 import {
     type LegacyLoadSessionResponse,
     type LegacyNewSessionResponse,
@@ -44,6 +45,7 @@ import {
     LEGACY_SET_SESSION_MODEL_METHOD,
 } from "./AcpExtensions";
 import {
+    createCommandExecutionCompleteUpdate,
     createCommandExecutionUpdate,
     createDynamicToolCallUpdate,
     createFileChangeUpdate,
@@ -833,17 +835,29 @@ export class CodexAcpServer implements acp.Agent {
 
     private async streamThreadHistory(sessionId: string, thread: Thread): Promise<void> {
         const session = new ACPSessionConnection(this.connection, sessionId);
+        const sessionState = this.getSessionState(sessionId);
+        const responseItemFallbackUpdates = await createResponseItemHistoryFallbackUpdates(
+            thread,
+            sessionState.terminalOutputMode,
+        );
+        if (responseItemFallbackUpdates) {
+            for (const update of responseItemFallbackUpdates) {
+                await session.update(update);
+            }
+            return;
+        }
+
         for (const turn of thread.turns) {
             for (const item of turn.items) {
-                const updates = await this.createHistoryUpdates(item);
+                const updates = await this.createHistoryUpdates(item, sessionState);
                 for (const update of updates) {
                     await session.update(update);
                 }
             }
         }
     }
 
-    private async createHistoryUpdates(item: ThreadItem): Promise<UpdateSessionEvent[]> {
+    private async createHistoryUpdates(item: ThreadItem, sessionState: SessionState): Promise<UpdateSessionEvent[]> {
         switch (item.type) {
             case "userMessage":
                 return this.createUserMessageUpdates(item);
@@ -859,8 +873,14 @@ export class CodexAcpServer implements acp.Agent {
                 return this.createReasoningUpdates(item);
             case "fileChange":
                 return [await createFileChangeUpdate(item)];
-            case "commandExecution":
-                return [await createCommandExecutionUpdate(item)];
+            case "commandExecution": {
+                const updates = [await createCommandExecutionUpdate(item)];
+                const completeUpdate = createCommandExecutionCompleteUpdate(item, sessionState.terminalOutputMode);
+                if (completeUpdate) {
+                    updates.push(completeUpdate);
+                }
+                return updates;
+            }
             case "mcpToolCall":
                 return [await createMcpToolCallUpdate(item)];
             case "dynamicToolCall":

src/CodexToolCallMapper.ts

@@ -27,6 +27,10 @@ import type {
 } from "./app-server/v2";
 import type { JsonValue } from "./app-server/serde_json/JsonValue";
 import {logger} from "./Logger";
+import {
+    createTerminalOutputMeta,
+    type TerminalOutputMode,
+} from "./TerminalOutputMode";
 
 type CodexItemStatus = CommandExecutionStatus | PatchApplyStatus | McpToolCallStatus | DynamicToolCallStatus;
 type AcpToolCallStatus = "pending" | "in_progress" | "completed" | "failed";
@@ -87,6 +91,47 @@ export async function createCommandExecutionUpdate(item: CommandExecutionItem):
     }, item.id, item.cwd);
 }
 
+export function createCommandExecutionCompleteUpdate(
+    item: CommandExecutionItem,
+    terminalOutputMode: TerminalOutputMode,
+): UpdateSessionEvent | null {
+    if (item.status === "inProgress") {
+        return null;
+    }
+
+    const update: UpdateSessionEvent = {
+        sessionUpdate: "tool_call_update",
+        toolCallId: item.id,
+        status: item.status === "completed" ? "completed" : "failed",
+        rawOutput: {
+            formatted_output: item.aggregatedOutput ?? "",
+            exit_code: item.exitCode,
+        },
+    };
+
+    if (!commandExecutionUsesTerminalOutput(item)) {
+        return update;
+    }
+
+    const terminalMeta: Record<string, unknown> = {};
+    if (item.aggregatedOutput) {
+        Object.assign(
+            terminalMeta,
+            createTerminalOutputMeta(terminalOutputMode, item.id, item.aggregatedOutput),
+        );
+    }
+    terminalMeta["terminal_exit"] = {
+        exit_code: item.exitCode,
+        signal: null,
+        terminal_id: item.id,
+    };
+
+    return {
+        ...update,
+        _meta: terminalMeta,
+    };
+}
+
 export async function createMcpToolCallUpdate(
     item: ThreadItem & { type: "mcpToolCall" }
 ): Promise<UpdateSessionEvent> {
@@ -334,12 +379,12 @@ export function formatWebSearchTitle(item: WebSearchItem): string {
     }
 }
 
-function createCommandActionEvent(
+export function createCommandActionEvent(
     id: string,
     status: CommandExecutionStatus,
     cwd: string,
     commandAction: CommandAction
-): UpdateSessionEvent {
+): AcpToolCallEvent {
     const acpStatus = toAcpStatus(status);
     switch (commandAction.type) {
         case "read":
@@ -395,7 +440,7 @@ function createTerminalCommandEvent(
     event: AcpToolCallEvent,
     terminalId: string,
     cwd: string,
-): UpdateSessionEvent {
+): AcpToolCallEvent {
     const { rawInput, ...eventWithoutRawInput } = event;
     return {
         ...eventWithoutRawInput,