remote-codex 0.11.40 → 0.11.41

package/apps/supervisor-api/dist/index.js

@@ -11717,7 +11717,40 @@ import { pathToFileURL } from "url";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var promptPhotoTokenPattern2 = /\[PHOTO\s+([^\]]+)\]/g;
+var claudeCompactSummaryPrefix = "This session is being continued from a previous conversation that ran out of context.";
 var activeTranscriptMatchWindowMs = 12e4;
+function isClaudeCompactBoundaryMessage(message) {
+  if (message.type !== "system") {
+    return false;
+  }
+  if (message.subtype === "compact_boundary" || message.compact_metadata) {
+    return true;
+  }
+  return isRecord8(message.message) && (message.message.subtype === "compact_boundary" || isRecord8(message.message.compact_metadata));
+}
+function isClaudeCompactSummaryMessage(message) {
+  if (message.type !== "user" || message.parent_tool_use_id) {
+    return false;
+  }
+  const payload = isRecord8(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, status, error = null) {
+  const completed = status === "completed";
+  const failed = status === "failed";
+  const text2 = failed ? "Context compaction failed" : completed ? "Context compacted" : "Compacting context";
+  return {
+    id,
+    kind: "contextCompaction",
+    text: text2,
+    previewText: text2,
+    detailText: failed ? error : null,
+    status
+  };
+}
 function normalizePromptForTurnReconciliation(value) {
   return value.replace(/\[PHOTO\s+[^\]]+\]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -12923,7 +12956,8 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       suppressedToolUseIds: /* @__PURE__ */ new Set(),
       assistantUsage: null,
       resultUsage: null,
-      modelContextWindow: null
+      modelContextWindow: null,
+      currentCompactionItemId: null
     };
     this.knownSessionIds.add(input.providerSessionId);
     let sessionPrompts = this.liveUserPrompts.get(input.providerSessionId);
@@ -13147,6 +13181,53 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       }
       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, randomUUID2())}`;
+        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, randomUUID2())}`;
+        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, randomUUID2())}`;
+      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) {
@@ -13498,6 +13579,8 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     const turns = [];
     let current = null;
     let skippingHiddenInit = false;
+    let pendingCompactSummaryItemId = null;
+    let pendingCompactBoundaryItemId = null;
     const suppressedToolUseIds = /* @__PURE__ */ new Set();
     const upsertCurrentItem = (item) => {
       if (!current) {
@@ -13529,6 +13612,18 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       current.itemsById.set(item.id, item);
     };
     for (const message of messages) {
+      if (isClaudeCompactBoundaryMessage(message)) {
+        const itemId = pendingCompactSummaryItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+        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) {
@@ -13573,6 +13668,20 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         }
       }
       if (message.type === "user" && !message.parent_tool_use_id) {
+        if (isClaudeCompactSummaryMessage(message)) {
+          const itemId = pendingCompactBoundaryItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+          if (!pendingCompactBoundaryItemId) {
+            pendingCompactSummaryItemId = itemId;
+          }
+          pendingCompactBoundaryItemId = null;
+          upsertCurrentItem(
+            withHistoryItemCreatedAt(
+              claudeContextCompactionItem(itemId, "completed"),
+              sessionMessageTimestamp(message) ?? current?.startedAt
+            )
+          );
+          continue;
+        }
         if (isHiddenInitMessage(message.message)) {
           skippingHiddenInit = true;
           current = null;
@@ -13592,19 +13701,19 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
             items: current.items
           }));
         }
-        const messageUuid2 = message.uuid ?? randomUUID2();
-        const userStartedAt = isoFromUuidV7(messageUuid2);
+        const userMessageUuid = message.uuid ?? randomUUID2();
+        const userStartedAt = isoFromUuidV7(userMessageUuid);
         const userItem = await this.userMessageToHistoryItem(
-          messageUuid2,
+          userMessageUuid,
           message.message,
           context
         );
         const stampedUserItem = withHistoryItemCreatedAt(userItem, userStartedAt);
         current = {
-          providerTurnId: `claude-turn-${messageUuid2}`,
+          providerTurnId: `claude-turn-${userMessageUuid}`,
           startedAt: userStartedAt,
           items: [stampedUserItem],
-          itemsById: /* @__PURE__ */ new Map([[messageUuid2, stampedUserItem]])
+          itemsById: /* @__PURE__ */ new Map([[userMessageUuid, stampedUserItem]])
         };
         continue;
       }

package/package.json

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

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

@@ -2983,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,11 +255,63 @@ 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
@@ -1690,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);
@@ -1976,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) {
@@ -2408,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) => {
@@ -2441,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) {
@@ -2487,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;
@@ -2506,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;
       }