@pi-chamber/web 0.9.6 → 0.9.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (85) hide show
  1. package/dist/assets/{DiagramView-0Iq1ak1I.js → DiagramView-BvrCkm_z.js} +1 -1
  2. package/dist/assets/{DiffView-DD1AFRi3.js → DiffView-DMvRLRN1.js} +1 -1
  3. package/dist/assets/{FileSaveConflictDialog-CoKwDovb.js → FileSaveConflictDialog-DGa9u43J.js} +1 -1
  4. package/dist/assets/{FilesView-B_BF39ef.js → FilesView-CNHu4RnC.js} +4 -4
  5. package/dist/assets/{GitView-LFEpCasf.js → GitView-Cbepz-bR.js} +3 -3
  6. package/dist/assets/{JsonTreeView-Cwjgvh4g.js → JsonTreeView-C2X5oXQm.js} +1 -1
  7. package/dist/assets/{MarkdownRendererImpl-_7kV1yNw.js → MarkdownRendererImpl-BanSCkPy.js} +2 -2
  8. package/dist/assets/{PatchDiff-DG43C1HW.js → PatchDiff-i_9BIlgo.js} +1 -1
  9. package/dist/assets/{SessionSwitcherContent-DCFXPY3d.js → SessionSwitcherContent-DxS_rFuS.js} +1 -1
  10. package/dist/assets/{SessionSwitcherDropdown-QY7FKuEQ.js → SessionSwitcherDropdown-AVghToww.js} +2 -2
  11. package/dist/assets/{SessionUnreadDot-DGT31A3z.js → SessionUnreadDot-CDRZswx-.js} +1 -1
  12. package/dist/assets/SettingsView-hyAGp836.js +2 -0
  13. package/dist/assets/SettingsWindow-BfPUzBbq.js +1 -0
  14. package/dist/assets/{ToolOutputDialog-IlCrS6BR.js → ToolOutputDialog-CJ87b80H.js} +5 -5
  15. package/dist/assets/{ToolPartDiffPreview-D68JV0rR.js → ToolPartDiffPreview-bF486Lz1.js} +1 -1
  16. package/dist/assets/{VirtualizedFileDiff-Bl-rAYeh.js → VirtualizedFileDiff-CFpvcZ1g.js} +1 -1
  17. package/dist/assets/{collapsible-BjniCdZ5.js → collapsible-DesjbW8a.js} +1 -1
  18. package/dist/assets/{computeVirtualFileMetrics-FSOm2VrW.js → computeVirtualFileMetrics-CsAu9rOt.js} +1 -1
  19. package/dist/assets/{contextFileOpenGuard-Bxb6AIPa.js → contextFileOpenGuard-rILslsBJ.js} +1 -1
  20. package/dist/assets/{gitStatusPredicates-DxolDpMd.js → gitStatusPredicates-D_31YElh.js} +1 -1
  21. package/dist/assets/index-BXgR2dKM.css +1 -0
  22. package/dist/assets/index-BZpvAhrX.js +8 -0
  23. package/dist/assets/{index-Dh58uD3I.js → index-CXLVW_GG.js} +1 -1
  24. package/dist/assets/{isDiffPlainText-D3_04XCh.js → isDiffPlainText-BX609Lau.js} +1 -1
  25. package/dist/assets/{isFilePlainText-CHouYQhH.js → isFilePlainText-FgBWqu9b.js} +1 -1
  26. package/dist/assets/{main-CH3EqGJI.js → main-C_pL2r_k.js} +2 -2
  27. package/dist/assets/{main-HzTrVvbB.js → main-tv2uysSs.js} +7 -7
  28. package/dist/assets/{markdownCore-DJU4KvHP.js → markdownCore-D3Ibaffd.js} +1 -1
  29. package/dist/assets/{miniChat-Ca3TpaaA.js → miniChat-B0xQlBzZ.js} +2 -2
  30. package/dist/assets/{mobile-lj4gpGsO.js → mobile-BmSlVuhn.js} +2 -2
  31. package/dist/assets/renderElectronMiniChatApp-C4xZzAnn.js +2 -0
  32. package/dist/assets/renderMobileApp-Bi8wTGd5.js +11 -0
  33. package/dist/assets/runtimeEndpointReset-B6_gFvBD.js +53 -0
  34. package/dist/assets/{runtimeSurface-CE_VNjdH.js → runtimeSurface-egSD9pqj.js} +1 -1
  35. package/dist/assets/{useAppFontEffects-BvFAP9zG.js → useAppFontEffects-C9QQrBIx.js} +104 -104
  36. package/dist/assets/{useFilesViewSearch-BD79p3A2.js → useFilesViewSearch-BTZutbn-.js} +2 -2
  37. package/dist/assets/{usePushVisibilityBeacon-CWg0j-Wg.js → usePushVisibilityBeacon-BZcHxSo-.js} +1 -1
  38. package/dist/assets/useSwitcherItems-Dw5tHQh8.js +1 -0
  39. package/dist/assets/{vendor-codemirror-language-data-CP3j3-xu.js → vendor-codemirror-language-data-0f_rLdj_.js} +2 -2
  40. package/dist/assets/{web-components-DWuadqra.js → web-components-CYngz9Ml.js} +1 -1
  41. package/dist/index.html +4 -4
  42. package/dist/mini-chat.html +3 -3
  43. package/dist/mobile.html +3 -3
  44. package/package.json +1 -1
  45. package/server/index.js +17 -3
  46. package/server/lib/client-auth/DOCUMENTATION.md +184 -0
  47. package/server/lib/client-auth/live-revocation.test.js +567 -0
  48. package/server/lib/client-auth/principal-tracker.js +383 -0
  49. package/server/lib/client-auth/principal-tracker.test.js +321 -0
  50. package/server/lib/client-auth/remote-clients.js +31 -0
  51. package/server/lib/client-auth/remote-clients.test.js +44 -0
  52. package/server/lib/pi/event-stream.js +269 -0
  53. package/server/lib/pi/event-stream.test.js +776 -0
  54. package/server/lib/pi/routes.js +76 -25
  55. package/server/lib/pi/routes.test.js +48 -4
  56. package/server/lib/pi/session-daemon/DOCUMENTATION.md +5 -4
  57. package/server/lib/pi/session-daemon/ipc-client.js +19 -15
  58. package/server/lib/pi/session-daemon/ipc-client.test.js +113 -1
  59. package/server/lib/pi/session-daemon/session-daemon-epoch.test.js +349 -0
  60. package/server/lib/pi/session-daemon/session-daemon.js +55 -6
  61. package/server/lib/pi/session-daemon/session-daemon.test.js +10 -4
  62. package/server/lib/pi/session-daemon/session-replay.test.js +8 -3
  63. package/server/lib/pi/session-daemon/supervisor.js +30 -5
  64. package/server/lib/pi/session-daemon/supervisor.test.js +4 -3
  65. package/server/lib/pi/ui-settings-store.js +1 -1
  66. package/server/lib/pi/ui-settings-store.test.js +3 -1
  67. package/server/lib/server/core-routes.js +11 -1
  68. package/server/lib/stt/DOCUMENTATION.md +2 -0
  69. package/server/lib/stt/runtime.js +39 -2
  70. package/server/lib/stt/runtime.test.js +53 -0
  71. package/server/lib/terminal/DOCUMENTATION.md +2 -0
  72. package/server/lib/terminal/runtime.js +48 -2
  73. package/server/lib/terminal/runtime.test.js +35 -0
  74. package/server/lib/ui-auth/DOCUMENTATION.md +13 -4
  75. package/server/lib/ui-auth/ui-auth.js +98 -0
  76. package/server/lib/ui-auth/ui-auth.test.js +249 -0
  77. package/server/lib/workspace/host.js +3 -1
  78. package/dist/assets/SettingsView-eG-wN-yY.js +0 -2
  79. package/dist/assets/SettingsWindow-Dvnp8YrA.js +0 -1
  80. package/dist/assets/index-BpmGBboM.css +0 -1
  81. package/dist/assets/index-DZnzXhTs.js +0 -8
  82. package/dist/assets/renderElectronMiniChatApp-rUFfaD-T.js +0 -2
  83. package/dist/assets/renderMobileApp-CcWQ1sCf.js +0 -11
  84. package/dist/assets/runtimeEndpointReset-D2MmSbDk.js +0 -53
  85. package/dist/assets/useSwitcherItems-CazJ6Yox.js +0 -1
@@ -0,0 +1,349 @@
1
+ import { afterEach, describe, expect, it } from 'vitest';
2
+ import { mkdir, mkdtemp } from 'node:fs/promises';
3
+ import { createConnection } from 'node:net';
4
+ import { tmpdir } from 'node:os';
5
+ import { join } from 'node:path';
6
+ import { StringDecoder } from 'node:string_decoder';
7
+
8
+ import { createSessionDaemon } from './session-daemon.js';
9
+
10
+ const credential = 'a-private-daemon-credential';
11
+
12
+ class FakeSession {
13
+ constructor(sessionId = 'pi-session-1') {
14
+ this.sessionId = sessionId;
15
+ this.isStreaming = false;
16
+ this.listeners = new Set();
17
+ this.entries = [];
18
+ this.model = { provider: 'test', id: 'model' };
19
+ this.thinkingLevel = 'low';
20
+ this.sessionManager = {
21
+ getSessionFile: () => undefined,
22
+ getHeader: () => ({ timestamp: '2026-01-01T00:00:00.000Z' }),
23
+ getEntries: () => this.entries,
24
+ getEntry: (id) => this.entries.find((entry) => entry.id === id),
25
+ getLeafId: () => 'fake-entry',
26
+ getTree: () => [],
27
+ appendSessionInfo: () => undefined,
28
+ getSessionName: () => undefined,
29
+ };
30
+ }
31
+
32
+ subscribe(listener) {
33
+ this.listeners.add(listener);
34
+ return () => this.listeners.delete(listener);
35
+ }
36
+
37
+ emit(event) {
38
+ for (const listener of this.listeners) listener(event);
39
+ }
40
+
41
+ async prompt() {}
42
+
43
+ async sendUserMessage() {}
44
+
45
+ async abort() {}
46
+
47
+ async compact() {}
48
+
49
+ getSteeringMessages() { return []; }
50
+
51
+ getFollowUpMessages() { return []; }
52
+ }
53
+
54
+ function testDaemonEndpoint(root) {
55
+ return process.platform === 'win32'
56
+ ? `\\\\.\\pipe\\pichamber-pi-daemon-epoch-test-${Math.random().toString(36).slice(2)}`
57
+ : join(root, 'daemon.sock');
58
+ }
59
+
60
+ function connectClient(endpoint) {
61
+ const socket = createConnection(endpoint);
62
+ const decoder = new StringDecoder('utf8');
63
+ let buffer = '';
64
+ const messages = [];
65
+ const waiters = [];
66
+
67
+ socket.on('data', (chunk) => {
68
+ buffer += decoder.write(chunk);
69
+ while (true) {
70
+ const newline = buffer.indexOf('\n');
71
+ if (newline === -1) break;
72
+ const line = buffer.slice(0, newline).replace(/\r$/, '');
73
+ buffer = buffer.slice(newline + 1);
74
+ if (!line) continue;
75
+ const message = JSON.parse(line);
76
+ messages.push(message);
77
+ for (let index = waiters.length - 1; index >= 0; index -= 1) {
78
+ const waiter = waiters[index];
79
+ if (waiter.predicate(message)) {
80
+ waiters.splice(index, 1);
81
+ waiter.resolve(message);
82
+ }
83
+ }
84
+ }
85
+ });
86
+
87
+ const next = (predicate) => {
88
+ const existing = messages.find(predicate);
89
+ if (existing) return Promise.resolve(existing);
90
+ return new Promise((resolve, reject) => {
91
+ const timer = setTimeout(() => {
92
+ const index = waiters.findIndex((waiter) => waiter.resolve === resolve);
93
+ if (index !== -1) waiters.splice(index, 1);
94
+ reject(new Error('Timed out waiting for daemon message'));
95
+ }, 2_000);
96
+ waiters.push({ predicate, reject, resolve: (message) => { clearTimeout(timer); resolve(message); } });
97
+ });
98
+ };
99
+
100
+ let closed = false;
101
+ return {
102
+ socket,
103
+ async authenticate({ fromSequence, streamEpoch } = {}) {
104
+ await new Promise((resolve, reject) => {
105
+ socket.once('connect', resolve);
106
+ socket.once('error', reject);
107
+ });
108
+ socket.write(`${JSON.stringify({
109
+ kind: 'authenticate',
110
+ credential,
111
+ ...(fromSequence !== undefined ? { fromSequence } : {}),
112
+ ...(streamEpoch ? { streamEpoch } : {}),
113
+ })}\n`);
114
+ await next((message) => message.kind === 'authenticated');
115
+ },
116
+ request(command, payload = {}) {
117
+ const requestId = `request-${Math.random()}`;
118
+ socket.write(`${JSON.stringify({ protocolVersion: 1, kind: 'request', requestId, command, payload })}\n`);
119
+ return next((message) => message.kind === 'response' && message.requestId === requestId);
120
+ },
121
+ next,
122
+ async close() {
123
+ if (closed) return;
124
+ closed = true;
125
+ socket.end();
126
+ await new Promise((resolve) => {
127
+ if (socket.destroyed) { resolve(); return; }
128
+ socket.once('close', resolve);
129
+ setTimeout(resolve, 250);
130
+ });
131
+ },
132
+ };
133
+ }
134
+
135
+ const startDaemon = async (root, session) => {
136
+ const endpoint = testDaemonEndpoint(root);
137
+ const daemon = createSessionDaemon({
138
+ endpoint,
139
+ credential,
140
+ cwd: root,
141
+ agentDir: join(root, 'agent'),
142
+ createRuntime: async () => ({ session, async dispose() {} }),
143
+ });
144
+ await daemon.start();
145
+ return { daemon, endpoint };
146
+ };
147
+
148
+ describe('session daemon stream epoch', () => {
149
+ const daemons = [];
150
+ const sockets = [];
151
+
152
+ const track = async (root, session) => {
153
+ const started = await startDaemon(root, session);
154
+ daemons.push(started.daemon);
155
+ return started;
156
+ };
157
+
158
+ afterEach(async () => {
159
+ for (const socket of sockets.splice(0)) await socket.close().catch(() => {});
160
+ for (const daemon of daemons.splice(0)) await daemon.stop().catch(() => {});
161
+ });
162
+
163
+ it('stamps a stable opaque streamEpoch on health, snapshots, events, and session reads', async () => {
164
+ const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
165
+ await mkdir(join(root, 'agent'), { recursive: true });
166
+ const session = new FakeSession();
167
+ const { endpoint } = await track(root, session);
168
+
169
+ const client = connectClient(endpoint);
170
+ sockets.push(client);
171
+ await client.authenticate();
172
+ const snapshot = await client.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
173
+ // Register the injected runtime so live session events are published.
174
+ await client.request('sessions.create', { cwd: root });
175
+
176
+ expect(typeof snapshot.streamEpoch).toBe('string');
177
+ expect(snapshot.streamEpoch.length).toBeGreaterThanOrEqual(16);
178
+ expect(snapshot.streamEpoch).not.toMatch(/pi-session|credential|agent/);
179
+ expect(snapshot.payload.resync).toBeUndefined();
180
+
181
+ const health = await client.request('runtime.health');
182
+ expect(health.result.streamEpoch).toBe(snapshot.streamEpoch);
183
+ expect(health.result.capabilities).toContain('events.streamEpoch');
184
+
185
+ const eventPromise = client.next((message) => message.kind === 'event' && message.event === 'session.updated');
186
+ session.emit({ type: 'session_info_changed', name: 'renamed' });
187
+ const event = await eventPromise;
188
+ expect(event.streamEpoch).toBe(snapshot.streamEpoch);
189
+
190
+ const opened = await client.request('sessions.open', { sessionId: session.sessionId, cwd: root });
191
+ expect(opened.result.streamEpoch).toBe(snapshot.streamEpoch);
192
+ });
193
+
194
+ it('replays contiguously at the same epoch without a resync snapshot', async () => {
195
+ const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
196
+ await mkdir(join(root, 'agent'), { recursive: true });
197
+ const session = new FakeSession();
198
+ const { endpoint } = await track(root, session);
199
+
200
+ const first = connectClient(endpoint);
201
+ sockets.push(first);
202
+ await first.authenticate();
203
+ const snapshot = await first.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
204
+ await first.request('sessions.create', { cwd: root });
205
+ const renamed = first.next((message) => message.kind === 'event' && message.event === 'session.updated');
206
+ session.emit({ type: 'session_info_changed', name: 'one' });
207
+ const renameEvent = await renamed;
208
+
209
+ // Reconnect from the rename cursor, stamping the cursor's stream epoch:
210
+ // the retained suffix replays without a snapshot, and the epoch is
211
+ // unchanged.
212
+ const second = connectClient(endpoint);
213
+ sockets.push(second);
214
+ await second.authenticate({ fromSequence: renameEvent.sequence, streamEpoch: snapshot.streamEpoch });
215
+ session.emit({ type: 'session_info_changed', name: 'two' });
216
+ const replayed = await second.next((message) => message.kind === 'event');
217
+ expect(replayed.event).toBe('session.updated');
218
+ expect(replayed.payload.title).toBe('two');
219
+ expect(replayed.streamEpoch).toBe(snapshot.streamEpoch);
220
+ expect(replayed.sequence).toBeGreaterThan(renameEvent.sequence);
221
+ });
222
+
223
+ it('a restart changes the epoch and a stale cursor resyncs from a lower snapshot baseline', async () => {
224
+ const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
225
+ await mkdir(join(root, 'agent'), { recursive: true });
226
+ const firstSession = new FakeSession();
227
+ const first = await track(root, firstSession);
228
+
229
+ const oldClient = connectClient(first.endpoint);
230
+ sockets.push(oldClient);
231
+ await oldClient.authenticate();
232
+ const oldSnapshot = await oldClient.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
233
+ await oldClient.request('sessions.create', { cwd: root });
234
+ const renameWait = oldClient.next((message) => message.kind === 'event' && message.event === 'session.updated');
235
+ firstSession.emit({ type: 'session_info_changed', name: 'before restart' });
236
+ const renameEvent = await renameWait;
237
+ expect(renameEvent.sequence).toBeGreaterThan(oldSnapshot.sequence);
238
+ const oldEpoch = renameEvent.streamEpoch;
239
+
240
+ // Restart: a brand new daemon process owns the endpoint's role. Its
241
+ // sequence space starts over, so the old epoch must differ and the old
242
+ // cursor must be unreplayable.
243
+ await oldClient.close();
244
+ await first.daemon.stop();
245
+ const secondSession = new FakeSession();
246
+ const second = await startDaemon(root, secondSession);
247
+ daemons.push(second.daemon);
248
+
249
+ const newClient = connectClient(second.endpoint);
250
+ sockets.push(newClient);
251
+ // The client stamps its cursor with the retired epoch, so the daemon can
252
+ // tell the sequence space reset even before looking at the numbers.
253
+ await newClient.authenticate({ fromSequence: renameEvent.sequence, streamEpoch: oldEpoch });
254
+ const resyncSnapshot = await newClient.next((message) => message.kind === 'event');
255
+ expect(resyncSnapshot.event).toBe('session.snapshot');
256
+ expect(resyncSnapshot.payload.resync).toBe(true);
257
+ expect(resyncSnapshot.streamEpoch).toBeTruthy();
258
+ expect(resyncSnapshot.streamEpoch).not.toBe(oldEpoch);
259
+ expect(resyncSnapshot.sequence).toBeLessThan(renameEvent.sequence);
260
+ expect(resyncSnapshot.payload.lastSequence).toBeLessThan(renameEvent.sequence);
261
+
262
+ // Register the restarted runtime so live session events are published.
263
+ await newClient.request('sessions.create', { cwd: root });
264
+
265
+ // Live events after the resync share the new epoch and grow from the
266
+ // lower baseline.
267
+ const liveWait = newClient.next((message) => message.kind === 'event' && message.event === 'session.updated');
268
+ secondSession.emit({ type: 'session_info_changed', name: 'after restart' });
269
+ const live = await liveWait;
270
+ expect(live.streamEpoch).toBe(resyncSnapshot.streamEpoch);
271
+ expect(live.sequence).toBeGreaterThan(resyncSnapshot.sequence);
272
+ });
273
+
274
+ it('rejects a replay cursor without its stream epoch as a protocol mismatch', async () => {
275
+ const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
276
+ await mkdir(join(root, 'agent'), { recursive: true });
277
+ const session = new FakeSession();
278
+ const { endpoint } = await track(root, session);
279
+
280
+ const first = connectClient(endpoint);
281
+ sockets.push(first);
282
+ await first.authenticate();
283
+ const snapshot = await first.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
284
+ await first.request('sessions.create', { cwd: root });
285
+ const renameWait = first.next((message) => message.kind === 'event' && message.event === 'session.updated');
286
+ session.emit({ type: 'session_info_changed', name: 'one' });
287
+ const renameEvent = await renameWait;
288
+
289
+ // An old client reconnects with a replayable cursor but cannot epoch-
290
+ // verify it (no streamEpoch marker). The daemon must reject the resume
291
+ // rather than silently replaying or substituting a snapshot.
292
+ const legacy = connectClient(endpoint);
293
+ sockets.push(legacy);
294
+ await legacy.authenticate({ fromSequence: renameEvent.sequence });
295
+ const legacyFrame = await legacy.next((message) => message.kind === 'error');
296
+ expect(legacyFrame.error).toEqual({ code: 'DAEMON_PROTOCOL_MISMATCH' });
297
+ expect(snapshot.streamEpoch).toBeTruthy();
298
+ });
299
+
300
+ it('a new daemon whose sequence overtook the old cursor resyncs instead of replaying the wrong window', async () => {
301
+ const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
302
+ await mkdir(join(root, 'agent'), { recursive: true });
303
+ const firstSession = new FakeSession();
304
+ const first = await track(root, firstSession);
305
+
306
+ const oldClient = connectClient(first.endpoint);
307
+ sockets.push(oldClient);
308
+ await oldClient.authenticate();
309
+ await oldClient.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
310
+ await oldClient.request('sessions.create', { cwd: root });
311
+ const renameWait = oldClient.next((message) => message.kind === 'event' && message.event === 'session.updated');
312
+ firstSession.emit({ type: 'session_info_changed', name: 'before restart' });
313
+ const renameEvent = await renameWait;
314
+ const oldEpoch = renameEvent.streamEpoch;
315
+ const oldCursor = renameEvent.sequence;
316
+ await oldClient.close();
317
+ await first.daemon.stop();
318
+
319
+ // The restarted daemon emits several events, so its new sequence space
320
+ // numerically OVERTAKES the old client's cursor before it reconnects.
321
+ const secondSession = new FakeSession();
322
+ const second = await startDaemon(root, secondSession);
323
+ daemons.push(second.daemon);
324
+ const warmup = connectClient(second.endpoint);
325
+ sockets.push(warmup);
326
+ await warmup.authenticate();
327
+ await warmup.request('sessions.create', { cwd: root });
328
+ for (let index = 0; index < Math.max(4, oldCursor + 2); index += 1) {
329
+ const wait = warmup.next((message) => message.kind === 'event' && message.event === 'session.updated');
330
+ secondSession.emit({ type: 'session_info_changed', name: `warmup-${index}` });
331
+ await wait;
332
+ }
333
+ const warmupState = await warmup.request('runtime.health');
334
+ const newEpoch = warmupState.result.streamEpoch;
335
+ expect(newEpoch).not.toBe(oldEpoch);
336
+
337
+ // The old cursor is numerically replayable on the new daemon, but the
338
+ // epoch marker proves it belongs to the retired sequence space: the
339
+ // daemon must resync rather than replay events 1..cursor of the new
340
+ // epoch the client never saw.
341
+ const returning = connectClient(second.endpoint);
342
+ sockets.push(returning);
343
+ await returning.authenticate({ fromSequence: oldCursor, streamEpoch: oldEpoch });
344
+ const resync = await returning.next((message) => message.kind === 'event');
345
+ expect(resync.event).toBe('session.snapshot');
346
+ expect(resync.payload.resync).toBe(true);
347
+ expect(resync.streamEpoch).toBe(newEpoch);
348
+ });
349
+ });
@@ -257,6 +257,13 @@ export function createSessionDaemon({
257
257
  let idleDisposeTimer;
258
258
  let dormantSession;
259
259
  let sequence = 0;
260
+ // Opaque, random, public stream-lifetime identifier. It regenerates on every
261
+ // daemon process start (restart, crash, or replacement), so clients can
262
+ // distinguish "same daemon, contiguous sequence" from "new daemon, sequence
263
+ // restarted from zero". It is deliberately NOT derived from the daemon id,
264
+ // profile key, pid, or any other private identity: it exists only to be
265
+ // compared for equality on the public wire.
266
+ const streamEpoch = randomUUID().replace(/-/g, '');
260
267
  let started = false;
261
268
  let stopping = false;
262
269
  const knownDirectories = new Set([cwd]);
@@ -531,6 +538,7 @@ export function createSessionDaemon({
531
538
  protocolVersion: PROTOCOL_VERSION,
532
539
  kind: 'event',
533
540
  event,
541
+ streamEpoch,
534
542
  sequence: ++sequence,
535
543
  payload: {
536
544
  sessionId,
@@ -607,7 +615,7 @@ export function createSessionDaemon({
607
615
  };
608
616
  };
609
617
 
610
- const publishSnapshot = (socket, requestedSessionId) => {
618
+ const publishSnapshot = (socket, requestedSessionId, { resync = false } = {}) => {
611
619
  const targetRuntime = requestedSessionId ? runtimeRegistry?.findBySessionId(requestedSessionId) : runtime;
612
620
  const session = targetRuntime?.session
613
621
  ? { sessionId: targetRuntime.session.sessionId, isStreaming: targetRuntime.session.isStreaming }
@@ -629,10 +637,15 @@ export function createSessionDaemon({
629
637
  protocolVersion: PROTOCOL_VERSION,
630
638
  kind: 'event',
631
639
  event: 'session.snapshot',
640
+ streamEpoch,
632
641
  sequence: snapshotSequence,
633
642
  payload: {
634
643
  ...(session.sessionId ? { sessionId: session.sessionId } : {}),
635
644
  directory: targetDirectory,
645
+ // `resync` tells the client the requested cursor could not be replayed
646
+ // (replay window expired or a daemon restart reset the sequence), so
647
+ // this snapshot is a recovery baseline rather than a routine attach.
648
+ ...(resync ? { resync: true } : {}),
636
649
  isStreaming: session.isStreaming ?? false,
637
650
  lifecycle: retry ? 'retry' : session.isStreaming ? 'busy' : 'idle',
638
651
  ...(retry ? { retry } : {}),
@@ -1564,7 +1577,10 @@ export function createSessionDaemon({
1564
1577
  protocolVersion: PROTOCOL_VERSION,
1565
1578
  kind: 'response',
1566
1579
  requestId,
1567
- result: detail,
1580
+ // Stamp the stream lifetime so a client can reject a detail response
1581
+ // that was generated by a previous daemon process (stale sequence
1582
+ // space) after observing an epoch change.
1583
+ result: { ...detail, streamEpoch },
1568
1584
  };
1569
1585
  if (Buffer.byteLength(JSON.stringify(frame)) > MAX_FRAME_BYTES) {
1570
1586
  throw new SessionDaemonProtocolError(
@@ -3069,7 +3085,10 @@ export function createSessionDaemon({
3069
3085
  latestAssistantMessageIds.delete(sessionId);
3070
3086
  toolInputBySession.delete(sessionId);
3071
3087
  clearToolTimingsForSession(sessionId);
3072
- publish('session.lifecycle', { state: 'idle', deleted: true, serverNow: Date.now() }, sessionId, targetDir);
3088
+ // Explicit typed deletion: every connected and replaying client drops
3089
+ // catalog, transcript, activity, and caches. Archive and directory moves
3090
+ // keep the session id and never publish this event.
3091
+ publish('session.deleted', {}, sessionId, targetDir);
3073
3092
  };
3074
3093
 
3075
3094
  const publishSessionEvent = (sessionId, event, directory = activeDirectory || cwd) => {
@@ -3433,7 +3452,12 @@ export function createSessionDaemon({
3433
3452
  state: 'ready',
3434
3453
  sessionId: getSessionState().sessionId,
3435
3454
  lastSequence: sequence,
3455
+ streamEpoch,
3436
3456
  capabilities: [
3457
+ // Public stream-lifetime identification: every event, snapshot,
3458
+ // and health result carries `streamEpoch`, and session read
3459
+ // responses stamp it so clients can reject stale-epoch data.
3460
+ 'events.streamEpoch',
3437
3461
  'runtime.claim', 'runtime.shutdown',
3438
3462
  'projects.list', 'projects.select', 'sessions.list', 'sessions.create', 'sessions.open', 'sessions.messages', 'sessions.rename', 'sessions.delete',
3439
3463
  'sessions.tree', 'sessions.navigate', 'sessions.fork', 'sessions.clone', 'sessions.prompt',
@@ -3654,7 +3678,9 @@ export function createSessionDaemon({
3654
3678
  protocolVersion: PROTOCOL_VERSION,
3655
3679
  kind: 'response',
3656
3680
  requestId: message.requestId,
3657
- result: { sessions },
3681
+ // Stamp the stream lifetime so clients can reject a listing that a
3682
+ // previous daemon process generated after an epoch change.
3683
+ result: { sessions, streamEpoch },
3658
3684
  });
3659
3685
  return;
3660
3686
  }
@@ -3902,14 +3928,37 @@ export function createSessionDaemon({
3902
3928
  writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'authenticated' });
3903
3929
  const requestedSessionId = typeof message.sessionId === 'string' && message.sessionId.length > 0 ? message.sessionId : undefined;
3904
3930
  const fromSequence = Number.isSafeInteger(message.fromSequence) && message.fromSequence >= 0 ? message.fromSequence : undefined;
3931
+ // Stream-lifetime identity the client's cursor was established
3932
+ // under (capability negotiation). A cursor stamped with a
3933
+ // different epoch belongs to a retired sequence space: even when
3934
+ // this daemon's sequence numerically overtook it, replaying from
3935
+ // it would silently skip the head of the new sequence space.
3936
+ // Subscribers without the marker cannot prove which sequence
3937
+ // space their cursor belongs to. Reject that shape instead of
3938
+ // silently treating it as a valid resume.
3939
+ const requestedEpoch = typeof message.streamEpoch === 'string' && message.streamEpoch.length > 0 && message.streamEpoch.length <= 128
3940
+ ? message.streamEpoch
3941
+ : undefined;
3942
+ if (fromSequence !== undefined && requestedEpoch === undefined) {
3943
+ throw new SessionDaemonProtocolError(
3944
+ 'DAEMON_PROTOCOL_MISMATCH',
3945
+ 'A replay cursor requires its stream epoch.',
3946
+ );
3947
+ }
3948
+ const epochMismatch = requestedEpoch !== undefined && requestedEpoch !== streamEpoch;
3905
3949
  // Contiguity is judged on the global retained suffix while delivery
3906
3950
  // stays session-filtered, so a filtered client never replays through
3907
3951
  // a gap left by eviction, an oversized event, an empty ring, or a
3908
3952
  // future cursor: all of those take the snapshot fallback below.
3909
- if (fromSequence !== undefined && replayLog.canReplay(fromSequence, sequence)) {
3953
+ // Replay additionally requires the epoch marker. The validation
3954
+ // above rejects a cursor that cannot be tied to an epoch.
3955
+ if (fromSequence !== undefined && requestedEpoch !== undefined && !epochMismatch && replayLog.canReplay(fromSequence, sequence)) {
3910
3956
  for (const cachedLine of replayLog.linesAfter(fromSequence, requestedSessionId)) writeLine(socket, cachedLine);
3911
3957
  } else {
3912
- publishSnapshot(socket, requestedSessionId);
3958
+ // A supplied cursor that cannot be replayed is a resync: the
3959
+ // snapshot is the client's recovery baseline for a missed replay
3960
+ // window, a daemon restart, or a cursor from a retired epoch.
3961
+ publishSnapshot(socket, requestedSessionId, { resync: fromSequence !== undefined || epochMismatch === true });
3913
3962
  }
3914
3963
  continue;
3915
3964
  }
@@ -195,12 +195,12 @@ function connectClient(endpoint) {
195
195
 
196
196
  return {
197
197
  socket,
198
- async authenticate(value = credential, { sessionId, fromSequence } = {}) {
198
+ async authenticate(value = credential, { sessionId, fromSequence, streamEpoch } = {}) {
199
199
  await new Promise((resolve, reject) => {
200
200
  socket.once('connect', resolve);
201
201
  socket.once('error', reject);
202
202
  });
203
- socket.write(`${JSON.stringify({ kind: 'authenticate', credential: value, ...(sessionId ? { sessionId } : {}), ...(fromSequence !== undefined ? { fromSequence } : {}) })}\n`);
203
+ socket.write(`${JSON.stringify({ kind: 'authenticate', credential: value, ...(sessionId ? { sessionId } : {}), ...(fromSequence !== undefined ? { fromSequence } : {}), ...(streamEpoch ? { streamEpoch } : {}) })}\n`);
204
204
  await next((message) => message.kind === 'authenticated');
205
205
  if (fromSequence !== undefined) return undefined;
206
206
  return next((message) => message.kind === 'event' && message.event === 'session.snapshot');
@@ -378,12 +378,12 @@ describe('Pi session daemon spike', () => {
378
378
  await first.close();
379
379
 
380
380
  const replay = connectClient(endpoint);
381
- await replay.authenticate(credential, { sessionId: 'pi-session-1', fromSequence: snapshot.sequence });
381
+ await replay.authenticate(credential, { sessionId: 'pi-session-1', fromSequence: snapshot.sequence, streamEpoch: snapshot.streamEpoch });
382
382
  await expect(replay.next((frame) => frame.event === 'assistant.message.delta')).resolves.toMatchObject({ sequence: delta.sequence, payload: { delta: 'replay' } });
383
383
  await replay.close();
384
384
 
385
385
  const stale = connectClient(endpoint);
386
- await stale.authenticate(credential, { sessionId: 'pi-session-1', fromSequence: 0 });
386
+ await stale.authenticate(credential, { sessionId: 'pi-session-1', fromSequence: 0, streamEpoch: snapshot.streamEpoch });
387
387
  await expect(stale.next((frame) => frame.event === 'session.snapshot')).resolves.toMatchObject({ payload: { lastSequence: expect.any(Number) } });
388
388
  await stale.close();
389
389
  });
@@ -418,6 +418,7 @@ describe('Pi session daemon spike', () => {
418
418
  await late.authenticate(credential, {
419
419
  sessionId: 'pi-session-1',
420
420
  fromSequence: detail.result.lastSequence,
421
+ streamEpoch: detail.result.streamEpoch,
421
422
  });
422
423
  const firstDelta = first.next((frame) => frame.event === 'assistant.message.delta');
423
424
  const lateDelta = late.next((frame) => frame.event === 'assistant.message.delta');
@@ -447,6 +448,7 @@ describe('Pi session daemon spike', () => {
447
448
  await resumed.authenticate(credential, {
448
449
  sessionId: 'pi-session-1',
449
450
  fromSequence: lateDeltaFrame.sequence,
451
+ streamEpoch: detail.result.streamEpoch,
450
452
  });
451
453
  const resumedEndFrame = await resumed.next((frame) => frame.event === 'assistant.message.end');
452
454
  expect(resumedEndFrame.sequence).toBe(firstEndFrame.sequence);
@@ -1229,7 +1231,11 @@ describe('Pi session daemon spike', () => {
1229
1231
  await expect(client.request('sessions.abort', { sessionId: 'pi-session-forked' })).resolves.toMatchObject({ result: {} });
1230
1232
  expect(runtime.session.aborted).toBe(1);
1231
1233
  runtime.session.isStreaming = false;
1234
+ const deletedEvent = client.next((frame) => frame.event === 'session.deleted');
1232
1235
  await expect(client.request('sessions.delete', { sessionId: 'pi-session-forked' })).resolves.toMatchObject({ result: {} });
1236
+ await expect(deletedEvent).resolves.toMatchObject({
1237
+ payload: { sessionId: 'pi-session-forked', directory: root },
1238
+ });
1233
1239
  await client.close();
1234
1240
  });
1235
1241
 
@@ -155,7 +155,7 @@ function connectDaemonClient(endpoint) {
155
155
  socket,
156
156
  messages,
157
157
  waitForMessage,
158
- async authenticate(credentialOverride = credential, { sessionId, fromSequence } = {}) {
158
+ async authenticate(credentialOverride = credential, { sessionId, fromSequence, streamEpoch } = {}) {
159
159
  await new Promise((resolve, reject) => {
160
160
  if (socket.connecting === false && socket.pending === false) {
161
161
  return resolve();
@@ -168,6 +168,7 @@ function connectDaemonClient(endpoint) {
168
168
  credential: credentialOverride,
169
169
  ...(sessionId ? { sessionId } : {}),
170
170
  ...(fromSequence !== undefined ? { fromSequence } : {}),
171
+ ...(streamEpoch ? { streamEpoch } : {}),
171
172
  };
172
173
  socket.write(`${JSON.stringify(frame)}\n`);
173
174
  await waitForMessage((message) => message.kind === 'authenticated');
@@ -327,20 +328,24 @@ describe('session replay log bounds', () => {
327
328
 
328
329
  describe('daemon byte-bounded reconnect', () => {
329
330
  let daemon;
331
+ let latestEpoch;
330
332
  const temporaryRoots = [];
331
333
  const connectedClients = new Set();
332
334
 
333
335
  const connectLiveClient = async (endpoint) => {
334
336
  const client = connectDaemonClient(endpoint);
335
337
  connectedClients.add(client);
336
- await client.authenticate();
338
+ const snapshot = await client.authenticate();
339
+ // Track the live daemon epoch so resuming clients can stamp their cursor
340
+ // (replay requires the stream-epoch marker).
341
+ latestEpoch = snapshot.streamEpoch;
337
342
  return client;
338
343
  };
339
344
 
340
345
  const connectResumingClient = async (endpoint, fromSequence) => {
341
346
  const client = connectDaemonClient(endpoint);
342
347
  connectedClients.add(client);
343
- await client.authenticate(credential, { sessionId: 'pi-session-1', fromSequence });
348
+ await client.authenticate(credential, { sessionId: 'pi-session-1', fromSequence, streamEpoch: latestEpoch });
344
349
  return client;
345
350
  };
346
351
 
@@ -495,7 +495,15 @@ export const createPiSessionDaemonSupervisor = ({
495
495
  const claimed = await claimDaemonOwnership(credential);
496
496
  if (isCompatibleBuild && claimed) {
497
497
  const ready = await probe(credential);
498
- return { state: 'ready', reused: true, protocolVersion: PROTOCOL_VERSION, capabilities: ready.health.capabilities ?? [] };
498
+ return {
499
+ state: 'ready',
500
+ reused: true,
501
+ protocolVersion: PROTOCOL_VERSION,
502
+ capabilities: ready.health.capabilities ?? [],
503
+ ...(typeof ready.health.streamEpoch === 'string' && ready.health.streamEpoch.length > 0
504
+ ? { streamEpoch: ready.health.streamEpoch }
505
+ : {}),
506
+ };
499
507
  }
500
508
  // Replace an older protocol/build, and always replace a development
501
509
  // daemon so a source restart cannot keep running stale module code.
@@ -571,7 +579,15 @@ export const createPiSessionDaemonSupervisor = ({
571
579
  while (Date.now() < deadline) {
572
580
  try {
573
581
  const started = await probe(credential);
574
- return { state: 'ready', reused: false, protocolVersion: PROTOCOL_VERSION, capabilities: started.health.capabilities ?? [] };
582
+ return {
583
+ state: 'ready',
584
+ reused: false,
585
+ protocolVersion: PROTOCOL_VERSION,
586
+ capabilities: started.health.capabilities ?? [],
587
+ ...(typeof started.health.streamEpoch === 'string' && started.health.streamEpoch.length > 0
588
+ ? { streamEpoch: started.health.streamEpoch }
589
+ : {}),
590
+ };
575
591
  } catch (error) {
576
592
  if (error instanceof PiSessionDaemonUnavailableError && isPermanentStartupFailure(error.code)) throw error;
577
593
  await wait(RETRY_DELAY_MS);
@@ -627,10 +643,12 @@ export const createPiSessionDaemonSupervisor = ({
627
643
  }
628
644
  };
629
645
 
630
- const subscribe = async ({ sessionId, fromSequence, onEvent, onError }) => {
646
+ const subscribe = async ({ sessionId, fromSequence, streamEpoch, onEvent, onError, signal }) => {
631
647
  try {
648
+ if (signal?.aborted) return () => {};
632
649
  const { credential } = await ensureReady();
633
- return await subscribeSessionDaemon({ endpoint: paths.endpoint, credential, sessionId, fromSequence, onEvent, onError });
650
+ if (signal?.aborted) return () => {};
651
+ return await subscribeSessionDaemon({ endpoint: paths.endpoint, credential, sessionId, fromSequence, streamEpoch, onEvent, onError, signal });
634
652
  } catch (error) {
635
653
  throw new PiSessionDaemonUnavailableError(
636
654
  error instanceof SessionDaemonClientError && error.code !== 'DAEMON_CONNECTION_REFUSED'
@@ -643,7 +661,14 @@ export const createPiSessionDaemonSupervisor = ({
643
661
  const health = async () => {
644
662
  try {
645
663
  const { ready } = await ensureReady();
646
- return { state: 'ready', protocolVersion: PROTOCOL_VERSION, capabilities: ready.health.capabilities ?? [] };
664
+ return {
665
+ state: 'ready',
666
+ protocolVersion: PROTOCOL_VERSION,
667
+ capabilities: ready.health.capabilities ?? [],
668
+ ...(typeof ready.health.streamEpoch === 'string' && ready.health.streamEpoch.length > 0
669
+ ? { streamEpoch: ready.health.streamEpoch }
670
+ : {}),
671
+ };
647
672
  } catch (error) {
648
673
  return {
649
674
  state: 'unavailable',
@@ -87,12 +87,13 @@ describe('Pi session daemon supervisor', () => {
87
87
  };
88
88
 
89
89
  supervisor = createPiSessionDaemonSupervisor({ env, cwd });
90
- await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: false, protocolVersion: 1 });
91
- await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: true, protocolVersion: 1 });
90
+ await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: false, protocolVersion: 1, streamEpoch: expect.stringMatching(/^[0-9a-f]{32}$/) });
91
+ await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: true, protocolVersion: 1, streamEpoch: expect.stringMatching(/^[0-9a-f]{32}$/) });
92
92
  await expect(supervisor.health()).resolves.toEqual({
93
93
  state: 'ready',
94
94
  protocolVersion: 1,
95
- capabilities: expect.arrayContaining(['projects.list', 'projects.select', 'sessions.list', 'sessions.create', 'sessions.open', 'sessions.rename', 'sessions.delete', 'sessions.tree', 'sessions.navigate', 'sessions.fork', 'sessions.clone', 'sessions.prompt', 'sessions.steer', 'sessions.followUp', 'sessions.abort', 'sessions.setModel', 'sessions.setThinking', 'sessions.compact', 'providers.list', 'providers.config.get', 'providers.models.set', 'providers.status', 'providers.login', 'providers.login.respond', 'providers.login.status', 'providers.logout', 'settings.get', 'settings.set', 'resources.list', 'resources.update', 'resources.prompts.create', 'resources.prompts.update', 'resources.prompts.delete']),
95
+ capabilities: expect.arrayContaining(['projects.list', 'projects.select', 'sessions.list', 'sessions.create', 'sessions.open', 'sessions.rename', 'sessions.delete', 'sessions.tree', 'sessions.navigate', 'sessions.fork', 'sessions.clone', 'sessions.prompt', 'sessions.steer', 'sessions.followUp', 'sessions.abort', 'sessions.setModel', 'sessions.setThinking', 'sessions.compact', 'providers.list', 'providers.config.get', 'providers.models.set', 'providers.status', 'providers.login', 'providers.login.respond', 'providers.login.status', 'providers.logout', 'settings.get', 'settings.set', 'resources.list', 'resources.update', 'resources.prompts.create', 'resources.prompts.update', 'resources.prompts.delete', 'events.streamEpoch']),
96
+ streamEpoch: expect.stringMatching(/^[0-9a-f]{32}$/),
96
97
  });
97
98
  await expect(supervisor.request('sessions.list')).resolves.toMatchObject({ sessions: expect.any(Array) });
98
99