@pi-chamber/web 1.0.2-rc.1 → 1.0.3-rc.1

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 (58) hide show
  1. package/dist/assets/{DiagramView-GUJij-1P.js → DiagramView-CXjieF51.js} +1 -1
  2. package/dist/assets/DiffView-CXg8TAtI.js +18 -0
  3. package/dist/assets/{FileSaveConflictDialog-Ci6WdSiS.js → FileSaveConflictDialog-a-HOCgyP.js} +1 -1
  4. package/dist/assets/{FilesView-DBiWEo71.js → FilesView-Dcd9ltOX.js} +1 -1
  5. package/dist/assets/{GitView-DVyhqN5s.js → GitView-DF2nsuSA.js} +3 -3
  6. package/dist/assets/{JsonTreeView-BaU7aAUq.js → JsonTreeView-BRU2mRTd.js} +1 -1
  7. package/dist/assets/{MarkdownRendererImpl-6NBJLtEr.js → MarkdownRendererImpl-CeYMkg1A.js} +5 -5
  8. package/dist/assets/{PatchDiff-CvptevA2.js → PatchDiff-kSTpjhu6.js} +1 -1
  9. package/dist/assets/{SessionSwitcherContent-Cqp5FVCP.js → SessionSwitcherContent-BsXDFt24.js} +1 -1
  10. package/dist/assets/{SessionSwitcherDropdown-CRVJU16x.js → SessionSwitcherDropdown-D8fSObHr.js} +2 -2
  11. package/dist/assets/{SessionUnreadDot-CsFxImPI.js → SessionUnreadDot-BpsHyrri.js} +1 -1
  12. package/dist/assets/SettingsView-OEl7QmXC.js +6 -0
  13. package/dist/assets/{SettingsWindow-geMUhnxd.js → SettingsWindow-BMBCj_L_.js} +1 -1
  14. package/dist/assets/{ToolOutputDialog-BLGl2mNt.js → ToolOutputDialog-KOVdmTqm.js} +1 -1
  15. package/dist/assets/{ToolPartDiffPreview-BVeL1IuE.js → ToolPartDiffPreview-B9xuVvkm.js} +1 -1
  16. package/dist/assets/{VirtualizedFileDiff-9kAZ96se.js → VirtualizedFileDiff-CV_Cpmqu.js} +4 -4
  17. package/dist/assets/{collapsible-BencOwkW.js → collapsible-BH1vXEAI.js} +1 -1
  18. package/dist/assets/{computeVirtualFileMetrics-C8vH0vcM.js → computeVirtualFileMetrics-yHZbtf5H.js} +2 -2
  19. package/dist/assets/{contextFileOpenGuard-B6e3cTcl.js → contextFileOpenGuard-BA2pkQY_.js} +1 -1
  20. package/dist/assets/{gitStatusPredicates-B6w5GMNU.js → gitStatusPredicates-CpGQLvMK.js} +1 -1
  21. package/dist/assets/index-5fyXnZFi.css +1 -0
  22. package/dist/assets/{index-CpSdU-d4.js → index-C-sV_9sb.js} +3 -3
  23. package/dist/assets/{index-BifnX1Mp.js → index-D_FGGnQQ.js} +1 -1
  24. package/dist/assets/{isDiffPlainText-BepQ1JHv.js → isDiffPlainText-BNyusJZz.js} +1 -1
  25. package/dist/assets/{isFilePlainText-CA1KFaTm.js → isFilePlainText-CMAUe7qD.js} +1 -1
  26. package/dist/assets/{main-dhVDQIHu.js → main-BMLgZ5yn.js} +2 -2
  27. package/dist/assets/{main-TzeSIx1W.js → main-DNq1n9F_.js} +3 -3
  28. package/dist/assets/{markdownCore-BztwD2c9.js → markdownCore-CZWcaNr2.js} +2 -2
  29. package/dist/assets/{miniChat-smqdx0Y7.js → miniChat-B2AgUZqL.js} +2 -2
  30. package/dist/assets/{mobile-BV-WCEiE.js → mobile-BsGiRUUg.js} +2 -2
  31. package/dist/assets/{renderElectronMiniChatApp-DKmb9oa7.js → renderElectronMiniChatApp-UV9dnnbf.js} +2 -2
  32. package/dist/assets/renderMobileApp-BMifduGA.js +11 -0
  33. package/dist/assets/runtimeEndpointReset-CkvC02dQ.js +53 -0
  34. package/dist/assets/{runtimeSurface-Bm6cRkok.js → runtimeSurface-BdndJV2m.js} +1 -1
  35. package/dist/assets/{useAppFontEffects-Dq7xKVjh.js → useAppFontEffects-CclUs9KY.js} +98 -98
  36. package/dist/assets/{useFilesViewSearch-Bvlo7C3a.js → useFilesViewSearch-CI5Gy1cp.js} +1 -1
  37. package/dist/assets/{usePushVisibilityBeacon-BY4xtozp.js → usePushVisibilityBeacon-aDmGZrTW.js} +3 -3
  38. package/dist/assets/{useSwitcherItems-CkE242zK.js → useSwitcherItems-BZKyNjhp.js} +1 -1
  39. package/dist/assets/{vendor-codemirror-language-data-Bv6kN79m.js → vendor-codemirror-language-data-C6LBD7qA.js} +2 -2
  40. package/dist/assets/{web-components-CCiRgoOw.js → web-components-Cdnmh4Xb.js} +4 -4
  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/lib/pi/model-config-store.js +146 -20
  46. package/server/lib/pi/model-config-store.test.js +153 -21
  47. package/server/lib/pi/routes.js +42 -1
  48. package/server/lib/pi/routes.test.js +104 -2
  49. package/server/lib/pi/session-daemon/DOCUMENTATION.md +3 -2
  50. package/server/lib/pi/session-daemon/session-daemon.js +322 -58
  51. package/server/lib/pi/session-daemon/session-daemon.test.js +335 -0
  52. package/server/lib/pi/session-daemon/session-failed-create-cleanup.test.js +372 -0
  53. package/server/lib/pi/session-persistence-gap.test.js +731 -0
  54. package/dist/assets/DiffView-BZ487Bhh.js +0 -18
  55. package/dist/assets/SettingsView-ppaIrPry.js +0 -2
  56. package/dist/assets/index-Dwz16owi.css +0 -1
  57. package/dist/assets/renderMobileApp-D3dtjeaE.js +0 -11
  58. package/dist/assets/runtimeEndpointReset-C1EENUlq.js +0 -53
@@ -0,0 +1,731 @@
1
+ import { afterEach, describe, expect, it } from 'vitest';
2
+ import { mkdir, mkdtemp, readFile, rm, stat, writeFile } 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
+ import { createSessionDaemon } from './session-daemon/session-daemon.js';
8
+ import { resolveSessionLeaseFile } from './session-daemon/session-lease.js';
9
+
10
+ /**
11
+ * Focused ephemeral-session lifecycle coverage.
12
+ *
13
+ * Pi's `SessionManager` defers JSONL creation until the first assistant
14
+ * message, so `sessions.create` alone stays ephemeral and a rejected first
15
+ * prompt persists nothing. The contract under test:
16
+ *
17
+ * 1. A rejected first prompt keeps the runtime resident and retryable until
18
+ * normal idle disposal (no materialization, no recycle, lease held).
19
+ * 2. Successful idle disposal positively checks the assigned JSONL: when
20
+ * absent (ENOENT only) it clears matching dormant state and publishes the
21
+ * existing `session.deleted` event so connected clients remove it.
22
+ * 3. Persisted sessions keep dormant/reopen behavior and emit no deletion.
23
+ * 4. A non-ENOENT stat failure never claims deletion.
24
+ * 5. A failed idle disposal retains ownership (registry, lease, runtime) and
25
+ * emits no deletion; a later disposal can still recover.
26
+ * 6. Untouched creates stay ephemeral across restart.
27
+ * 7. An unknown session file (throwing/missing getSessionFile) never claims
28
+ * deletion: disposal still releases cleanly without emitting deleted.
29
+ * 8. A stolen lease blocks deletion publication: determination happens while
30
+ * the lease is held, release is attempted, and session.deleted publishes
31
+ * only after a successful release, closing the cross-daemon recreate
32
+ * race. When release reports not-owned, the runtime still disposes but no
33
+ * deletion publishes and a later open reports SESSION_IN_USE.
34
+ * 9. Failed `sessions.create` model/thinking cleanup stays covered by
35
+ * `session-daemon/session-failed-create-cleanup.test.js`.
36
+ *
37
+ * Seam notes (existing injection only, no new DI):
38
+ * - `createRuntime` fakes Pi's session surface so prompt rejection
39
+ * (`preflightResult(false)` + `INVALID_MODEL`) exercises the real daemon
40
+ * idle-disposal and event path against temp dirs.
41
+ * - One-request-per-connection IPC (like production `requestSessionDaemon`)
42
+ * so prompt rejections resolve as error frames with preserved codes.
43
+ * - One persistent subscriber per idle-disposal test observes the broadcast
44
+ * `session.deleted` / `session.error` events.
45
+ */
46
+
47
+ const credential = 'ephemeral-lifecycle-regression-secret';
48
+
49
+ const testDaemonEndpoint = (root) => {
50
+ if (process.platform === 'win32') return `\\\\.\\pipe\\pichamber-ephemeral-${process.pid}-${Math.random().toString(16).slice(2)}`;
51
+ return join(root, 'daemon.sock');
52
+ };
53
+
54
+ const daemonRequest = (endpoint, command, payload, timeoutMs = 20_000) => new Promise((resolve, reject) => {
55
+ const requestId = `req-${Math.random().toString(16).slice(2)}`;
56
+ const socket = createConnection({ path: endpoint });
57
+ const decoder = new StringDecoder('utf8');
58
+ let buffer = '';
59
+ let authenticated = false;
60
+ let settled = false;
61
+ const timer = setTimeout(() => {
62
+ if (!settled) {
63
+ settled = true;
64
+ socket.destroy();
65
+ reject(new Error(`Timed out waiting for daemon ${command}`));
66
+ }
67
+ }, timeoutMs);
68
+ const finish = (callback, value) => {
69
+ if (settled) return;
70
+ settled = true;
71
+ clearTimeout(timer);
72
+ socket.destroy();
73
+ callback(value);
74
+ };
75
+ socket.once('error', (error) => finish(reject, error));
76
+ socket.on('connect', () => {
77
+ socket.write(`${JSON.stringify({ kind: 'authenticate', credential })}\n`);
78
+ });
79
+ socket.on('data', (chunk) => {
80
+ buffer += decoder.write(chunk);
81
+ for (;;) {
82
+ const newline = buffer.indexOf('\n');
83
+ if (newline === -1) return;
84
+ const line = buffer.slice(0, newline).replace(/\r$/, '');
85
+ buffer = buffer.slice(newline + 1);
86
+ if (!line) continue;
87
+ const frame = JSON.parse(line);
88
+ if (!authenticated) {
89
+ if (frame.kind !== 'authenticated') {
90
+ finish(reject, new Error(`Daemon authentication failed for ${command}`));
91
+ return;
92
+ }
93
+ authenticated = true;
94
+ socket.write(`${JSON.stringify({
95
+ protocolVersion: 1, kind: 'request', requestId, command, payload,
96
+ })}\n`);
97
+ continue;
98
+ }
99
+ if (frame.kind === 'response' && frame.requestId === requestId) {
100
+ finish(resolve, { ok: true, result: frame.result });
101
+ return;
102
+ }
103
+ if (frame.kind === 'error') {
104
+ finish(resolve, { ok: false, error: frame.error });
105
+ return;
106
+ }
107
+ }
108
+ });
109
+ socket.on('close', () => {
110
+ if (!settled && authenticated) finish(reject, new Error(`Daemon connection closed waiting for ${command}`));
111
+ });
112
+ });
113
+
114
+ function connectSubscriber(endpoint) {
115
+ const socket = createConnection({ path: endpoint });
116
+ const decoder = new StringDecoder('utf8');
117
+ let buffer = '';
118
+ const messages = [];
119
+ const waiters = [];
120
+ const publishMessage = (message) => {
121
+ messages.push(message);
122
+ for (let index = waiters.length - 1; index >= 0; index -= 1) {
123
+ const waiter = waiters[index];
124
+ if (waiter.predicate(message)) {
125
+ waiters.splice(index, 1);
126
+ clearTimeout(waiter.timer);
127
+ waiter.resolve(message);
128
+ }
129
+ }
130
+ };
131
+ socket.on('data', (chunk) => {
132
+ buffer += decoder.write(chunk);
133
+ for (;;) {
134
+ const newline = buffer.indexOf('\n');
135
+ if (newline === -1) return;
136
+ const line = buffer.slice(0, newline).replace(/\r$/, '');
137
+ buffer = buffer.slice(newline + 1);
138
+ if (line) publishMessage(JSON.parse(line));
139
+ }
140
+ });
141
+ const waitForMessage = (predicate, timeoutMs = 5_000) => {
142
+ const hit = messages.find(predicate);
143
+ if (hit) return Promise.resolve(hit);
144
+ return new Promise((resolve, reject) => {
145
+ const waiter = { predicate, resolve, reject };
146
+ waiter.timer = setTimeout(() => {
147
+ const index = waiters.indexOf(waiter);
148
+ if (index !== -1) waiters.splice(index, 1);
149
+ reject(new Error('Timed out waiting for daemon message'));
150
+ }, timeoutMs);
151
+ waiters.push(waiter);
152
+ });
153
+ };
154
+ return {
155
+ waitForMessage,
156
+ async authenticate() {
157
+ await new Promise((resolve, reject) => {
158
+ socket.once('connect', resolve);
159
+ socket.once('error', reject);
160
+ });
161
+ socket.write(`${JSON.stringify({ kind: 'authenticate', credential })}\n`);
162
+ await waitForMessage((message) => message.kind === 'authenticated');
163
+ return waitForMessage((message) => message.kind === 'event' && message.event === 'session.snapshot');
164
+ },
165
+ async close() {
166
+ for (const waiter of waiters.splice(0)) {
167
+ clearTimeout(waiter.timer);
168
+ waiter.reject(new Error('Daemon client closed'));
169
+ }
170
+ if (!socket.destroyed) {
171
+ socket.end();
172
+ await Promise.race([
173
+ new Promise((resolve) => socket.once('close', resolve)),
174
+ new Promise((resolve) => setTimeout(resolve, 1_000)),
175
+ ]);
176
+ }
177
+ },
178
+ };
179
+ }
180
+
181
+ function sleep(ms) {
182
+ return new Promise((resolve) => setTimeout(resolve, ms));
183
+ }
184
+
185
+ async function waitFor(predicate, { timeoutMs = 5_000, intervalMs = 10, message = 'Timed out' } = {}) {
186
+ const start = Date.now();
187
+ for (;;) {
188
+ try {
189
+ if (await predicate()) return true;
190
+ } catch {
191
+ // Retry until the timeout expires.
192
+ }
193
+ if (Date.now() - start > timeoutMs) throw new Error(message);
194
+ await sleep(intervalMs);
195
+ }
196
+ }
197
+
198
+ function rejectedPromptError() {
199
+ return Object.assign(new Error('first-input rejected'), { code: 'INVALID_MODEL' });
200
+ }
201
+
202
+ class FakeSession {
203
+ constructor(sessionId, sessionFile, { rejectPrompt = false } = {}) {
204
+ this.sessionId = sessionId;
205
+ this.isStreaming = false;
206
+ this.isCompacting = false;
207
+ this.listeners = new Set();
208
+ this.names = [];
209
+ this.entries = [];
210
+ this.promptCalls = 0;
211
+ this.rejectPrompt = rejectPrompt;
212
+ this.model = { provider: 'test', id: 'model' };
213
+ this.thinkingLevel = 'low';
214
+ this.sessionManager = {
215
+ getSessionFile: () => sessionFile,
216
+ getHeader: () => ({ type: 'session', id: sessionId, cwd: '/tmp', timestamp: '2026-01-01T00:00:00.000Z' }),
217
+ getEntries: () => this.entries,
218
+ getEntry: (entryId) => this.entries.find((candidate) => candidate?.id === entryId)
219
+ ?? (entryId === 'fake-entry' ? { id: entryId } : undefined),
220
+ getSessionId: () => sessionId,
221
+ getLeafId: () => 'fake-entry',
222
+ getTree: () => [
223
+ { entry: { id: 'fake-entry', parentId: undefined, timestamp: '2026-01-01T00:00:00.000Z' }, children: [] },
224
+ ],
225
+ appendSessionInfo: (name) => this.names.push(name),
226
+ getSessionName: () => this.names[this.names.length - 1],
227
+ };
228
+ }
229
+
230
+ subscribe(listener) {
231
+ this.listeners.add(listener);
232
+ return () => this.listeners.delete(listener);
233
+ }
234
+
235
+ async prompt(text, options) {
236
+ this.promptCalls += 1;
237
+ if (this.rejectPrompt) {
238
+ options?.preflightResult?.(false);
239
+ throw rejectedPromptError();
240
+ }
241
+ options?.preflightResult?.(true);
242
+ }
243
+
244
+ async navigateTree() {
245
+ return { cancelled: false };
246
+ }
247
+
248
+ async abort() {
249
+ this.isStreaming = false;
250
+ }
251
+
252
+ getSteeringMessages() {
253
+ return [];
254
+ }
255
+
256
+ getFollowUpMessages() {
257
+ return [];
258
+ }
259
+ }
260
+
261
+ class FakeRuntime {
262
+ constructor({ cwd, session, onDispose }) {
263
+ this.cwd = cwd;
264
+ this.session = session;
265
+ this.disposed = false;
266
+ this.onDispose = onDispose;
267
+ }
268
+
269
+ async dispose() {
270
+ if (typeof this.onDispose === 'function') await this.onDispose(this);
271
+ this.disposed = true;
272
+ }
273
+ }
274
+
275
+ function createSessionHeaderLine(sessionId, cwd) {
276
+ return `${JSON.stringify({ type: 'session', id: sessionId, cwd, timestamp: '2026-01-01T00:00:00.000Z' })}\n`;
277
+ }
278
+
279
+ describe('ephemeral session lifecycle', () => {
280
+ let tempRoot;
281
+ const daemons = [];
282
+ const subscribers = [];
283
+
284
+ afterEach(async () => {
285
+ while (subscribers.length > 0) {
286
+ const subscriber = subscribers.pop();
287
+ await subscriber.close().catch(() => {});
288
+ }
289
+ while (daemons.length > 0) {
290
+ const daemon = daemons.pop();
291
+ await daemon.stop().catch(() => {});
292
+ }
293
+ if (tempRoot) {
294
+ await rm(tempRoot, { recursive: true, force: true }).catch(() => {});
295
+ tempRoot = null;
296
+ }
297
+ });
298
+
299
+ async function setupDirs(prefix) {
300
+ tempRoot = await mkdtemp(join(tmpdir(), prefix));
301
+ const projectDir = join(tempRoot, 'project');
302
+ const agentDir = join(tempRoot, 'agent');
303
+ const endpoint = testDaemonEndpoint(tempRoot);
304
+ await mkdir(projectDir, { recursive: true });
305
+ await mkdir(agentDir, { recursive: true });
306
+ return { projectDir, agentDir, endpoint };
307
+ }
308
+
309
+ function leaseFileFor({ agentDir, projectDir, sessionId }) {
310
+ return resolveSessionLeaseFile({ agentDir, cwd: projectDir, sessionId }).file;
311
+ }
312
+
313
+ function startDaemon({ endpoint, projectDir, agentDir, idleTimeoutMs, createRuntime, listSessions }) {
314
+ const daemon = createSessionDaemon({
315
+ endpoint,
316
+ credential,
317
+ cwd: projectDir,
318
+ agentDir,
319
+ idleTimeoutMs,
320
+ profileKey: 'test-ephemeral-profile',
321
+ daemonId: `test-ephemeral-daemon-${Math.random().toString(16).slice(2)}`,
322
+ serverInstanceId: `test-ephemeral-server-${Math.random().toString(16).slice(2)}`,
323
+ serverPid: process.pid,
324
+ ...(createRuntime ? { createRuntime } : {}),
325
+ ...(listSessions ? { listSessions } : {}),
326
+ });
327
+ daemons.push(daemon);
328
+ return daemon;
329
+ }
330
+
331
+ it('a rejected first prompt keeps the runtime resident and retryable until idle disposal', async () => {
332
+ const { projectDir, agentDir, endpoint } = await setupDirs('pichamber-ephemeral-resident-');
333
+ const sessionId = 'rejected-first-input';
334
+ const assignedPath = join(agentDir, 'sessions', '--tmp-project--', `20260101T000000Z_${sessionId}.jsonl`);
335
+ const session = new FakeSession(sessionId, assignedPath, { rejectPrompt: true });
336
+ const runtime = new FakeRuntime({ cwd: projectDir, session });
337
+ let createRuntimeCalls = 0;
338
+ const daemon = startDaemon({
339
+ endpoint, projectDir, agentDir, idleTimeoutMs: 60_000,
340
+ createRuntime: async () => {
341
+ createRuntimeCalls += 1;
342
+ return runtime;
343
+ },
344
+ listSessions: async () => [],
345
+ });
346
+ await daemon.start();
347
+
348
+ const created = await daemonRequest(endpoint, 'sessions.create', { cwd: projectDir });
349
+ expect(created.ok).toBe(true);
350
+ expect(created.result?.session?.id).toBe(sessionId);
351
+
352
+ // The original prompt error propagates unchanged.
353
+ const rejected = await daemonRequest(endpoint, 'sessions.prompt', { sessionId, text: 'hello rejected' });
354
+ expect(rejected.ok).toBe(false);
355
+ expect(rejected.error?.code).toBe('INVALID_MODEL');
356
+
357
+ // Nothing is materialized: the assigned JSONL stays absent and the lease
358
+ // stays held by the resident runtime.
359
+ await expect(stat(assignedPath)).rejects.toMatchObject({ code: 'ENOENT' });
360
+ expect(runtime.disposed).toBe(false);
361
+ await expect(stat(leaseFileFor({ agentDir, projectDir, sessionId }))).resolves.toBeDefined();
362
+
363
+ // The session stays retryable on the same resident runtime: reopening
364
+ // does not create a second runtime and a second prompt reports the same
365
+ // prompt error rather than SESSION_IN_USE or INVALID_SESSION.
366
+ const opened = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
367
+ expect(opened.ok).toBe(true);
368
+ expect(opened.result?.session?.id).toBe(sessionId);
369
+ expect(createRuntimeCalls).toBe(1);
370
+
371
+ const retried = await daemonRequest(endpoint, 'sessions.prompt', { sessionId, text: 'hello again' });
372
+ expect(retried.ok).toBe(false);
373
+ expect(retried.error?.code).toBe('INVALID_MODEL');
374
+ expect(session.promptCalls).toBe(2);
375
+ expect(createRuntimeCalls).toBe(1);
376
+ expect(runtime.disposed).toBe(false);
377
+
378
+ // While resident, the ephemeral session is still listed through the
379
+ // resident registry overlay even though nothing reached disk.
380
+ const listed = await daemonRequest(endpoint, 'sessions.list', { directory: projectDir });
381
+ expect(listed.ok).toBe(true);
382
+ expect(listed.result.sessions.map((entry) => entry.session.id)).toContain(sessionId);
383
+ }, 60_000);
384
+
385
+ it('idle disposal of an ephemeral session publishes session.deleted and clears dormant state', async () => {
386
+ const { projectDir, agentDir, endpoint } = await setupDirs('pichamber-ephemeral-disposal-');
387
+ const sessionId = 'ephemeral-idle-session';
388
+ const assignedPath = join(agentDir, 'sessions', '--tmp-project--', `20260101T000000Z_${sessionId}.jsonl`);
389
+ const session = new FakeSession(sessionId, assignedPath, { rejectPrompt: true });
390
+ const runtime = new FakeRuntime({ cwd: projectDir, session });
391
+ const daemon = startDaemon({
392
+ endpoint, projectDir, agentDir, idleTimeoutMs: 50,
393
+ createRuntime: async () => runtime,
394
+ listSessions: async () => [],
395
+ });
396
+ await daemon.start();
397
+
398
+ const subscriber = connectSubscriber(endpoint);
399
+ subscribers.push(subscriber);
400
+ await subscriber.authenticate();
401
+
402
+ const created = await daemonRequest(endpoint, 'sessions.create', { cwd: projectDir });
403
+ expect(created.ok).toBe(true);
404
+ const rejected = await daemonRequest(endpoint, 'sessions.prompt', { sessionId, text: 'hello ephemeral' });
405
+ expect(rejected.ok).toBe(false);
406
+ expect(rejected.error?.code).toBe('INVALID_MODEL');
407
+
408
+ // The rejected session is evicted by normal idle disposal, which
409
+ // positively finds its assigned JSONL absent and reports deletion.
410
+ const deleted = await subscriber.waitForMessage(
411
+ (message) => message.event === 'session.deleted' && message.payload?.sessionId === sessionId,
412
+ );
413
+ expect(deleted.payload?.directory).toBe(projectDir);
414
+ await waitFor(() => runtime.disposed === true, { message: 'ephemeral runtime was not disposed' });
415
+ await waitFor(
416
+ async () => (await stat(leaseFileFor({ agentDir, projectDir, sessionId })).then(() => false).catch((error) => error?.code === 'ENOENT')) === true,
417
+ { message: 'ephemeral lease was not released' },
418
+ );
419
+
420
+ // Dormant state is cleared: the session is gone from listings and can no
421
+ // longer be opened, instead of reopening from a stale dormant record.
422
+ const listed = await daemonRequest(endpoint, 'sessions.list', { directory: projectDir });
423
+ expect(listed.ok).toBe(true);
424
+ expect(listed.result.sessions.map((entry) => entry.session.id)).not.toContain(sessionId);
425
+ const opened = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
426
+ expect(opened.ok).toBe(false);
427
+ expect(opened.error?.code).toBe('INVALID_SESSION');
428
+ }, 60_000);
429
+
430
+ it('idle disposal of a persisted session keeps dormant reopen behavior and emits no deletion', async () => {
431
+ const { projectDir, agentDir, endpoint } = await setupDirs('pichamber-ephemeral-persisted-');
432
+ const sessionId = 'persisted-idle-session';
433
+ const sessionFile = join(tempRoot, `${sessionId}.jsonl`);
434
+ await writeFile(sessionFile, createSessionHeaderLine(sessionId, projectDir));
435
+ let createRuntimeCalls = 0;
436
+ const runtimes = [];
437
+ const daemon = startDaemon({
438
+ endpoint, projectDir, agentDir, idleTimeoutMs: 50,
439
+ createRuntime: async (options) => {
440
+ createRuntimeCalls += 1;
441
+ const runtime = new FakeRuntime({ cwd: projectDir, session: new FakeSession(sessionId, options?.sessionFile ?? sessionFile) });
442
+ runtimes.push(runtime);
443
+ return runtime;
444
+ },
445
+ listSessions: async () => [{ path: sessionFile, id: sessionId, cwd: projectDir }],
446
+ });
447
+ await daemon.start();
448
+
449
+ const subscriber = connectSubscriber(endpoint);
450
+ subscribers.push(subscriber);
451
+ await subscriber.authenticate();
452
+ let deletedSeen = false;
453
+ void subscriber.waitForMessage(
454
+ (message) => message.event === 'session.deleted' && message.payload?.sessionId === sessionId,
455
+ ).then(() => { deletedSeen = true; }).catch(() => {});
456
+
457
+ const opened = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
458
+ expect(opened.ok).toBe(true);
459
+ expect(createRuntimeCalls).toBe(1);
460
+
461
+ // Idle disposal runs (the file exists, so the session is persisted) but
462
+ // must not report deletion.
463
+ await waitFor(() => runtimes[0]?.disposed === true, { message: 'persisted runtime was not disposed' });
464
+ await sleep(300);
465
+ expect(deletedSeen).toBe(false);
466
+
467
+ // Dormant/reopen behavior is retained: opening again rehydrates from the
468
+ // persisted JSONL instead of failing as INVALID_SESSION.
469
+ const reopened = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
470
+ expect(reopened.ok).toBe(true);
471
+ expect(reopened.result?.session?.id).toBe(sessionId);
472
+ expect(createRuntimeCalls).toBe(2);
473
+ }, 60_000);
474
+
475
+ it('a non-ENOENT stat failure during idle disposal never claims deletion', async () => {
476
+ const { projectDir, agentDir, endpoint } = await setupDirs('pichamber-ephemeral-stat-');
477
+ const sessionId = 'stat-failure-session';
478
+ // A regular file in the assigned path's position makes stat fail with
479
+ // ENOTDIR (not ENOENT), which must never be treated as absence.
480
+ const blockerFile = join(tempRoot, 'blocker');
481
+ await writeFile(blockerFile, 'blocker');
482
+ const assignedPath = join(blockerFile, `${sessionId}.jsonl`);
483
+ const session = new FakeSession(sessionId, assignedPath, { rejectPrompt: true });
484
+ const runtime = new FakeRuntime({ cwd: projectDir, session });
485
+ const daemon = startDaemon({
486
+ endpoint, projectDir, agentDir, idleTimeoutMs: 50,
487
+ createRuntime: async () => runtime,
488
+ listSessions: async () => [],
489
+ });
490
+ await daemon.start();
491
+
492
+ const subscriber = connectSubscriber(endpoint);
493
+ subscribers.push(subscriber);
494
+ await subscriber.authenticate();
495
+ let deletedSeen = false;
496
+ void subscriber.waitForMessage(
497
+ (message) => message.event === 'session.deleted' && message.payload?.sessionId === sessionId,
498
+ ).then(() => { deletedSeen = true; }).catch(() => {});
499
+
500
+ const created = await daemonRequest(endpoint, 'sessions.create', { cwd: projectDir });
501
+ expect(created.ok).toBe(true);
502
+ const rejected = await daemonRequest(endpoint, 'sessions.prompt', { sessionId, text: 'hello stat' });
503
+ expect(rejected.ok).toBe(false);
504
+ expect(rejected.error?.code).toBe('INVALID_MODEL');
505
+
506
+ // Disposal still runs and releases the lease, but claims no deletion.
507
+ await waitFor(() => runtime.disposed === true, { message: 'runtime was not disposed' });
508
+ await waitFor(
509
+ async () => (await stat(leaseFileFor({ agentDir, projectDir, sessionId })).then(() => false).catch((error) => error?.code === 'ENOENT')) === true,
510
+ { message: 'lease was not released' },
511
+ );
512
+ await sleep(300);
513
+ expect(deletedSeen).toBe(false);
514
+ }, 60_000);
515
+
516
+ it('a failed idle disposal retains ownership and emits no deletion', async () => {
517
+ const { projectDir, agentDir, endpoint } = await setupDirs('pichamber-ephemeral-dispose-fail-');
518
+ const sessionId = 'dispose-failed-session';
519
+ const assignedPath = join(agentDir, 'sessions', '--tmp-project--', `20260101T000000Z_${sessionId}.jsonl`);
520
+ const session = new FakeSession(sessionId, assignedPath, { rejectPrompt: true });
521
+ let disposeShouldFail = true;
522
+ const runtime = new FakeRuntime({
523
+ cwd: projectDir,
524
+ session,
525
+ onDispose: async () => {
526
+ if (disposeShouldFail) throw new Error('dispose rejected');
527
+ },
528
+ });
529
+ let createRuntimeCalls = 0;
530
+ const daemon = startDaemon({
531
+ endpoint, projectDir, agentDir, idleTimeoutMs: 50,
532
+ createRuntime: async () => {
533
+ createRuntimeCalls += 1;
534
+ return runtime;
535
+ },
536
+ listSessions: async () => [],
537
+ });
538
+ await daemon.start();
539
+
540
+ const subscriber = connectSubscriber(endpoint);
541
+ subscribers.push(subscriber);
542
+ await subscriber.authenticate();
543
+ let deletedSeen = false;
544
+ void subscriber.waitForMessage(
545
+ (message) => message.event === 'session.deleted' && message.payload?.sessionId === sessionId,
546
+ ).then(() => { deletedSeen = true; }).catch(() => {});
547
+
548
+ const created = await daemonRequest(endpoint, 'sessions.create', { cwd: projectDir });
549
+ expect(created.ok).toBe(true);
550
+ const rejected = await daemonRequest(endpoint, 'sessions.prompt', { sessionId, text: 'hello dispose' });
551
+ expect(rejected.ok).toBe(false);
552
+
553
+ // The failed disposal surfaces session.error, keeps the registry entry,
554
+ // lease, and runtime, and never emits deletion.
555
+ const disposalError = await subscriber.waitForMessage(
556
+ (message) => message.event === 'session.error' && message.payload?.sessionId === sessionId,
557
+ );
558
+ expect(disposalError.payload?.code).toBe('RUNTIME_DISPOSAL_FAILED');
559
+ expect(runtime.disposed).toBe(false);
560
+ await expect(stat(leaseFileFor({ agentDir, projectDir, sessionId }))).resolves.toBeDefined();
561
+ const opened = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
562
+ expect(opened.ok).toBe(true);
563
+ expect(createRuntimeCalls).toBe(1);
564
+ await sleep(200);
565
+ expect(deletedSeen).toBe(false);
566
+
567
+ // Recovery: once disposal succeeds, the next idle disposal (re-armed
568
+ // by a fresh access) reports the ephemeral session as deleted exactly
569
+ // once.
570
+ disposeShouldFail = false;
571
+ const reopened = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
572
+ expect(reopened.ok).toBe(true);
573
+ expect(createRuntimeCalls).toBe(1);
574
+ const deleted = await subscriber.waitForMessage(
575
+ (message) => message.event === 'session.deleted' && message.payload?.sessionId === sessionId,
576
+ );
577
+ expect(deleted.payload?.directory).toBe(projectDir);
578
+ await waitFor(() => runtime.disposed === true, { message: 'retained runtime did not recover' });
579
+ await waitFor(
580
+ async () => (await stat(leaseFileFor({ agentDir, projectDir, sessionId })).then(() => false).catch((error) => error?.code === 'ENOENT')) === true,
581
+ { message: 'retained lease was not released on recovery' },
582
+ );
583
+ }, 60_000);
584
+
585
+ it('sessions created but never prompted stay ephemeral across restart', async () => {
586
+ const { projectDir, agentDir, endpoint } = await setupDirs('pichamber-ephemeral-untouched-');
587
+ const sessionId = 'untouched-session';
588
+ const session = new FakeSession(sessionId, undefined);
589
+ const runtime = new FakeRuntime({ cwd: projectDir, session });
590
+ const daemon = startDaemon({
591
+ endpoint, projectDir, agentDir, idleTimeoutMs: 60_000,
592
+ createRuntime: async () => runtime,
593
+ listSessions: async () => [],
594
+ });
595
+ await daemon.start();
596
+
597
+ const created = await daemonRequest(endpoint, 'sessions.create', { cwd: projectDir });
598
+ expect(created.ok).toBe(true);
599
+ expect(created.result?.session?.id).toBe(sessionId);
600
+
601
+ const listedBefore = await daemonRequest(endpoint, 'sessions.list', { directory: projectDir });
602
+ expect(listedBefore.ok).toBe(true);
603
+ expect(listedBefore.result.sessions.map((entry) => entry.session.id)).toContain(sessionId);
604
+
605
+ await daemon.stop();
606
+ daemons.pop();
607
+ const restarted = startDaemon({
608
+ endpoint, projectDir, agentDir, idleTimeoutMs: 60_000,
609
+ createRuntime: async () => {
610
+ throw new Error('must not create a runtime for an ephemeral session');
611
+ },
612
+ listSessions: async () => [],
613
+ });
614
+ await restarted.start();
615
+
616
+ const listedAfter = await daemonRequest(endpoint, 'sessions.list', { directory: projectDir });
617
+ expect(listedAfter.ok).toBe(true);
618
+ expect(listedAfter.result.sessions.map((entry) => entry.session.id)).not.toContain(sessionId);
619
+
620
+ const openedAfter = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
621
+ expect(openedAfter.ok).toBe(false);
622
+ expect(openedAfter.error?.code).toBe('INVALID_SESSION');
623
+ }, 60_000);
624
+
625
+ it('an unknown session file never claims deletion during idle disposal', async () => {
626
+ const { projectDir, agentDir, endpoint } = await setupDirs('pichamber-ephemeral-unknown-');
627
+ const sessionId = 'unknown-file-session';
628
+ const session = new FakeSession(sessionId, undefined, { rejectPrompt: true });
629
+ // Unknown: getSessionFile throws, so ephemerality cannot be proven.
630
+ // The daemon must still dispose and release cleanly without emitting
631
+ // deletion (cannot prove absent) and without surfacing disposal failure.
632
+ session.sessionManager.getSessionFile = () => { throw new Error('unknown session file'); };
633
+ const runtime = new FakeRuntime({ cwd: projectDir, session });
634
+ const daemon = startDaemon({
635
+ endpoint, projectDir, agentDir, idleTimeoutMs: 50,
636
+ createRuntime: async () => runtime,
637
+ listSessions: async () => [],
638
+ });
639
+ await daemon.start();
640
+
641
+ const subscriber = connectSubscriber(endpoint);
642
+ subscribers.push(subscriber);
643
+ await subscriber.authenticate();
644
+ let deletedSeen = false;
645
+ void subscriber.waitForMessage(
646
+ (message) => message.event === 'session.deleted' && message.payload?.sessionId === sessionId,
647
+ ).then(() => { deletedSeen = true; }).catch(() => {});
648
+ let disposalFailed = false;
649
+ void subscriber.waitForMessage(
650
+ (message) => message.event === 'session.error' && message.payload?.sessionId === sessionId,
651
+ ).then(() => { disposalFailed = true; }).catch(() => {});
652
+
653
+ const created = await daemonRequest(endpoint, 'sessions.create', { cwd: projectDir });
654
+ expect(created.ok).toBe(true);
655
+ const rejected = await daemonRequest(endpoint, 'sessions.prompt', { sessionId, text: 'hello unknown' });
656
+ expect(rejected.ok).toBe(false);
657
+ expect(rejected.error?.code).toBe('INVALID_MODEL');
658
+
659
+ // Disposal still runs and releases the lease, but claims no deletion
660
+ // and reports no disposal failure: unknown means cannot prove absent.
661
+ await waitFor(() => runtime.disposed === true, { message: 'runtime was not disposed' });
662
+ await waitFor(
663
+ async () => (await stat(leaseFileFor({ agentDir, projectDir, sessionId })).then(() => false).catch((error) => error?.code === 'ENOENT')) === true,
664
+ { message: 'lease was not released' },
665
+ );
666
+ await sleep(300);
667
+ expect(deletedSeen).toBe(false);
668
+ expect(disposalFailed).toBe(false);
669
+ }, 60_000);
670
+
671
+ it('a stolen lease blocks deletion publication (publish only after successful release)', async () => {
672
+ const { projectDir, agentDir, endpoint } = await setupDirs('pichamber-ephemeral-stolen-');
673
+ const sessionId = 'stolen-lease-session';
674
+ const assignedPath = join(agentDir, 'sessions', '--tmp-project--', `20260101T000000Z_${sessionId}.jsonl`);
675
+ const session = new FakeSession(sessionId, assignedPath, { rejectPrompt: true });
676
+ const runtime = new FakeRuntime({ cwd: projectDir, session });
677
+ const daemon = startDaemon({
678
+ endpoint, projectDir, agentDir, idleTimeoutMs: 100,
679
+ createRuntime: async () => runtime,
680
+ listSessions: async () => [],
681
+ });
682
+ await daemon.start();
683
+
684
+ const subscriber = connectSubscriber(endpoint);
685
+ subscribers.push(subscriber);
686
+ await subscriber.authenticate();
687
+ let deletedSeen = false;
688
+ void subscriber.waitForMessage(
689
+ (message) => message.event === 'session.deleted' && message.payload?.sessionId === sessionId,
690
+ ).then(() => { deletedSeen = true; }).catch(() => {});
691
+
692
+ const created = await daemonRequest(endpoint, 'sessions.create', { cwd: projectDir });
693
+ expect(created.ok).toBe(true);
694
+ const rejected = await daemonRequest(endpoint, 'sessions.prompt', { sessionId, text: 'hello stolen' });
695
+ expect(rejected.ok).toBe(false);
696
+ expect(rejected.error?.code).toBe('INVALID_MODEL');
697
+
698
+ // Cross-daemon steal: overwrite the lease with a different live owner
699
+ // before idle disposal fires. The daemon still disposes its registry
700
+ // entry, but release reports not-owned, so no deletion may publish.
701
+ // This proves publication happens only after a successful release;
702
+ // precise stat-vs-release interleaving beyond this gate is not
703
+ // observable through existing IPC/lease seams without new DI.
704
+ const leaseFile = leaseFileFor({ agentDir, projectDir, sessionId });
705
+ await expect(stat(leaseFile)).resolves.toBeDefined();
706
+ await writeFile(leaseFile, JSON.stringify({
707
+ profileKey: 'thief-profile',
708
+ serverInstanceId: 'thief-server',
709
+ daemonId: 'thief-daemon',
710
+ daemonPid: process.pid,
711
+ sessionId,
712
+ cwd: projectDir,
713
+ agentDir,
714
+ acquiredAt: new Date().toISOString(),
715
+ }));
716
+
717
+ await waitFor(() => runtime.disposed === true, { message: 'runtime was not disposed' });
718
+ await sleep(400);
719
+ expect(deletedSeen).toBe(false);
720
+ // The lease is still held by the thief, so no deletion was published
721
+ // and ownership was not handed back. Open still fails INVALID_SESSION
722
+ // (no JSONL exists for this ephemeral id); the proof of blocked
723
+ // publication is the surviving thief lease below, contrasting with the
724
+ // successful-release case where the lease is ENOENT after deletion.
725
+ const thiefLease = JSON.parse(await readFile(leaseFile, 'utf8'));
726
+ expect(thiefLease.daemonId).toBe('thief-daemon');
727
+ const opened = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
728
+ expect(opened.ok).toBe(false);
729
+ expect(opened.error?.code).toBe('INVALID_SESSION');
730
+ }, 60_000);
731
+ });