@assistkick/create 1.7.0 → 1.9.0

package/templates/assistkick-product-system/tests/web_terminal.test.ts

@@ -1,504 +1,223 @@
 /**
  * Unit tests for Web Terminal (feat_073).
- * Tests PTY session manager logic, command whitelist validation (dec_029),
- * command execution model, and WebSocket handler auth checks.
+ * Tests PTY session manager logic with DB-backed sessions,
+ * claude session resumption, and WebSocket handler auth checks.
  */
-import { describe, it, mock } from 'node:test';
+import { describe, it, mock, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { PtySessionManager } from '../packages/backend/src/services/pty_session_manager.js';
 
-// --- Command Whitelist (dec_029) ---
+// --- Mock helpers ---
 
-describe('Command Prefix Whitelist (dec_029)', () => {
-  const mockLog = mock.fn();
-  const mockSpawn = mock.fn(() => ({
-    onData: mock.fn(),
-    onExit: mock.fn(),
+const createMockPty = () => {
+  const listeners: Record<string, Function> = {};
+  return {
+    onData: mock.fn((cb: Function) => { listeners.data = cb; }),
+    onExit: mock.fn((cb: Function) => { listeners.exit = cb; }),
     write: mock.fn(),
     resize: mock.fn(),
     kill: mock.fn(),
-  }));
-  const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-  it('allows "claude" command', () => {
-    const result = manager.validateCommand('claude');
-    assert.equal(result.valid, true);
-    assert.equal(result.error, undefined);
-  });
-
-  it('allows "claude login" command', () => {
-    const result = manager.validateCommand('claude login');
-    assert.equal(result.valid, true);
-  });
-
-  it('allows "claude --version" command', () => {
-    const result = manager.validateCommand('claude --version');
-    assert.equal(result.valid, true);
-  });
-
-  it('rejects "ls" command', () => {
-    const result = manager.validateCommand('ls');
-    assert.equal(result.valid, false);
-    assert.ok(result.error?.includes('not allowed'));
-  });
-
-  it('rejects "rm -rf /" command', () => {
-    const result = manager.validateCommand('rm -rf /');
-    assert.equal(result.valid, false);
-    assert.ok(result.error?.includes('not allowed'));
-  });
-
-  it('rejects "bash" command', () => {
-    const result = manager.validateCommand('bash');
-    assert.equal(result.valid, false);
-  });
-
-  it('rejects empty command', () => {
-    const result = manager.validateCommand('');
-    assert.equal(result.valid, false);
-    assert.ok(result.error?.includes('Empty'));
-  });
-
-  it('rejects whitespace-only command', () => {
-    const result = manager.validateCommand('   ');
-    assert.equal(result.valid, false);
-    assert.ok(result.error?.includes('Empty'));
-  });
-
-  it('trims leading whitespace before validating', () => {
-    const result = manager.validateCommand('  claude login');
-    assert.equal(result.valid, true);
-  });
-
-  it('rejects "git" command (not in whitelist)', () => {
-    const result = manager.validateCommand('git status');
-    assert.equal(result.valid, false);
-    assert.ok(result.error?.includes('not allowed'));
-  });
-
-  it('rejects "claude-imposter" command (must be exact prefix match)', () => {
-    const result = manager.validateCommand('claude-imposter');
-    assert.equal(result.valid, false);
-  });
-});
+    _emit: (event: string, data: unknown) => listeners[event]?.(data),
+    _listeners: listeners,
+  };
+};
+
+/** In-memory mock DB that mimics Drizzle's API surface for terminal_sessions. */
+const createMockDb = () => {
+  const rows: any[] = [];
+
+  return {
+    _rows: rows,
+    select: () => ({
+      from: () => ({
+        where: (_pred: any) => Promise.resolve(rows.filter(() => true)),
+        then: (resolve: Function) => resolve(rows),
+      }),
+    }),
+    insert: () => ({
+      values: (val: any) => {
+        rows.push(val);
+        return Promise.resolve();
+      },
+    }),
+    update: () => ({
+      set: () => ({
+        where: () => Promise.resolve(),
+      }),
+    }),
+    delete: () => ({
+      where: () => {
+        rows.length = 0;
+        return Promise.resolve();
+      },
+    }),
+  };
+};
 
 // --- PTY Session Manager — session lifecycle ---
 
 describe('PtySessionManager session lifecycle', () => {
-  it('auto-launches claude on session creation', () => {
-    const mockLog = mock.fn();
-    const mockPty = { onData: mock.fn(), onExit: mock.fn(), write: mock.fn(), resize: mock.fn(), kill: mock.fn() };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    const session = manager.createSession('proj-1', 'Project One', 80, 24);
+  let manager: PtySessionManager;
+  let mockSpawn: ReturnType<typeof mock.fn>;
+  let mockLog: ReturnType<typeof mock.fn>;
+  let mockPty: ReturnType<typeof createMockPty>;
+  let mockDb: ReturnType<typeof createMockDb>;
+
+  beforeEach(() => {
+    mockPty = createMockPty();
+    mockSpawn = mock.fn(() => mockPty);
+    mockLog = mock.fn();
+    mockDb = createMockDb();
+    manager = new PtySessionManager({
+      spawn: mockSpawn as any,
+      log: mockLog,
+      projectRoot: '/test',
+      getDb: () => mockDb,
+    });
+  });
+
+  it('auto-launches claude on session creation with --session-id', async () => {
+    const session = await manager.createSession('proj-1', 'Project One', 80, 24);
     assert.ok(session);
     assert.equal(session.projectId, 'proj-1');
     assert.equal(session.projectName, 'Project One');
-    assert.equal(session.state, 'running'); // claude auto-launches on creation
+    assert.equal(session.state, 'running');
     assert.ok(session.id.startsWith('term_'));
-    // claude was spawned automatically with project context
+    assert.ok(session.claudeSessionId); // UUID should be set
+
+    // claude was spawned automatically with project context and --session-id
     assert.equal(mockSpawn.mock.calls.length, 1);
     assert.equal(mockSpawn.mock.calls[0].arguments[0], 'claude');
     const args = mockSpawn.mock.calls[0].arguments[1] as string[];
     assert.ok(args.includes('--dangerously-skip-permissions'));
     assert.ok(args.includes('--append-system-prompt'));
+    assert.ok(args.includes('--session-id'));
+    assert.ok(args.includes(session.claudeSessionId));
     assert.ok(args.some((a: string) => a.includes('proj-1')));
   });
 
-  it('creates separate sessions for the same project (no uniqueness constraint)', () => {
-    const mockLog = mock.fn();
-    const mockSpawn = mock.fn(() => ({ onData: mock.fn(), onExit: mock.fn(), write: mock.fn(), resize: mock.fn(), kill: mock.fn() }));
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    const session1 = manager.createSession('proj-1', 'Project', 80, 24);
-    const session2 = manager.createSession('proj-1', 'Project', 100, 30);
+  it('creates separate sessions for the same project', async () => {
+    const session1 = await manager.createSession('proj-1', 'Project', 80, 24);
+    const session2 = await manager.createSession('proj-1', 'Project', 100, 30);
     assert.notEqual(session1.id, session2.id);
-    assert.equal(mockSpawn.mock.calls.length, 2); // auto-launch for each session
+    assert.notEqual(session1.claudeSessionId, session2.claudeSessionId);
+    assert.equal(mockSpawn.mock.calls.length, 2);
   });
 
-  it('creates separate sessions for different projects', () => {
-    const mockLog = mock.fn();
-    const mockSpawn = mock.fn(() => ({ onData: mock.fn(), onExit: mock.fn(), write: mock.fn(), resize: mock.fn(), kill: mock.fn() }));
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    const session1 = manager.createSession('proj-1', 'Project One', 80, 24);
-    const session2 = manager.createSession('proj-2', 'Project Two', 80, 24);
+  it('creates separate sessions for different projects', async () => {
+    const session1 = await manager.createSession('proj-1', 'Project One', 80, 24);
+    const session2 = await manager.createSession('proj-2', 'Project Two', 80, 24);
     assert.notEqual(session1.id, session2.id);
   });
 
-  it('getSession returns undefined for unknown session id', () => {
-    const mockLog = mock.fn();
-    const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    assert.equal(manager.getSession('term_unknown'), undefined);
-  });
-
-  it('destroySession removes the session and kills running PTY', () => {
-    const mockLog = mock.fn();
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn(),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // session.pty is already set by auto-launch
-    assert.ok(manager.getSession(session.id));
-
-    manager.destroySession(session.id);
-    assert.equal(manager.getSession(session.id), undefined);
+  it('destroySession kills running PTY', async () => {
+    const session = await manager.createSession('proj-1', 'Project', 80, 24);
+    await manager.destroySession(session.id);
     assert.equal(mockPty.kill.mock.calls.length, 1);
   });
 
-  it('destroyAll removes all sessions', () => {
-    const mockLog = mock.fn();
-    const mockPty1 = {
-      onData: mock.fn(),
-      onExit: mock.fn(),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const mockPty2 = {
-      onData: mock.fn(),
-      onExit: mock.fn(),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const ptys = [mockPty1, mockPty2];
+  it('destroyAllPty kills all live PTYs without removing DB records', async () => {
+    const mockPty2 = createMockPty();
+    const ptys = [mockPty, mockPty2];
     let idx = 0;
-    const mockSpawn = mock.fn(() => ptys[idx++]);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    const s1 = manager.createSession('proj-1', 'Project One', 80, 24);
-    const s2 = manager.createSession('proj-2', 'Project Two', 80, 24);
-    // PTYs are already running via auto-launch
-
-    manager.destroyAll();
-    assert.equal(manager.getSession(s1.id), undefined);
-    assert.equal(manager.getSession(s2.id), undefined);
+    mockSpawn = mock.fn(() => ptys[idx++]);
+    manager = new PtySessionManager({
+      spawn: mockSpawn as any,
+      log: mockLog,
+      projectRoot: '/test',
+      getDb: () => mockDb,
+    });
+
+    await manager.createSession('proj-1', 'Project One', 80, 24);
+    await manager.createSession('proj-2', 'Project Two', 80, 24);
+
+    manager.destroyAllPty();
+    assert.equal(mockPty.kill.mock.calls.length, 1);
+    assert.equal(mockPty2.kill.mock.calls.length, 1);
+    // DB rows should still exist
+    assert.equal(mockDb._rows.length, 2);
   });
 
-  it('resizeSession updates stored dimensions and forwards to running PTY', () => {
-    const mockLog = mock.fn();
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn(),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // PTY already running via auto-launch
+  it('resizeSession updates dimensions and forwards to running PTY', async () => {
+    const session = await manager.createSession('proj-1', 'Project', 80, 24);
     manager.resizeSession(session.id, 120, 40);
 
     assert.equal(mockPty.resize.mock.calls.length, 1);
     assert.deepEqual(mockPty.resize.mock.calls[0].arguments, [120, 40]);
-
-    const updated = manager.getSession(session.id);
-    assert.equal(updated?.cols, 120);
-    assert.equal(updated?.rows, 40);
   });
-});
-
-// --- Command execution model (dec_029 enforcement) ---
-
-describe('Command execution — whitelist enforced on every command', () => {
-  it('rejects disallowed command typed character-by-character', () => {
-    const mockLog = mock.fn();
-    let exitHandler: (info: { exitCode: number }) => void = () => {};
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn((cb: Function) => { exitHandler = cb as any; }),
-      write: mock.fn(), resize: mock.fn(), kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-    const output: string[] = [];
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // Let auto-launch exit to enter idle mode
-    exitHandler({ exitCode: 0 });
-    manager.addListener(session.id, (data) => output.push(data));
-
-    // Type "ls" and press Enter (in idle mode)
-    manager.writeToSession(session.id, 'l');
-    manager.writeToSession(session.id, 's');
-    manager.writeToSession(session.id, '\r');
-
-    // Only auto-launch was spawned, no new PTY for disallowed command
-    assert.equal(mockSpawn.mock.calls.length, 1);
-
-    // Output should contain the error message
-    const fullOutput = output.join('');
-    assert.ok(fullOutput.includes('not allowed'));
-  });
-
-  it('allows whitelisted command and spawns PTY', () => {
-    const mockLog = mock.fn();
-    let exitHandler: (info: { exitCode: number }) => void = () => {};
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn((cb: Function) => { exitHandler = cb as any; }),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // Let auto-launch exit to enter idle mode
-    exitHandler({ exitCode: 0 });
-
-    manager.writeToSession(session.id, 'claude login\r');
-
-    // Auto-launch (call 0) + user command (call 1)
-    assert.equal(mockSpawn.mock.calls.length, 2);
-    assert.equal(mockSpawn.mock.calls[1].arguments[0], 'claude');
-    assert.deepEqual(mockSpawn.mock.calls[1].arguments[1], ['login']);
-
-    // Session should be in running state
-    const updated = manager.getSession(session.id);
-    assert.equal(updated?.state, 'running');
-  });
-
-  it('forwards raw input to running PTY process', () => {
-    const mockLog = mock.fn();
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn(),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
 
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // Session is already running via auto-launch — send input directly
+  it('forwards raw input to running PTY process', async () => {
+    await manager.createSession('proj-1', 'Project', 80, 24);
+    const session = await manager.createSession('proj-1', 'Project', 80, 24);
     manager.writeToSession(session.id, 'hello');
     const lastWrite = mockPty.write.mock.calls[mockPty.write.mock.calls.length - 1];
     assert.equal(lastWrite.arguments[0], 'hello');
   });
+});
 
-  it('returns to idle state and shows prompt when command exits', () => {
-    const mockLog = mock.fn();
-    let exitHandler: (info: { exitCode: number; signal?: number }) => void = () => {};
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn((handler: (info: { exitCode: number; signal?: number }) => void) => {
-        exitHandler = handler;
-      }),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-    const output: string[] = [];
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    manager.addListener(session.id, (data) => output.push(data));
-    manager.writeToSession(session.id, 'claude --version\r');
-
-    // Simulate command exit
-    exitHandler({ exitCode: 0 });
-
-    const updated = manager.getSession(session.id);
-    assert.equal(updated?.state, 'idle');
-    assert.equal(updated?.pty, null);
-
-    // Should show prompt again
-    const fullOutput = output.join('');
-    assert.ok(fullOutput.includes('$'));
-  });
+// --- Session resumption ---
 
-  it('prevents arbitrary shell commands even after a valid command exits', () => {
+describe('Session resumption across restarts', () => {
+  it('ensureRunning does not re-spawn for already live session', async () => {
+    const mockPty1 = createMockPty();
+    const mockSpawn = mock.fn(() => mockPty1);
     const mockLog = mock.fn();
-    let exitHandler: (info: { exitCode: number; signal?: number }) => void = () => {};
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn((handler: (info: { exitCode: number; signal?: number }) => void) => {
-        exitHandler = handler;
-      }),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-    const output: string[] = [];
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    manager.addListener(session.id, (data) => output.push(data));
-
-    // Let auto-launch exit to enter idle mode
-    exitHandler({ exitCode: 0 });
-
-    // Clear output to check next command
-    output.length = 0;
-
-    // Try to execute a disallowed command after returning to idle
-    manager.writeToSession(session.id, 'rm -rf /\r');
-
-    // Should NOT spawn a new PTY beyond the initial auto-launch
+    const mockDb = createMockDb();
+    const manager = new PtySessionManager({
+      spawn: mockSpawn as any,
+      log: mockLog,
+      projectRoot: '/test',
+      getDb: () => mockDb,
+    });
+
+    const session = await manager.createSession('proj-1', 'Project', 80, 24);
     assert.equal(mockSpawn.mock.calls.length, 1);
-    const fullOutput = output.join('');
-    assert.ok(fullOutput.includes('not allowed'));
-  });
-
-  it('handles backspace in idle mode', () => {
-    const mockLog = mock.fn();
-    let exitHandler: (info: { exitCode: number }) => void = () => {};
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn((cb: Function) => { exitHandler = cb as any; }),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-    const output: string[] = [];
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // Let auto-launch exit to enter idle mode
-    exitHandler({ exitCode: 0 });
-    manager.addListener(session.id, (data) => output.push(data));
-
-    // Type "ls", backspace twice, type "claude"
-    manager.writeToSession(session.id, 'ls');
-    manager.writeToSession(session.id, '\x7f\x7f'); // two backspaces
-    manager.writeToSession(session.id, 'claude\r');
-
-    // auto-launch (call 0) + user's claude command (call 1)
-    assert.equal(mockSpawn.mock.calls.length, 2);
-    assert.equal(mockSpawn.mock.calls[1].arguments[0], 'claude');
-    assert.deepEqual(mockSpawn.mock.calls[1].arguments[1], []);
-  });
-
-  it('handles Ctrl+C in idle mode (clears input)', () => {
-    const mockLog = mock.fn();
-    let exitHandler: (info: { exitCode: number }) => void = () => {};
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn((cb: Function) => { exitHandler = cb as any; }),
-      write: mock.fn(),
-      resize: mock.fn(),
-      kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-    const output: string[] = [];
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // Let auto-launch exit to enter idle mode
-    exitHandler({ exitCode: 0 });
-    manager.addListener(session.id, (data) => output.push(data));
 
-    // Type "rm" then Ctrl+C
-    manager.writeToSession(session.id, 'rm');
-    manager.writeToSession(session.id, '\x03');
-
-    // Then type a valid command
-    manager.writeToSession(session.id, 'claude\r');
-
-    // auto-launch (call 0) + user's claude command (call 1), Ctrl+C cleared "rm"
-    assert.equal(mockSpawn.mock.calls.length, 2);
-    assert.equal(mockSpawn.mock.calls[1].arguments[0], 'claude');
-  });
-
-  it('handles empty Enter (shows prompt again)', () => {
-    const mockLog = mock.fn();
-    let exitHandler: (info: { exitCode: number }) => void = () => {};
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn((cb: Function) => { exitHandler = cb as any; }),
-      write: mock.fn(), resize: mock.fn(), kill: mock.fn(),
-    };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-    const output: string[] = [];
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // Let auto-launch exit to enter idle mode
-    exitHandler({ exitCode: 0 });
-    manager.addListener(session.id, (data) => output.push(data));
-
-    manager.writeToSession(session.id, '\r');
-
-    // No additional spawn beyond auto-launch
+    const result = await manager.ensureRunning(session.id, 80, 24);
+    assert.equal(result, true);
+    // No extra spawn
     assert.equal(mockSpawn.mock.calls.length, 1);
-
-    // Should show prompt
-    const fullOutput = output.join('');
-    assert.ok(fullOutput.includes('$'));
   });
 
-  it('handles spawn failure gracefully', () => {
+  it('ensureRunning returns false for unknown session', async () => {
+    const mockSpawn = mock.fn();
     const mockLog = mock.fn();
-    const mockSpawn = mock.fn(() => { throw new Error('spawn failed'); });
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-    const output: string[] = [];
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    manager.addListener(session.id, (data) => output.push(data));
-
-    manager.writeToSession(session.id, 'claude\r');
-
-    // Session should remain idle
-    const updated = manager.getSession(session.id);
-    assert.equal(updated?.state, 'idle');
+    const mockDb = createMockDb();
+    const manager = new PtySessionManager({
+      spawn: mockSpawn as any,
+      log: mockLog,
+      projectRoot: '/test',
+      getDb: () => mockDb,
+    });
 
-    // Should show error and prompt
-    const fullOutput = output.join('');
-    assert.ok(fullOutput.includes('Failed to execute'));
-    assert.ok(fullOutput.includes('$'));
+    const result = await manager.ensureRunning('term_unknown', 80, 24);
+    assert.equal(result, false);
   });
 });
 
-// --- Output buffer (dec_030 — session persistence) ---
+// --- Output buffer ---
 
-describe('PTY output buffering (dec_030)', () => {
-  it('buffers welcome message on session creation', () => {
-    const mockLog = mock.fn();
-    const mockPty = { onData: mock.fn(), onExit: mock.fn(), write: mock.fn(), resize: mock.fn(), kill: mock.fn() };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-
-    const buffered = manager.getBufferedOutput(session.id);
-    assert.ok(buffered.includes('Restricted terminal'));
-    // prompt appears after auto-launched claude exits, not before
-  });
-
-  it('buffers PTY command output for reconnection', () => {
-    const mockLog = mock.fn();
+describe('PTY output buffering', () => {
+  it('buffers PTY command output for reconnection', async () => {
     let dataHandler: ((data: string) => void) | null = null;
-    const mockPty = {
+    const mockPty1 = {
       onData: mock.fn((handler: (data: string) => void) => { dataHandler = handler; }),
       onExit: mock.fn(),
       write: mock.fn(),
       resize: mock.fn(),
       kill: mock.fn(),
     };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
+    const mockSpawn = mock.fn(() => mockPty1);
+    const mockLog = mock.fn();
+    const mockDb = createMockDb();
+    const manager = new PtySessionManager({
+      spawn: mockSpawn as any,
+      log: mockLog,
+      projectRoot: '/test',
+      getDb: () => mockDb,
+    });
 
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // dataHandler is captured from the auto-launched claude PTY
+    const session = await manager.createSession('proj-1', 'Project', 80, 24);
 
     assert.ok(dataHandler);
     dataHandler!('Claude v1.0.0');
@@ -508,54 +227,99 @@ describe('PTY output buffering (dec_030)', () => {
   });
 
   it('returns empty string for unknown session id', () => {
-    const mockLog = mock.fn();
     const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
+    const mockLog = mock.fn();
+    const mockDb = createMockDb();
+    const manager = new PtySessionManager({
+      spawn: mockSpawn as any,
+      log: mockLog,
+      projectRoot: '/test',
+      getDb: () => mockDb,
+    });
 
     assert.equal(manager.getBufferedOutput('term_unknown'), '');
   });
 
-  it('notifies listeners when output is produced in idle mode', () => {
-    const mockLog = mock.fn();
-    let exitHandler: (info: { exitCode: number }) => void = () => {};
-    const mockPty = {
-      onData: mock.fn(),
-      onExit: mock.fn((cb: Function) => { exitHandler = cb as any; }),
-      write: mock.fn(), resize: mock.fn(), kill: mock.fn(),
+  it('notifies listeners when output is produced', async () => {
+    let dataHandler: ((data: string) => void) | null = null;
+    const mockPty1 = {
+      onData: mock.fn((handler: (data: string) => void) => { dataHandler = handler; }),
+      onExit: mock.fn(),
+      write: mock.fn(),
+      resize: mock.fn(),
+      kill: mock.fn(),
     };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
+    const mockSpawn = mock.fn(() => mockPty1);
+    const mockLog = mock.fn();
+    const mockDb = createMockDb();
+    const manager = new PtySessionManager({
+      spawn: mockSpawn as any,
+      log: mockLog,
+      projectRoot: '/test',
+      getDb: () => mockDb,
+    });
 
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
-    // Let auto-launch exit to enter idle mode
-    exitHandler({ exitCode: 0 });
+    const session = await manager.createSession('proj-1', 'Project', 80, 24);
 
     const listener = mock.fn();
     manager.addListener(session.id, listener);
 
-    // Typing in idle mode echoes characters to listeners
-    manager.writeToSession(session.id, 'c');
+    // Simulate PTY output
+    dataHandler!('test output');
     assert.ok(listener.mock.calls.length > 0);
-    assert.equal(listener.mock.calls[listener.mock.calls.length - 1].arguments[0], 'c');
+    assert.equal(listener.mock.calls[listener.mock.calls.length - 1].arguments[0], 'test output');
   });
 
-  it('removeListener stops notifications', () => {
+  it('removeListener stops notifications', async () => {
+    let dataHandler: ((data: string) => void) | null = null;
+    const mockPty1 = {
+      onData: mock.fn((handler: (data: string) => void) => { dataHandler = handler; }),
+      onExit: mock.fn(),
+      write: mock.fn(),
+      resize: mock.fn(),
+      kill: mock.fn(),
+    };
+    const mockSpawn = mock.fn(() => mockPty1);
     const mockLog = mock.fn();
-    const mockPty = { onData: mock.fn(), onExit: mock.fn(), write: mock.fn(), resize: mock.fn(), kill: mock.fn() };
-    const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
-
-    const session = manager.createSession('proj-1', 'Project', 80, 24);
+    const mockDb = createMockDb();
+    const manager = new PtySessionManager({
+      spawn: mockSpawn as any,
+      log: mockLog,
+      projectRoot: '/test',
+      getDb: () => mockDb,
+    });
+
+    const session = await manager.createSession('proj-1', 'Project', 80, 24);
     const listener = mock.fn();
     manager.addListener(session.id, listener);
     manager.removeListener(session.id, listener);
 
     const callsBefore = listener.mock.calls.length;
-    manager.writeToSession(session.id, 'x'); // forwarded to running PTY, no echo
+    dataHandler!('test output');
     assert.equal(listener.mock.calls.length, callsBefore);
   });
 });
 
+// --- Session name formatting ---
+
+describe('Session name formatting', () => {
+  it('formats session name as ProjectName - DD/MM/YY - HH:MM', () => {
+    const mockSpawn = mock.fn();
+    const mockLog = mock.fn();
+    const mockDb = createMockDb();
+    const manager = new PtySessionManager({
+      spawn: mockSpawn as any,
+      log: mockLog,
+      projectRoot: '/test',
+      getDb: () => mockDb,
+    });
+
+    const date = new Date(2026, 2, 6, 14, 30);
+    const name = manager.formatSessionName('My Project', date);
+    assert.equal(name, 'My Project - 06/03/26 - 14:30');
+  });
+});
+
 // --- WebSocket auth checks ---
 
 describe('Terminal WebSocket authentication', () => {