feat(cli): show Claude compaction as a summary card with token delta

cli/src/claude/claudeRemoteLauncher.launchFailure.test.ts

@@ -141,6 +141,36 @@ describe('claudeRemoteLauncher launch-failure recovery', () => {
         expect(restoredMessageText).toBe('hello');
     });
 
+    it('does not restore /compact after its SDK result was accepted', async () => {
+        const queue = new MessageQueue2<EnhancedMode>((mode) => JSON.stringify(mode));
+        queue.push('/compact', { permissionMode: 'default' });
+
+        const client = makeClient();
+        const session = makeSession(queue, client);
+        let callCount = 0;
+        let queueSizeOnSecondAttempt: number | undefined;
+
+        claudeRemoteMock.mockImplementation(async (opts: any) => {
+            callCount += 1;
+            if (callCount === 1) {
+                const msg = await opts.nextMessage();
+                expect(msg?.message).toBe('/compact');
+                opts.onCompactResultAccepted();
+                throw new Error('stream failed after compact result');
+            }
+
+            queueSizeOnSecondAttempt = session.queue.size();
+            triggerSwitch(client);
+            throw new Error('stop test');
+        });
+
+        const { claudeRemoteLauncher } = await import('./claudeRemoteLauncher');
+        await claudeRemoteLauncher(session);
+
+        expect(callCount).toBe(2);
+        expect(queueSizeOnSecondAttempt).toBe(0);
+    });
+
     it('sends the result carrier before compact completion and ready', async () => {
         const queue = new MessageQueue2<EnhancedMode>((mode) => JSON.stringify(mode));
         queue.push('/compact', { permissionMode: 'default' });

cli/src/claude/claudeRemoteLauncher.ts

@@ -1,7 +1,8 @@
 import React from "react";
 import { Session } from "./session";
 import { RemoteModeDisplay } from "@/ui/ink/RemoteModeDisplay";
-import { claudeRemote } from "./claudeRemote";
+import { claudeRemote, type CompactSummaryPayload } from "./claudeRemote";
+import { convertAgentMessage } from "@/agent/messageConverter";
 import { PermissionHandler } from "./utils/permissionHandler";
 import { Future } from "@/utils/future";
 import { SDKAssistantMessage, SDKMessage, SDKUserMessage } from "./sdk";
@@ -492,6 +493,13 @@ class ClaudeRemoteLauncher extends RemoteLauncherBase {
                         onFirstResult: (initialMessage) => {
                             applySessionTitleFallback(session.client, initialMessage);
                         },
+                        onCompactResultAccepted: () => {
+                            // The command has completed at the SDK boundary even
+                            // if transcript summary lookup is still pending. A
+                            // later stream failure must not replay /compact.
+                            reachedReadyThisAttempt = true;
+                            inFlightMessage = null;
+                        },
                         onCompletionEvent: (message: string) => {
                             logger.debug(`[remote]: Completion event: ${message}`);
                             session.client.sendSessionEvent({ type: 'message', message });
@@ -507,7 +515,7 @@ class ClaudeRemoteLauncher extends RemoteLauncherBase {
                             // just asked to clear.
                             session.consumeOneTimeFlags();
                         },
-                        onReady: async (completionEvent?: string) => {
+                        onReady: async (completionEvent?: string, compactSummary?: CompactSummaryPayload, compactContextTokens?: number) => {
                             // Reaching ready at all means this attempt is not an
                             // immediate/deterministic failure -- reset the
                             // respawn-storm guard. The turn that led here is no
@@ -521,6 +529,26 @@ class ClaudeRemoteLauncher extends RemoteLauncherBase {
                                 logger.debug(`[remote]: Completion event: ${completionEvent}`);
                                 session.client.sendSessionEvent({ type: 'message', message: completionEvent });
                             }
+                            if (compactSummary) {
+                                logger.debug(`[remote]: Compact summary promoted (${compactSummary.summary.length} chars)`);
+                                session.client.sendSessionEvent({
+                                    type: 'compact-summary',
+                                    summary: compactSummary.summary,
+                                    tokensBefore: compactSummary.tokensBefore,
+                                    estimatedTokensAfter: compactSummary.tokensAfter
+                                });
+                            }
+                            if (compactContextTokens !== undefined) {
+                                // The status bar keeps the last pre-compaction
+                                // usage until the next model response; refresh
+                                // it with the boundary's post-tokens the same
+                                // way the Pi launcher does.
+                                const convertedUsage = convertAgentMessage(
+                                    { type: 'usage', inputTokens: 0, outputTokens: 0, contextTokens: compactContextTokens },
+                                    session.getModel()
+                                );
+                                if (convertedUsage) session.client.sendAgentMessage(convertedUsage);
+                            }
 
                             logger.debug(
                                 `[claudeRemoteLauncher][async-debug] onReady callback ` +

cli/src/claude/utils/compactCompletion.test.ts

@@ -0,0 +1,29 @@
+/**
+ * Tests for the claude /compact completion event builder
+ */
+
+import { describe, it, expect } from 'vitest'
+import { buildCompactCompletionEvent } from './compactCompletion'
+
+describe('buildCompactCompletionEvent', () => {
+    it('reports failure with its reason', () => {
+        expect(buildCompactCompletionEvent('context too large', undefined, undefined))
+            .toBe('📦 Compaction failed: context too large')
+    })
+
+    it('falls back to a generic failure message when no reason is available', () => {
+        expect(buildCompactCompletionEvent('', undefined, undefined))
+            .toBe('📦 Compaction failed')
+    })
+
+    it('emits a token delta line when both tokens are known', () => {
+        expect(buildCompactCompletionEvent(null, 34492, 2082))
+            .toBe('📦 Compacted (34492 → 2082 tokens)')
+    })
+
+    it('omits the delta when tokens are missing', () => {
+        expect(buildCompactCompletionEvent(null, undefined, 2082)).toBe('📦 Compacted')
+        expect(buildCompactCompletionEvent(null, 34492, undefined)).toBe('📦 Compacted')
+        expect(buildCompactCompletionEvent(null, undefined, undefined)).toBe('📦 Compacted')
+    })
+})

cli/src/claude/utils/compactCompletion.ts

@@ -0,0 +1,21 @@
+/**
+ * Builds the chat-visible completion line for a claude /compact turn.
+ *
+ * The SDK stream carries no summary body for compactions (measured: only a
+ * system/compact_boundary with token metadata arrives), so the completion
+ * event is the defensive fallback line — pi-style token delta when both
+ * numbers are known, bare acknowledgment otherwise.
+ */
+export function buildCompactCompletionEvent(
+    failure: string | null,
+    tokensBefore?: number,
+    tokensAfter?: number
+): string {
+    if (failure !== null) {
+        return failure.length > 0 ? `📦 Compaction failed: ${failure}` : '📦 Compaction failed'
+    }
+    if (typeof tokensBefore === 'number' && typeof tokensAfter === 'number') {
+        return `📦 Compacted (${tokensBefore} → ${tokensAfter} tokens)`
+    }
+    return '📦 Compacted'
+}

cli/src/claude/utils/compactSummaryLookup.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtemp, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { extractCompactSummaryFromTranscript, findLatestCompactSummary } from './compactSummaryLookup';
+
+function entry(text: string, isCompactSummary = true): string {
+    return JSON.stringify({
+        type: 'user',
+        uuid: `u-${Math.random().toString(36).slice(2)}`,
+        isCompactSummary,
+        message: { role: 'user', content: text },
+        sessionId: 's-1'
+    });
+}
+
+describe('extractCompactSummaryFromTranscript', () => {
+    it('returns the text of the last isCompactSummary entry', () => {
+        const content = [
+            entry('older summary'),
+            entry('not a summary', false),
+            entry('newer summary')
+        ].join('\n');
+
+        expect(extractCompactSummaryFromTranscript(content)).toBe('newer summary');
+    });
+
+    it('returns null when no entry carries isCompactSummary', () => {
+        const content = [entry('plain turn', false)].join('\n');
+        expect(extractCompactSummaryFromTranscript(content)).toBeNull();
+    });
+
+    it('returns null for empty or malformed lines without throwing', () => {
+        expect(extractCompactSummaryFromTranscript('')).toBeNull();
+        expect(extractCompactSummaryFromTranscript('{broken json\n[]\n')).toBeNull();
+    });
+
+    it('extracts joined text from array-style message content', () => {
+        const content = JSON.stringify({
+            type: 'user',
+            uuid: 'u-1',
+            isCompactSummary: true,
+            message: { role: 'user', content: [{ type: 'text', text: 'part one\n' }, { type: 'text', text: 'part two' }] }
+        });
+
+        expect(extractCompactSummaryFromTranscript(content)).toBe('part one\npart two');
+    });
+});
+
+describe('findLatestCompactSummary', () => {
+    it('ignores summaries written before the baseline offset', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'compact-summary-'));
+        try {
+            const filePath = join(dir, 's-1.jsonl');
+            const stale = entry('stale summary from a previous compaction') + '\n';
+            await writeFile(filePath, stale);
+            const baselineBytes = Buffer.byteLength(stale, 'utf8');
+            // A resumed or second-compact session already carries a summary row.
+            // With the baseline recorded before the new compaction started, the
+            // stale row must not satisfy the lookup while the new row is delayed.
+            const pending = findLatestCompactSummary(filePath, {
+                attempts: 3,
+                intervalMs: 5,
+                sleep: async () => {},
+                minBytes: baselineBytes
+            });
+            await new Promise((r) => setTimeout(r, 20));
+            expect(await pending).toBeNull();
+        } finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+
+    it('returns only the summary written after the baseline offset', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'compact-summary-'));
+        try {
+            const filePath = join(dir, 's-1.jsonl');
+            const stale = entry('stale summary') + '\n';
+            await writeFile(filePath, stale);
+            const baselineBytes = Buffer.byteLength(stale, 'utf8');
+            const pending = findLatestCompactSummary(filePath, {
+                attempts: 5,
+                intervalMs: 5,
+                sleep: async () => {},
+                minBytes: baselineBytes
+            });
+            await writeFile(filePath, stale + entry('fresh summary') + '\n');
+            await expect(pending).resolves.toBe('fresh summary');
+        } finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+
+    it('resolves the summary once the transcript contains an isCompactSummary entry', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'compact-summary-'));
+        try {
+            const filePath = join(dir, 's-1.jsonl');
+            const sleeps: number[] = [];
+            const pending = findLatestCompactSummary(filePath, {
+                attempts: 5,
+                intervalMs: 7,
+                sleep: async (ms) => { sleeps.push(ms); }
+            });
+            await writeFile(filePath, entry('late summary') + '\n');
+            await expect(pending).resolves.toBe('late summary');
+            expect(sleeps.length).toBeGreaterThan(0);
+        } finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+
+    it('returns null after exhausting attempts when the entry never appears', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'compact-summary-'));
+        try {
+            const filePath = join(dir, 'missing.jsonl');
+            const summary = await findLatestCompactSummary(filePath, {
+                attempts: 3,
+                intervalMs: 1,
+                sleep: async () => {}
+            });
+            expect(summary).toBeNull();
+        } finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+
+    it('stops polling when aborted', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'compact-summary-'));
+        try {
+            const controller = new AbortController();
+            const pending = findLatestCompactSummary(join(dir, 'missing.jsonl'), {
+                attempts: 10,
+                intervalMs: 10_000,
+                signal: controller.signal
+            });
+            controller.abort();
+            await expect(pending).resolves.toBeNull();
+        } finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});