feat(context): add bounded checkpoints and scoped evidence access

.github/workflows/build-electron.yml

@@ -34,6 +34,15 @@ jobs:
       - name: Lint and type-check
         run: pnpm lint
 
+      # app/runtime/pinStore.test.ts runs the offline pin store against a real
+      # IndexedDB by driving Playwright's Chromium. Install exactly the browser
+      # revision pinned by the exact "playwright" version in package.json
+      # (1.62.1 -> chromium + chromium-headless-shell 1234) together with its
+      # system dependencies; otherwise the launch fails because the executable
+      # is absent. "chromium" includes the headless shell this test uses.
+      - name: Install Playwright browser for storage tests
+        run: pnpm exec playwright install --with-deps chromium
+
       - name: Run tests
         run: pnpm test
 

app/acpProcessManager.lifecycle.test.ts

@@ -91,4 +91,39 @@ describe('ACP process generation lifecycle', () => {
       await manager.stopAll();
     }
   });
+
+  it('keeps the agent running and clears the raw tap when a runtime client disconnects', async () => {
+    const manager = createAcpProcessManager();
+    try {
+      await manager.reconcile([
+        {
+          id: 'runtime-detach',
+          name: 'Runtime detach',
+          command: process.execPath,
+          args: ['-e', agentScript],
+          enabled: true,
+        },
+      ]);
+      const client = new TestClient();
+      const attachment = manager.attach('runtime-detach', client, { runtime: true });
+      const tapped: string[] = [];
+      attachment.setRawTap((chunk) => tapped.push(Buffer.from(chunk).toString('utf8')));
+
+      client.close();
+
+      expect(manager.getStatus()[0]).toMatchObject({
+        state: 'running',
+        owned: true,
+        connected: false,
+      });
+      client.emit(
+        'message',
+        JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'ping', params: {} }),
+      );
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(tapped).toEqual([]);
+    } finally {
+      await manager.stopAll();
+    }
+  });
 });

app/acpProcessManager.test.ts

@@ -277,4 +277,39 @@ describe('acpProcessManager', () => {
     expect(manager.getStatus()[0]?.droppedFrames).toBe(1);
     await manager.stopAll();
   });
+
+  it('delivers runtime stdout to the selected history raw tap and stops once it is cleared', async () => {
+    const script = [
+      "const readline = require('node:readline');",
+      "readline.createInterface({ input: process.stdin }).on('line', () => {",
+      "  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', method: 'note', params: { token: 'RAW' } }) + '\\n');",
+      '});',
+    ].join('\n');
+    const manager = createAcpProcessManager();
+    await manager.reconcile([
+      { id: 'tap', name: 'Tap ACP', command: process.execPath, args: ['-e', script], enabled: true },
+    ]);
+    const client = new TestClient();
+    const attachment = manager.attach('tap', client, { runtime: true });
+    const tapped: string[] = [];
+    attachment.setRawTap((chunk) => tapped.push(Buffer.from(chunk).toString('utf8')));
+    const trigger = () =>
+      client.emit(
+        'message',
+        JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'ping', params: {} }),
+      );
+
+    trigger();
+    await vi.waitFor(() => expect(tapped.join('')).toContain('RAW'));
+    expect(client.sent.some((payload) => payload.includes('RAW'))).toBe(true);
+
+    attachment.setRawTap(undefined);
+    const before = tapped.join('').split('RAW').length;
+    trigger();
+    await new Promise((resolve) => setTimeout(resolve, 80));
+    expect(tapped.join('').split('RAW').length).toBe(before);
+
+    await manager.stopAll();
+    expect(manager.getStatus()[0]?.state).toBe('stopped');
+  });
 });

app/acpProcessProtocol.boundaries.test.ts

@@ -26,6 +26,59 @@ describe('ACP stdout protocol boundaries', () => {
     expect(send).toHaveBeenCalledExactlyOnceWith(valid);
   });
 
+  it('feeds a runtime-owned raw tap the exact stdout bytes before the 2MiB assembly drops them', () => {
+    const send = vi.fn();
+    const tapped: Uint8Array[] = [];
+    const entry = {
+      agent: { id: 'agent' },
+      status: { state: 'running', droppedFrames: 0 },
+      stdoutBuffer: '',
+      stdoutQueue: Promise.resolve(),
+      pendingAgentResponses: new Map(),
+      client: { send, close: vi.fn() },
+      clientGeneration: 1,
+      child: { stdin: { write: vi.fn() } },
+      runtimeOwned: true,
+      rawTap: (chunk: Uint8Array) => tapped.push(chunk),
+    };
+    const entries = new Map([['agent', entry]]);
+    const forward = createAcpStdoutForwarder({ entries });
+    const oversized = 'x'.repeat(2 * 1024 * 1024 + 1);
+    const valid = JSON.stringify({ jsonrpc: '2.0', method: 'session/update', params: {} });
+    const raw = `${oversized}\n${valid}\n`;
+
+    forward(entry, raw);
+
+    expect(Buffer.concat(tapped.map((chunk) => Buffer.from(chunk))).toString('utf8')).toBe(raw);
+    expect(entry.status.droppedFrames).toBe(1);
+    expect(send).toHaveBeenCalledExactlyOnceWith(valid);
+  });
+
+  it('never taps a legacy client even when a tap function is present', async () => {
+    const send = vi.fn();
+    const tap = vi.fn();
+    const entry = {
+      agent: { id: 'agent' },
+      status: { state: 'running', droppedFrames: 0 },
+      stdoutBuffer: '',
+      stdoutQueue: Promise.resolve(),
+      pendingAgentResponses: new Map(),
+      client: { send },
+      clientGeneration: 1,
+      child: { stdin: { write: vi.fn() } },
+      rawTap: tap,
+    };
+    const entries = new Map([['agent', entry]]);
+    const forward = createAcpStdoutForwarder({ entries });
+    const line = JSON.stringify({ jsonrpc: '2.0', method: 'session/update', params: {} });
+
+    forward(entry, `${line}\n`);
+    await entry.stdoutQueue;
+
+    expect(tap).not.toHaveBeenCalled();
+    expect(send).toHaveBeenCalledExactlyOnceWith(line);
+  });
+
   it('preserves UTF-8 code points split across stdout chunks', async () => {
     const send = vi.fn();
     const entry = {

app/acpProcessReconnect.test.ts

@@ -149,4 +149,34 @@ describe('AcpProcessManager reconnect transport', () => {
       }),
     );
   });
+
+  it('delivers the same native frame to the runtime client and the raw history tap', async () => {
+    const script = [
+      "const readline=require('node:readline')",
+      "readline.createInterface({input:process.stdin}).on('line',(line)=>{",
+      'JSON.parse(line)',
+      "process.stdout.write(JSON.stringify({jsonrpc:'2.0',method:'session/update',params:{sessionId:'s1',update:{sessionUpdate:'agent_message_chunk',content:{type:'text',text:'added'}}}})+'\\n')",
+      '})',
+    ].join(';');
+    manager = createAcpProcessManager();
+    await manager.reconcile([
+      {
+        id: 'frame',
+        name: 'Frame ACP',
+        command: process.execPath,
+        args: ['-e', script],
+        enabled: true,
+      },
+    ]);
+    const client = new MockClient();
+    const attachment = manager.attach('frame', client, { runtime: true });
+    const tapped: string[] = [];
+    attachment.setRawTap((chunk) => tapped.push(Buffer.from(chunk).toString('utf8')));
+
+    client.emit('message', JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'ping', params: {} }));
+
+    await vi.waitFor(() => expect(client.sent).toHaveLength(1));
+    expect(tapped.join('')).toContain('"text":"added"');
+    expect(JSON.parse(client.sent[0] ?? '{}')).toMatchObject({ method: 'session/update' });
+  });
 });

app/acpTerminalManager.test.ts

@@ -47,6 +47,7 @@ describe('acpTerminalManager', () => {
       setInterval(() => {}, 1000);
     `;
     let descendantPid: number | undefined;
+    const failures: unknown[] = [];
 
     try {
       await manager.create({ command: process.execPath, args: ['-e', script, pidPath] });
@@ -64,14 +65,28 @@ describe('acpTerminalManager', () => {
       await manager.stopAll();
 
       expect(() => process.kill(activeDescendantPid, 0)).toThrow();
+    } catch (error) {
+      failures.push(error);
     } finally {
       if (descendantPid) {
         try {
           process.kill(descendantPid, 'SIGKILL');
         } catch {}
       }
-      await manager.stopAll();
-      await rm(directory, { recursive: true, force: true });
+      try {
+        await manager.stopAll();
+      } catch (error) {
+        failures.push(error);
+      }
+      try {
+        await rm(directory, { recursive: true, force: true });
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) {
+      throw new AggregateError(failures, 'Terminal shutdown and cleanup failed', { cause: failures[0] });
     }
   });