remote-codex 0.11.38 → 0.11.40

package/packages/claude/src/runtimeAdapter.test.ts

@@ -22,6 +22,11 @@ function wait(ms = 0) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function uuidV7At(timestamp = Date.now()) {
+  const timestampHex = Math.trunc(timestamp).toString(16).padStart(12, '0');
+  return `${timestampHex.slice(0, 8)}-${timestampHex.slice(8)}-7000-8000-000000000001`;
+}
+
 class FakeQuery implements Query {
   interrupted = false;
   closed = false;
@@ -541,6 +546,7 @@ describe('ClaudeRuntimeAdapter', () => {
 
   it('reconciles active multimodal transcript turns back to the live runtime turn id', async () => {
     let queryMessages: SDKMessage[] = [systemInit()];
+    const currentMessageUuid = uuidV7At();
     const adapter = new ClaudeRuntimeAdapter({
       home: '/tmp/claude-home',
       command: 'claude',
@@ -556,7 +562,7 @@ describe('ClaudeRuntimeAdapter', () => {
       getSessionMessages: (async () => [
         {
           type: 'user',
-          uuid: '019e4657-bd3c-72d1-b59d-324ed8a4b1ec',
+          uuid: currentMessageUuid,
           session_id: 'claude-session-1',
           message: {
             role: 'user',
@@ -609,6 +615,99 @@ describe('ClaudeRuntimeAdapter', () => {
     expect(reloadedSession.turns[0]?.providerTurnId).toBe(started.providerTurnId);
   });
 
+  it('does not reconcile an old matching user-only turn as the active turn', async () => {
+    const historicalMessageUuid = uuidV7At(Date.now() - 10 * 60_000);
+    const adapter = new ClaudeRuntimeAdapter({
+      home: '/tmp/claude-home',
+      command: 'claude',
+      query: (() => new FakeQuery([systemInit()], { holdOpen: true })) as any,
+      listSessions: (async () => [] satisfies SDKSessionInfo[]) as any,
+      getSessionInfo: (async () => ({
+        sessionId: 'claude-session-1',
+        summary: 'Existing session',
+        cwd: '/tmp/workspace',
+      })) as any,
+      getSessionMessages: (async () => [{
+        type: 'user',
+        uuid: historicalMessageUuid,
+        session_id: 'claude-session-1',
+        message: { role: 'user', content: 'Repeat this prompt' },
+        parent_tool_use_id: null,
+      }] satisfies SessionMessage[]) as any,
+    });
+
+    const started = await adapter.startTurn({
+      providerSessionId: 'claude-session-1',
+      prompt: 'Repeat this prompt',
+      model: 'sonnet',
+      workspacePath: '/tmp/workspace',
+    });
+    const session = await adapter.readSession('claude-session-1');
+
+    expect(session.turns).toHaveLength(1);
+    expect(session.turns[0]).toMatchObject({
+      providerTurnId: `claude-turn-${historicalMessageUuid}`,
+      status: 'completed',
+    });
+
+    await adapter.interruptTurn({
+      providerSessionId: 'claude-session-1',
+      providerTurnId: started.providerTurnId,
+    });
+  });
+
+  it('reconciles only the current prompt when an older user-only turn exists', async () => {
+    const historicalMessageUuid = uuidV7At(Date.now() - 10 * 60_000);
+    const currentMessageUuid = uuidV7At();
+    const adapter = new ClaudeRuntimeAdapter({
+      home: '/tmp/claude-home',
+      command: 'claude',
+      query: (() => new FakeQuery([systemInit()], { holdOpen: true })) as any,
+      listSessions: (async () => [] satisfies SDKSessionInfo[]) as any,
+      getSessionInfo: (async () => ({
+        sessionId: 'claude-session-1',
+        summary: 'Existing session',
+        cwd: '/tmp/workspace',
+      })) as any,
+      getSessionMessages: (async () => [
+        {
+          type: 'user',
+          uuid: historicalMessageUuid,
+          session_id: 'claude-session-1',
+          message: { role: 'user', content: 'An older prompt' },
+          parent_tool_use_id: null,
+        },
+        {
+          type: 'user',
+          uuid: currentMessageUuid,
+          session_id: 'claude-session-1',
+          message: { role: 'user', content: 'The current prompt' },
+          parent_tool_use_id: null,
+        },
+      ] satisfies SessionMessage[]) as any,
+    });
+
+    const started = await adapter.startTurn({
+      providerSessionId: 'claude-session-1',
+      prompt: 'The current prompt',
+      model: 'sonnet',
+      workspacePath: '/tmp/workspace',
+    });
+    const session = await adapter.readSession('claude-session-1');
+
+    expect(session.turns.map((turn) => turn.providerTurnId)).toEqual([
+      `claude-turn-${historicalMessageUuid}`,
+      started.providerTurnId,
+    ]);
+    expect(session.turns[0]?.items[0]).toMatchObject({ text: 'An older prompt' });
+    expect(session.turns[1]).toMatchObject({ status: 'inProgress' });
+
+    await adapter.interruptTurn({
+      providerSessionId: 'claude-session-1',
+      providerTurnId: started.providerTurnId,
+    });
+  });
+
   it('keeps image blocks visible when reading Claude session history', async () => {
     const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'claude-history-image-'));
     const adapter = new ClaudeRuntimeAdapter({
@@ -824,6 +923,91 @@ describe('ClaudeRuntimeAdapter', () => {
     heldQuery.close();
   });
 
+  it('keeps an active Claude session running when its detail is re-read', async () => {
+    const heldQuery = new FakeQuery([systemInit()], { holdOpen: true });
+    const adapter = makeAdapter((prompt) => {
+      if (prompt === hiddenInitPrompt()) {
+        return [systemInit(), result()];
+      }
+      return heldQuery;
+    });
+
+    await adapter.startSession({
+      cwd: '/tmp/workspace',
+      model: 'sonnet',
+      approvalMode: 'guarded',
+      sandboxMode: 'workspace-write',
+    });
+    await adapter.startTurn({
+      providerSessionId: 'claude-session-1',
+      providerTurnId: 'turn-1',
+      prompt: 'Keep running',
+    } as any);
+    await wait();
+
+    await expect(adapter.readSession('claude-session-1')).resolves.toMatchObject({
+      providerSessionId: 'claude-session-1',
+      status: 'running',
+    });
+
+    heldQuery.close();
+  });
+
+  it('emits complete assistant progress messages before the Claude turn finishes', async () => {
+    const heldQuery = new FakeQuery([
+      systemInit(),
+      {
+        type: 'assistant',
+        message: {
+          id: 'msg_progress',
+          type: 'message',
+          role: 'assistant',
+          model: 'sonnet',
+          content: [{ type: 'text', text: 'I found the failing integration.' }],
+          usage: {} as any,
+        },
+        parent_tool_use_id: null,
+        uuid: '00000000-0000-4000-8000-000000000050' as any,
+        session_id: 'claude-session-1',
+      },
+    ], { holdOpen: true });
+    const adapter = makeAdapter((prompt) => {
+      if (prompt === hiddenInitPrompt()) {
+        return [systemInit(), result()];
+      }
+      return heldQuery;
+    });
+    const events: AgentRuntimeEvent[] = [];
+    adapter.on('event', (event) => events.push(event));
+
+    await adapter.startSession({
+      cwd: '/tmp/workspace',
+      model: 'sonnet',
+      approvalMode: 'guarded',
+      sandboxMode: 'workspace-write',
+    });
+    await adapter.startTurn({
+      providerSessionId: 'claude-session-1',
+      providerTurnId: 'turn-1',
+      prompt: 'Investigate the failure',
+    } as any);
+    await wait();
+
+    expect(events).toContainEqual(
+      expect.objectContaining({
+        type: 'item.completed',
+        item: expect.objectContaining({
+          id: 'msg_progress:content:0',
+          kind: 'agentMessage',
+          text: 'I found the failing integration.',
+        }),
+      }),
+    );
+    expect(events.some((event) => event.type === 'turn.completed')).toBe(false);
+
+    heldQuery.close();
+  });
+
   it('merges adjacent Claude thinking blocks into one reasoning item', () => {
     const items = assistantMessageToHistoryItems({
       messageId: 'msg_1',
@@ -1988,7 +2172,11 @@ describe('ClaudeRuntimeAdapter', () => {
               : null,
         )
         .filter(Boolean),
-    ).toEqual(['claude-turn-visible', 'claude-turn-visible']);
+    ).toEqual([
+      'claude-turn-visible',
+      'claude-turn-visible',
+      'claude-turn-visible',
+    ]);
   });
 
   it('interrupts an active query', async () => {

package/packages/claude/src/runtimeAdapter.ts

@@ -247,6 +247,33 @@ interface ActiveClaudeTurn {
 }
 
 const promptPhotoTokenPattern = /\[PHOTO\s+([^\]]+)\]/g;
+const activeTranscriptMatchWindowMs = 120_000;
+
+function normalizePromptForTurnReconciliation(value: string) {
+  return value
+    // Claude history can rewrite or omit an image marker. The surrounding
+    // text and UUIDv7 timestamp remain stable reconciliation identifiers.
+    .replace(/\[PHOTO\s+[^\]]+\]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function userPromptForTurn(turn: AgentTurn) {
+  return turn.items.find((item) => item.kind === 'userMessage')?.text ?? null;
+}
+
+function isRecentActiveTranscriptTurn(turn: AgentTurn, activeStartedAt: string) {
+  if (!turn.startedAt) {
+    return true;
+  }
+  const transcriptStartedAt = Date.parse(turn.startedAt);
+  const activeStartedAtMs = Date.parse(activeStartedAt);
+  return (
+    !Number.isFinite(transcriptStartedAt)
+    || !Number.isFinite(activeStartedAtMs)
+    || Math.abs(transcriptStartedAt - activeStartedAtMs) <= activeTranscriptMatchWindowMs
+  );
+}
 
 function mimeTypeForImagePath(filePath: string) {
   const extension = path.extname(filePath).toLowerCase();
@@ -1503,6 +1530,12 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     return {
       ...summary,
       cwd,
+      // Claude's persisted session metadata remains "idle" while a query is
+      // streaming. The in-memory runtime is authoritative for that interval:
+      // returning the stale persisted status makes detail polling clear the
+      // active provider turn, which in turn drops live tool items from the
+      // transcript until Claude writes its final history record.
+      status: activeTurn ? 'running' : summary.status,
       turns: this.reconcileActiveTranscriptTurn(providerSessionId, turns, activeTurn),
     };
   }
@@ -1760,12 +1793,17 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     const activeItems = [...activeTurn.itemOrder]
       .map((itemId) => activeTurn.items.get(itemId))
       .filter((item): item is AgentHistoryItem => Boolean(item));
-    const transcriptTurnIndex = turns.findLastIndex(
-      (turn) =>
-        turn.status === 'completed' &&
-        turn.items.some((item) => item.kind === 'userMessage') &&
-        !turn.items.some((item) => item.kind === 'agentMessage'),
-    );
+    const normalizedPrompt = normalizePromptForTurnReconciliation(prompt);
+    const transcriptTurnIndex = turns.findLastIndex((turn) => {
+      const transcriptPrompt = userPromptForTurn(turn);
+      return (
+        turn.status === 'completed'
+        && transcriptPrompt !== null
+        && normalizePromptForTurnReconciliation(transcriptPrompt) === normalizedPrompt
+        && !turn.items.some((item) => item.kind === 'agentMessage')
+        && isRecentActiveTranscriptTurn(turn, activeTurn.startedAt)
+      );
+    });
 
     if (transcriptTurnIndex < 0) {
       return turns;
@@ -1778,6 +1816,14 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         aliases = new Map();
         this.historicalTurnIdAliases.set(providerSessionId, aliases);
       }
+      for (const [historicalTurnId, displayTurnId] of aliases) {
+        if (
+          displayTurnId === activeTurn.providerTurnId
+          && historicalTurnId !== transcriptTurn.providerTurnId
+        ) {
+          aliases.delete(historicalTurnId);
+        }
+      }
       aliases.set(transcriptTurn.providerTurnId, activeTurn.providerTurnId);
     }
 
@@ -1806,9 +1852,20 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     if (!aliases || aliases.size === 0) {
       return turns;
     }
+    const rawTurnIds = new Set(turns.map((turn) => turn.providerTurnId));
+    const usedTurnIds = new Set<string>();
     return turns.map((turn) => {
       const providerTurnId = aliases.get(turn.providerTurnId);
-      return providerTurnId ? { ...turn, providerTurnId } : turn;
+      if (
+        !providerTurnId
+        || usedTurnIds.has(providerTurnId)
+        || (providerTurnId !== turn.providerTurnId && rawTurnIds.has(providerTurnId))
+      ) {
+        usedTurnIds.add(turn.providerTurnId);
+        return turn;
+      }
+      usedTurnIds.add(providerTurnId);
+      return { ...turn, providerTurnId };
     });
   }
 
@@ -2054,9 +2111,15 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
         const existing = state.items.get(nextItem.id);
         addOrUpdateItem(state, nextItem);
-        if (nextItem.kind !== 'agentMessage' && !existing) {
+        if (nextItem.kind === 'agentMessage') {
+          // Unlike stream_event text deltas, complete assistant messages are
+          // delivered as SDK assistant events. Emit these immediately so
+          // progress text between Claude tool calls is visible before the
+          // enclosing turn finishes.
+          this.emitItem(state, nextItem, 'item.completed', { force: true });
+        } else if (!existing) {
           this.emitItem(state, nextItem, 'item.started');
-        } else if (nextItem.kind !== 'agentMessage' && existing) {
+        } else {
           this.emitItem(state, nextItem, 'item.started', { force: true });
         }
       }