remote-codex 0.11.39 → 0.11.41

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.41",
   "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({
@@ -2884,4 +2983,139 @@ describe('ClaudeRuntimeAdapter', () => {
       ]),
     );
   });
+
+  it('keeps live Claude compaction in the active turn and hides its summary', async () => {
+    const adapter = makeAdapter((prompt) => prompt === hiddenInitPrompt()
+      ? [systemInit(), result()]
+      : [
+          systemInit(),
+          {
+            type: 'assistant',
+            uuid: 'assistant-before-compact',
+            session_id: 'claude-session-1',
+            message: { role: 'assistant', content: [{ type: 'text', text: 'Before.' }] },
+            parent_tool_use_id: null,
+          },
+          {
+            type: 'system',
+            subtype: 'status',
+            status: 'compacting',
+            uuid: 'compact-status',
+            session_id: 'claude-session-1',
+          },
+          {
+            type: 'user',
+            uuid: 'compact-summary',
+            session_id: 'claude-session-1',
+            isCompactSummary: true,
+            message: { role: 'user', content: 'HIDDEN LIVE SUMMARY' },
+            parent_tool_use_id: null,
+          },
+          {
+            type: 'system',
+            subtype: 'compact_boundary',
+            compact_metadata: { trigger: 'auto', pre_tokens: 180_000 },
+            uuid: 'compact-boundary',
+            session_id: 'claude-session-1',
+          },
+          {
+            type: 'assistant',
+            uuid: 'assistant-after-compact',
+            session_id: 'claude-session-1',
+            message: { role: 'assistant', content: [{ type: 'text', text: 'After.' }] },
+            parent_tool_use_id: null,
+          },
+          result(),
+        ]);
+    const events: AgentRuntimeEvent[] = [];
+    adapter.on('event', (event) => events.push(event));
+
+    await adapter.startTurn({
+      providerSessionId: 'claude-session-1',
+      displayTurnId: 'turn-compact',
+      prompt: 'Continue working',
+    } as any);
+    await wait();
+
+    const completed = events.findLast((event) => event.type === 'turn.completed');
+    const items = completed?.type === 'turn.completed' ? completed.turn.items : [];
+    expect(completed).toMatchObject({
+      type: 'turn.completed',
+      turn: { providerTurnId: 'turn-compact', status: 'completed' },
+    });
+    expect(items.filter((item) => item.kind === 'contextCompaction')).toEqual([
+      expect.objectContaining({
+        text: 'Context compacted',
+        detailText: null,
+        status: 'completed',
+      }),
+    ]);
+    expect(items).toEqual(expect.arrayContaining([
+      expect.objectContaining({ kind: 'agentMessage', text: 'Before.' }),
+      expect.objectContaining({ kind: 'agentMessage', text: 'After.' }),
+    ]));
+    expect(JSON.stringify(items)).not.toContain('HIDDEN LIVE SUMMARY');
+  });
+
+  it('does not create a historical turn for Claude compact summaries', async () => {
+    const adapter = new ClaudeRuntimeAdapter({
+      home: '/tmp/claude-home',
+      query: (() => new FakeQuery([])) as any,
+      getSessionInfo: (async () => ({
+        sessionId: 'claude-session-1',
+        summary: 'Existing session',
+        lastModified: 1_772_000_000_000,
+        createdAt: 1_771_000_000_000,
+        cwd: '/tmp/workspace',
+        firstPrompt: 'Check training',
+      })) as any,
+      getSessionMessages: (async () => [
+        {
+          type: 'user',
+          uuid: uuidV7At(1_771_000_000_000),
+          session_id: 'claude-session-1',
+          message: { role: 'user', content: 'Check training' },
+          parent_tool_use_id: null,
+        },
+        {
+          type: 'assistant',
+          uuid: 'assistant-before-compact',
+          session_id: 'claude-session-1',
+          message: { role: 'assistant', content: [{ type: 'text', text: 'Before.' }] },
+          parent_tool_use_id: null,
+        },
+        {
+          type: 'user',
+          uuid: 'compact-summary',
+          session_id: 'claude-session-1',
+          message: {
+            role: 'user',
+            content: 'This session is being continued from a previous conversation that ran out of context. HIDDEN HISTORICAL SUMMARY',
+          },
+          parent_tool_use_id: null,
+        },
+        {
+          type: 'assistant',
+          uuid: 'assistant-after-compact',
+          session_id: 'claude-session-1',
+          message: { role: 'assistant', content: [{ type: 'text', text: 'After.' }] },
+          parent_tool_use_id: null,
+        },
+      ] satisfies SessionMessage[]) as any,
+    });
+
+    const session = await adapter.readSession('claude-session-1');
+    expect(session.turns).toHaveLength(1);
+    expect(session.turns[0]?.items).toEqual(expect.arrayContaining([
+      expect.objectContaining({ kind: 'userMessage', text: 'Check training' }),
+      expect.objectContaining({ kind: 'agentMessage', text: 'Before.' }),
+      expect.objectContaining({
+        kind: 'contextCompaction',
+        text: 'Context compacted',
+        detailText: null,
+      }),
+      expect.objectContaining({ kind: 'agentMessage', text: 'After.' }),
+    ]));
+    expect(JSON.stringify(session.turns)).not.toContain('HIDDEN HISTORICAL SUMMARY');
+  });
 });

package/packages/claude/src/runtimeAdapter.ts

@@ -46,6 +46,7 @@ import {
   isHiddenContinuationMessage,
   isHiddenInitMessage,
   limitErrorFromHistoryItems,
+  messageContentText,
   partialReasoningDelta,
   partialTextDelta,
   resultForToolUse,
@@ -133,6 +134,16 @@ interface SDKMessage {
   errors?: string[];
   stop_reason?: string;
   rate_limit_info?: SDKRateLimitInfo;
+  compact_metadata?: {
+    trigger?: 'manual' | 'auto';
+    pre_tokens?: number;
+    post_tokens?: number;
+  };
+  compact_result?: 'success' | 'failed';
+  compact_error?: string;
+  status?: 'compacting' | 'requesting' | null;
+  isCompactSummary?: boolean;
+  is_compact_summary?: boolean;
 }
 interface SDKRateLimitInfo {
   status: 'allowed' | 'allowed_warning' | 'rejected';
@@ -244,9 +255,88 @@ interface ActiveClaudeTurn {
   assistantUsage: ClaudeTokenUsageBreakdown | null;
   resultUsage: ClaudeTokenUsageBreakdown | null;
   modelContextWindow: number | null;
+  currentCompactionItemId: string | null;
 }
 
 const promptPhotoTokenPattern = /\[PHOTO\s+([^\]]+)\]/g;
+const claudeCompactSummaryPrefix =
+  'This session is being continued from a previous conversation that ran out of context.';
+const activeTranscriptMatchWindowMs = 120_000;
+
+function isClaudeCompactBoundaryMessage(message: SDKMessage | SessionMessage) {
+  if (message.type !== 'system') {
+    return false;
+  }
+  if (message.subtype === 'compact_boundary' || message.compact_metadata) {
+    return true;
+  }
+  return isRecord(message.message)
+    && (message.message.subtype === 'compact_boundary' || isRecord(message.message.compact_metadata));
+}
+
+function isClaudeCompactSummaryMessage(message: SDKMessage | SessionMessage) {
+  if (message.type !== 'user' || message.parent_tool_use_id) {
+    return false;
+  }
+  const payload = isRecord(message.message) ? message.message : null;
+  if (
+    message.isCompactSummary
+    || message.is_compact_summary
+    || payload?.isCompactSummary === true
+    || payload?.is_compact_summary === true
+  ) {
+    return true;
+  }
+  return messageContentText(message.message).trim().startsWith(claudeCompactSummaryPrefix);
+}
+
+function claudeContextCompactionItem(
+  id: string,
+  status: 'running' | 'completed' | 'failed',
+  error: string | null = null,
+): AgentHistoryItem {
+  const completed = status === 'completed';
+  const failed = status === 'failed';
+  const text = failed
+    ? 'Context compaction failed'
+    : completed
+      ? 'Context compacted'
+      : 'Compacting context';
+  return {
+    id,
+    kind: 'contextCompaction',
+    text,
+    previewText: text,
+    detailText: failed ? error : null,
+    status,
+  };
+}
+
+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();
@@ -1663,6 +1753,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       assistantUsage: null,
       resultUsage: null,
       modelContextWindow: null,
+      currentCompactionItemId: null,
     };
     this.knownSessionIds.add(input.providerSessionId);
     let sessionPrompts = this.liveUserPrompts.get(input.providerSessionId);
@@ -1766,12 +1857,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 +1880,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 +1916,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 };
     });
   }
 
@@ -1925,6 +2040,62 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       return;
     }
 
+    if (message.type === 'system' && message.subtype === 'status') {
+      if (message.status === 'compacting') {
+        const existing = state.currentCompactionItemId
+          ? state.items.get(state.currentCompactionItemId)
+          : null;
+        const itemId = existing?.status === 'running'
+          ? existing.id
+          : `claude-compaction-${messageUuid(message, randomUUID())}`;
+        state.currentCompactionItemId = itemId;
+        const item = withHistoryItemCreatedAt(
+          claudeContextCompactionItem(itemId, 'running'),
+          messageCreatedAt,
+        );
+        addOrUpdateItem(state, item);
+        this.emitItem(state, item, 'item.started', { force: Boolean(existing) });
+        return;
+      }
+      if (message.compact_result) {
+        const itemId = state.currentCompactionItemId
+          ?? `claude-compaction-${messageUuid(message, randomUUID())}`;
+        const status = message.compact_result === 'success' ? 'completed' : 'failed';
+        const item = withHistoryItemCreatedAt(
+          claudeContextCompactionItem(itemId, status, message.compact_error ?? null),
+          messageCreatedAt,
+        );
+        addOrUpdateItem(state, item);
+        this.emitItem(state, item, 'item.completed');
+        state.currentCompactionItemId = status === 'failed' ? null : itemId;
+        return;
+      }
+      return;
+    }
+
+    if (isClaudeCompactBoundaryMessage(message)) {
+      const itemId = state.currentCompactionItemId
+        ?? `claude-compaction-${messageUuid(message, randomUUID())}`;
+      const previous = state.items.get(itemId);
+      const item = withHistoryItemCreatedAt(
+        claudeContextCompactionItem(itemId, 'completed'),
+        previous?.createdAt ?? messageCreatedAt,
+      );
+      addOrUpdateItem(state, item);
+      if (!previous) {
+        this.emitItem(state, item, 'item.started');
+      }
+      if (previous?.status !== 'completed') {
+        this.emitItem(state, item, 'item.completed');
+      }
+      state.currentCompactionItemId = null;
+      return;
+    }
+
+    if (isClaudeCompactSummaryMessage(message)) {
+      return;
+    }
+
     if (message.type === 'stream_event') {
       const nextStreamMessageId = streamMessageId(message.event);
       if (nextStreamMessageId) {
@@ -2357,6 +2528,8 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       itemsById: Map<string, AgentHistoryItem>;
     } | null = null;
     let skippingHiddenInit = false;
+    let pendingCompactSummaryItemId: string | null = null;
+    let pendingCompactBoundaryItemId: string | null = null;
     const suppressedToolUseIds = new Set<string>();
 
     const upsertCurrentItem = (item: AgentHistoryItem) => {
@@ -2390,6 +2563,20 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     };
 
     for (const message of messages) {
+      if (isClaudeCompactBoundaryMessage(message)) {
+        const itemId: string = pendingCompactSummaryItemId
+          ?? `claude-compaction-${messageUuid(message, randomUUID())}`;
+        pendingCompactSummaryItemId = null;
+        pendingCompactBoundaryItemId = itemId;
+        upsertCurrentItem(
+          withHistoryItemCreatedAt(
+            claudeContextCompactionItem(itemId, 'completed'),
+            sessionMessageTimestamp(message) ?? current?.startedAt,
+          ),
+        );
+        continue;
+      }
+
       if (message.type === 'user') {
         const taskNotification = taskNotificationToolResult(message.message);
         if (taskNotification) {
@@ -2436,6 +2623,21 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       }
 
       if (message.type === 'user' && !message.parent_tool_use_id) {
+        if (isClaudeCompactSummaryMessage(message)) {
+          const itemId: string = pendingCompactBoundaryItemId
+            ?? `claude-compaction-${messageUuid(message, randomUUID())}`;
+          if (!pendingCompactBoundaryItemId) {
+            pendingCompactSummaryItemId = itemId;
+          }
+          pendingCompactBoundaryItemId = null;
+          upsertCurrentItem(
+            withHistoryItemCreatedAt(
+              claudeContextCompactionItem(itemId, 'completed'),
+              sessionMessageTimestamp(message) ?? current?.startedAt,
+            ),
+          );
+          continue;
+        }
         if (isHiddenInitMessage(message.message)) {
           skippingHiddenInit = true;
           current = null;
@@ -2455,19 +2657,19 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
             items: current.items,
           }));
         }
-        const messageUuid = message.uuid ?? randomUUID();
-        const userStartedAt = isoFromUuidV7(messageUuid);
+        const userMessageUuid = message.uuid ?? randomUUID();
+        const userStartedAt = isoFromUuidV7(userMessageUuid);
         const userItem = await this.userMessageToHistoryItem(
-          messageUuid,
+          userMessageUuid,
           message.message,
           context,
         );
         const stampedUserItem = withHistoryItemCreatedAt(userItem, userStartedAt);
         current = {
-          providerTurnId: `claude-turn-${messageUuid}`,
+          providerTurnId: `claude-turn-${userMessageUuid}`,
           startedAt: userStartedAt,
           items: [stampedUserItem],
-          itemsById: new Map([[messageUuid, stampedUserItem]]),
+          itemsById: new Map([[userMessageUuid, stampedUserItem]]),
         };
         continue;
       }