remote-codex 0.11.39 → 0.11.40

package/apps/supervisor-web/dist/index.html

@@ -10,7 +10,7 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
     <link rel="manifest" href="/site.webmanifest" />
     <title>Remote Codex</title>
-    <script type="module" crossorigin src="/assets/index-CUhMNGXI.js"></script>
+    <script type="module" crossorigin src="/assets/index-B-qj7e8G.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/react-vendor-Dfg_6BLf.js">
     <link rel="modulepreload" crossorigin href="/assets/ui-vendor-CuR8GHb0.js">
     <link rel="modulepreload" crossorigin href="/assets/graph-vendor-DVQUpZ8C.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.39",
+  "version": "0.11.40",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",

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({

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();
@@ -1766,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;
@@ -1784,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);
     }
 
@@ -1812,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 };
     });
   }