@assistkick/create 1.2.0 → 1.3.0

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

@@ -18,7 +18,7 @@ describe('Command Prefix Whitelist (dec_029)', () => {
     resize: mock.fn(),
     kill: mock.fn(),
   }));
-  const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+  const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
 
   it('allows "claude" command', () => {
     const result = manager.validateCommand('claude');
@@ -85,47 +85,54 @@ describe('Command Prefix Whitelist (dec_029)', () => {
 // --- PTY Session Manager — session lifecycle ---
 
 describe('PtySessionManager session lifecycle', () => {
-  it('creates a new session in idle state (no shell spawned)', () => {
+  it('auto-launches claude on session creation', () => {
     const mockLog = mock.fn();
-    const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    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('user-1', 80, 24);
+    const session = manager.createSession('proj-1', 'Project One', 80, 24);
     assert.ok(session);
-    assert.equal(session.userId, 'user-1');
-    assert.equal(session.state, 'idle');
-    assert.equal(session.pty, null);
-    // No shell spawned on session creation
-    assert.equal(mockSpawn.mock.calls.length, 0);
+    assert.equal(session.projectId, 'proj-1');
+    assert.equal(session.projectName, 'Project One');
+    assert.equal(session.state, 'running'); // claude auto-launches on creation
+    assert.ok(session.id.startsWith('term_'));
+    // claude was spawned automatically with project context
+    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.some((a: string) => a.includes('proj-1')));
   });
 
-  it('reuses existing session for same user', () => {
+  it('creates separate sessions for the same project (no uniqueness constraint)', () => {
     const mockLog = mock.fn();
-    const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    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('user-1', 80, 24);
-    const session2 = manager.createSession('user-1', 100, 30);
-    assert.equal(session1, session2);
-    assert.equal(mockSpawn.mock.calls.length, 0);
+    const session1 = manager.createSession('proj-1', 'Project', 80, 24);
+    const session2 = 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
   });
 
-  it('creates separate sessions for different users', () => {
+  it('creates separate sessions for different projects', () => {
     const mockLog = mock.fn();
-    const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    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('user-1', 80, 24);
-    const session2 = manager.createSession('user-2', 80, 24);
-    assert.notEqual(session1, session2);
+    const session1 = manager.createSession('proj-1', 'Project One', 80, 24);
+    const session2 = manager.createSession('proj-2', 'Project Two', 80, 24);
+    assert.notEqual(session1.id, session2.id);
   });
 
-  it('getSession returns undefined for unknown user', () => {
+  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 });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
 
-    assert.equal(manager.getSession('unknown'), undefined);
+    assert.equal(manager.getSession('term_unknown'), undefined);
   });
 
   it('destroySession removes the session and kills running PTY', () => {
@@ -138,15 +145,14 @@ describe('PtySessionManager session lifecycle', () => {
       kill: mock.fn(),
     };
     const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
 
-    manager.createSession('user-1', 80, 24);
-    // Simulate a running command by sending "claude\r"
-    manager.writeToSession('user-1', 'claude\r');
-    assert.ok(manager.getSession('user-1'));
+    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('user-1');
-    assert.equal(manager.getSession('user-1'), undefined);
+    manager.destroySession(session.id);
+    assert.equal(manager.getSession(session.id), undefined);
     assert.equal(mockPty.kill.mock.calls.length, 1);
   });
 
@@ -169,17 +175,15 @@ describe('PtySessionManager session lifecycle', () => {
     const ptys = [mockPty1, mockPty2];
     let idx = 0;
     const mockSpawn = mock.fn(() => ptys[idx++]);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
 
-    manager.createSession('user-1', 80, 24);
-    manager.createSession('user-2', 80, 24);
-    // Start commands so PTYs exist
-    manager.writeToSession('user-1', 'claude\r');
-    manager.writeToSession('user-2', 'claude\r');
+    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('user-1'), undefined);
-    assert.equal(manager.getSession('user-2'), undefined);
+    assert.equal(manager.getSession(s1.id), undefined);
+    assert.equal(manager.getSession(s2.id), undefined);
   });
 
   it('resizeSession updates stored dimensions and forwards to running PTY', () => {
@@ -192,18 +196,18 @@ describe('PtySessionManager session lifecycle', () => {
       kill: mock.fn(),
     };
     const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
 
-    manager.createSession('user-1', 80, 24);
-    manager.writeToSession('user-1', 'claude\r'); // start a command so PTY exists
-    manager.resizeSession('user-1', 120, 40);
+    const session = manager.createSession('proj-1', 'Project', 80, 24);
+    // PTY already running via auto-launch
+    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 session = manager.getSession('user-1');
-    assert.equal(session?.cols, 120);
-    assert.equal(session?.rows, 40);
+    const updated = manager.getSession(session.id);
+    assert.equal(updated?.cols, 120);
+    assert.equal(updated?.rows, 40);
   });
 });
 
@@ -212,20 +216,28 @@ describe('PtySessionManager session lifecycle', () => {
 describe('Command execution — whitelist enforced on every command', () => {
   it('rejects disallowed command typed character-by-character', () => {
     const mockLog = mock.fn();
-    const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    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[] = [];
 
-    manager.createSession('user-1', 80, 24);
-    manager.addListener('user-1', (data) => output.push(data));
+    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
-    manager.writeToSession('user-1', 'l');
-    manager.writeToSession('user-1', 's');
-    manager.writeToSession('user-1', '\r');
+    // Type "ls" and press Enter (in idle mode)
+    manager.writeToSession(session.id, 'l');
+    manager.writeToSession(session.id, 's');
+    manager.writeToSession(session.id, '\r');
 
-    // No PTY should have been spawned
-    assert.equal(mockSpawn.mock.calls.length, 0);
+    // 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('');
@@ -234,27 +246,31 @@ describe('Command execution — whitelist enforced on every command', () => {
 
   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(),
+      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 });
+    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.createSession('user-1', 80, 24);
-    manager.writeToSession('user-1', 'claude login\r');
+    manager.writeToSession(session.id, 'claude login\r');
 
-    // PTY should have been spawned with "claude" and ["login"]
-    assert.equal(mockSpawn.mock.calls.length, 1);
-    assert.equal(mockSpawn.mock.calls[0].arguments[0], 'claude');
-    assert.deepEqual(mockSpawn.mock.calls[0].arguments[1], ['login']);
+    // 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 session = manager.getSession('user-1');
-    assert.equal(session?.state, 'running');
+    const updated = manager.getSession(session.id);
+    assert.equal(updated?.state, 'running');
   });
 
   it('forwards raw input to running PTY process', () => {
@@ -267,15 +283,13 @@ describe('Command execution — whitelist enforced on every command', () => {
       kill: mock.fn(),
     };
     const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
 
-    manager.createSession('user-1', 80, 24);
-    manager.writeToSession('user-1', 'claude\r');
-
-    // Now send input while command is running
-    manager.writeToSession('user-1', 'hello');
-    assert.equal(mockPty.write.mock.calls.length, 1);
-    assert.equal(mockPty.write.mock.calls[0].arguments[0], 'hello');
+    const session = manager.createSession('proj-1', 'Project', 80, 24);
+    // Session is already running via auto-launch — send input directly
+    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', () => {
@@ -291,19 +305,19 @@ describe('Command execution — whitelist enforced on every command', () => {
       kill: mock.fn(),
     };
     const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
     const output: string[] = [];
 
-    manager.createSession('user-1', 80, 24);
-    manager.addListener('user-1', (data) => output.push(data));
-    manager.writeToSession('user-1', 'claude --version\r');
+    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 session = manager.getSession('user-1');
-    assert.equal(session?.state, 'idle');
-    assert.equal(session?.pty, null);
+    const updated = manager.getSession(session.id);
+    assert.equal(updated?.state, 'idle');
+    assert.equal(updated?.pty, null);
 
     // Should show prompt again
     const fullOutput = output.join('');
@@ -323,95 +337,109 @@ describe('Command execution — whitelist enforced on every command', () => {
       kill: mock.fn(),
     };
     const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
     const output: string[] = [];
 
-    manager.createSession('user-1', 80, 24);
-    manager.addListener('user-1', (data) => output.push(data));
+    const session = manager.createSession('proj-1', 'Project', 80, 24);
+    manager.addListener(session.id, (data) => output.push(data));
 
-    // Execute a valid command
-    manager.writeToSession('user-1', 'claude --version\r');
+    // 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('user-1', 'rm -rf /\r');
+    manager.writeToSession(session.id, 'rm -rf /\r');
 
-    // Should NOT spawn a new PTY
-    assert.equal(mockSpawn.mock.calls.length, 1); // only the first valid command
+    // Should NOT spawn a new PTY beyond the initial auto-launch
+    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(),
+      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 });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
     const output: string[] = [];
 
-    manager.createSession('user-1', 80, 24);
-    manager.addListener('user-1', (data) => output.push(data));
+    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('user-1', 'ls');
-    manager.writeToSession('user-1', '\x7f\x7f'); // two backspaces
-    manager.writeToSession('user-1', 'claude\r');
+    manager.writeToSession(session.id, 'ls');
+    manager.writeToSession(session.id, '\x7f\x7f'); // two backspaces
+    manager.writeToSession(session.id, 'claude\r');
 
-    // Should have spawned claude (not ls)
-    assert.equal(mockSpawn.mock.calls.length, 1);
-    assert.equal(mockSpawn.mock.calls[0].arguments[0], 'claude');
+    // 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(),
+      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 });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
     const output: string[] = [];
 
-    manager.createSession('user-1', 80, 24);
-    manager.addListener('user-1', (data) => output.push(data));
+    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('user-1', 'rm');
-    manager.writeToSession('user-1', '\x03');
+    manager.writeToSession(session.id, 'rm');
+    manager.writeToSession(session.id, '\x03');
 
     // Then type a valid command
-    manager.writeToSession('user-1', 'claude\r');
+    manager.writeToSession(session.id, 'claude\r');
 
-    // Should have spawned claude (Ctrl+C cleared "rm")
-    assert.equal(mockSpawn.mock.calls.length, 1);
-    assert.equal(mockSpawn.mock.calls[0].arguments[0], 'claude');
+    // 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();
-    const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    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[] = [];
 
-    manager.createSession('user-1', 80, 24);
-    manager.addListener('user-1', (data) => output.push(data));
+    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('user-1', '\r');
+    manager.writeToSession(session.id, '\r');
 
-    // No spawn
-    assert.equal(mockSpawn.mock.calls.length, 0);
+    // No additional spawn beyond auto-launch
+    assert.equal(mockSpawn.mock.calls.length, 1);
 
     // Should show prompt
     const fullOutput = output.join('');
@@ -421,17 +449,17 @@ describe('Command execution — whitelist enforced on every command', () => {
   it('handles spawn failure gracefully', () => {
     const mockLog = mock.fn();
     const mockSpawn = mock.fn(() => { throw new Error('spawn failed'); });
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
     const output: string[] = [];
 
-    manager.createSession('user-1', 80, 24);
-    manager.addListener('user-1', (data) => output.push(data));
+    const session = manager.createSession('proj-1', 'Project', 80, 24);
+    manager.addListener(session.id, (data) => output.push(data));
 
-    manager.writeToSession('user-1', 'claude\r');
+    manager.writeToSession(session.id, 'claude\r');
 
     // Session should remain idle
-    const session = manager.getSession('user-1');
-    assert.equal(session?.state, 'idle');
+    const updated = manager.getSession(session.id);
+    assert.equal(updated?.state, 'idle');
 
     // Should show error and prompt
     const fullOutput = output.join('');
@@ -443,16 +471,17 @@ describe('Command execution — whitelist enforced on every command', () => {
 // --- Output buffer (dec_030 — session persistence) ---
 
 describe('PTY output buffering (dec_030)', () => {
-  it('buffers output including welcome message and prompt', () => {
+  it('buffers welcome message on session creation', () => {
     const mockLog = mock.fn();
-    const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    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' });
 
-    manager.createSession('user-1', 80, 24);
+    const session = manager.createSession('proj-1', 'Project', 80, 24);
 
-    const buffered = manager.getBufferedOutput('user-1');
+    const buffered = manager.getBufferedOutput(session.id);
     assert.ok(buffered.includes('Restricted terminal'));
-    assert.ok(buffered.includes('$'));
+    // prompt appears after auto-launched claude exits, not before
   });
 
   it('buffers PTY command output for reconnection', () => {
@@ -466,53 +495,63 @@ describe('PTY output buffering (dec_030)', () => {
       kill: mock.fn(),
     };
     const mockSpawn = mock.fn(() => mockPty);
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
 
-    manager.createSession('user-1', 80, 24);
-    manager.writeToSession('user-1', 'claude --version\r');
+    const session = manager.createSession('proj-1', 'Project', 80, 24);
+    // dataHandler is captured from the auto-launched claude PTY
 
     assert.ok(dataHandler);
     dataHandler!('Claude v1.0.0');
 
-    const buffered = manager.getBufferedOutput('user-1');
+    const buffered = manager.getBufferedOutput(session.id);
     assert.ok(buffered.includes('Claude v1.0.0'));
   });
 
-  it('returns empty string for unknown user', () => {
+  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 });
+    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog, projectRoot: '/test' });
 
-    assert.equal(manager.getBufferedOutput('unknown'), '');
+    assert.equal(manager.getBufferedOutput('term_unknown'), '');
   });
 
-  it('notifies listeners when output is produced', () => {
+  it('notifies listeners when output is produced in idle mode', () => {
     const mockLog = mock.fn();
-    const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    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.createSession('user-1', 80, 24);
     const listener = mock.fn();
-    manager.addListener('user-1', listener);
+    manager.addListener(session.id, listener);
 
-    // Typing echoes characters
-    manager.writeToSession('user-1', 'c');
+    // Typing in idle mode echoes characters to listeners
+    manager.writeToSession(session.id, 'c');
     assert.ok(listener.mock.calls.length > 0);
     assert.equal(listener.mock.calls[listener.mock.calls.length - 1].arguments[0], 'c');
   });
 
   it('removeListener stops notifications', () => {
     const mockLog = mock.fn();
-    const mockSpawn = mock.fn();
-    const manager = new PtySessionManager({ spawn: mockSpawn as any, log: mockLog });
+    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' });
 
-    manager.createSession('user-1', 80, 24);
+    const session = manager.createSession('proj-1', 'Project', 80, 24);
     const listener = mock.fn();
-    manager.addListener('user-1', listener);
-    manager.removeListener('user-1', listener);
+    manager.addListener(session.id, listener);
+    manager.removeListener(session.id, listener);
 
     const callsBefore = listener.mock.calls.length;
-    manager.writeToSession('user-1', 'x');
+    manager.writeToSession(session.id, 'x'); // forwarded to running PTY, no echo
     assert.equal(listener.mock.calls.length, callsBefore);
   });
 });