cognitive-core 0.1.0 → 0.2.0

package/references/sessionlog/src/__tests__/e2e-live.test.ts

@@ -0,0 +1,890 @@
+/**
+ * Comprehensive E2E Live Tests for Sessionlog
+ *
+ * Tests the full sessionlog lifecycle with real Claude Code sessions:
+ * session creation, file tracking, commit handling, status reporting,
+ * doctor/clean, token usage, and checkpoint verification via CLI binary.
+ *
+ * Note on checkpoints: In single-turn `-p` mode, Claude creates files and
+ * commits within one turn. The checkpoint trailer requires a shadow branch
+ * (created during saveStep/TurnEnd), which doesn't exist yet when
+ * prepare-commit-msg fires within the same turn. Checkpoint verification
+ * is therefore tested deterministically via CLI binary piping (Suite 7).
+ *
+ * Gated behind LIVE_AGENT=1 environment variable:
+ *   LIVE_AGENT=1 npx vitest run src/__tests__/e2e-live.test.ts
+ *
+ * Prerequisites:
+ *   - `claude` CLI installed and authenticated (Claude Max or API key)
+ *   - `npm run build` has been run (dist/ exists)
+ *   - `npm link` has been run (sessionlog available in PATH)
+ */
+
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { execFileSync, execSync } from 'node:child_process';
+
+const LIVE = process.env.LIVE_AGENT === '1';
+const HOOK_WAIT_MS = 2000;
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function initRepo(dir: string): void {
+  execFileSync('git', ['init'], { cwd: dir, stdio: 'pipe' });
+  execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: dir, stdio: 'pipe' });
+  execFileSync('git', ['config', 'user.name', 'Test'], { cwd: dir, stdio: 'pipe' });
+  fs.writeFileSync(path.join(dir, 'README.md'), '# Test Project\n\nA simple test project.');
+  execFileSync('git', ['add', '.'], { cwd: dir, stdio: 'pipe' });
+  execFileSync('git', ['commit', '-m', 'initial commit'], { cwd: dir, stdio: 'pipe' });
+}
+
+function enableSessionlog(dir: string): void {
+  execFileSync('sessionlog', ['enable', '--force', '--agent', 'claude-code'], {
+    cwd: dir,
+    stdio: 'pipe',
+  });
+}
+
+/**
+ * Read all session state files from .git/sessionlog-sessions/.
+ */
+function readSessionStates(dir: string): Record<string, unknown>[] {
+  const sessionsDir = path.join(dir, '.git', 'sessionlog-sessions');
+  if (!fs.existsSync(sessionsDir)) return [];
+
+  return fs
+    .readdirSync(sessionsDir)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(sessionsDir, f), 'utf-8'));
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean) as Record<string, unknown>[];
+}
+
+/**
+ * Run claude in print mode with the given prompt.
+ */
+function runClaude(
+  dir: string,
+  prompt: string,
+  opts?: {
+    allowedTools?: string[];
+    systemPrompt?: string;
+    timeoutMs?: number;
+    model?: string;
+  },
+): string {
+  const args = ['-p', '--dangerously-skip-permissions'];
+
+  if (opts?.model) {
+    args.push('--model', opts.model);
+  } else {
+    args.push('--model', 'sonnet');
+  }
+
+  if (opts?.allowedTools?.length) {
+    args.push('--allowedTools', opts.allowedTools.join(','));
+  }
+
+  if (opts?.systemPrompt) {
+    args.push('--system-prompt', opts.systemPrompt);
+  }
+
+  args.push('--', prompt);
+
+  const cmd = ['claude', ...args].map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+
+  const result = execSync(cmd, {
+    cwd: dir,
+    timeout: opts?.timeoutMs ?? 120_000,
+    encoding: 'utf-8',
+    env: {
+      ...process.env,
+      CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+    },
+  });
+
+  return result;
+}
+
+/**
+ * Run a sessionlog CLI command and return stdout.
+ */
+function runSessionlog(dir: string, args: string[], timeoutMs = 30_000): string {
+  return execSync(`sessionlog ${args.join(' ')}`, {
+    cwd: dir,
+    timeout: timeoutMs,
+    encoding: 'utf-8',
+    env: { ...process.env },
+  });
+}
+
+/**
+ * Parse sessionlog status --json output.
+ */
+function getStatus(dir: string): Record<string, unknown> {
+  const output = runSessionlog(dir, ['status', '--json']);
+  return JSON.parse(output);
+}
+
+/**
+ * Get the last commit message (full body with trailers).
+ */
+function getLastCommitMessage(dir: string): string {
+  return execFileSync('git', ['log', '-1', '--format=%B'], {
+    cwd: dir,
+    encoding: 'utf-8',
+  });
+}
+
+/**
+ * Count commits on current branch.
+ */
+function getCommitCount(dir: string): number {
+  const output = execFileSync('git', ['rev-list', '--count', 'HEAD'], {
+    cwd: dir,
+    encoding: 'utf-8',
+  });
+  return parseInt(output.trim(), 10);
+}
+
+/**
+ * List git branches matching a pattern.
+ */
+function listGitBranches(dir: string, pattern?: string): string[] {
+  const args = ['branch', '--list'];
+  if (pattern) args.push(pattern);
+  const output = execFileSync('git', args, { cwd: dir, encoding: 'utf-8' });
+  return output
+    .trim()
+    .split('\n')
+    .map((b) => b.replace('* ', '').trim())
+    .filter(Boolean);
+}
+
+/**
+ * Get HEAD commit SHA.
+ */
+function getHead(dir: string): string {
+  return execFileSync('git', ['rev-parse', 'HEAD'], {
+    cwd: dir,
+    encoding: 'utf-8',
+  }).trim();
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe.skipIf(!LIVE)('Live E2E — Core Sessionlog', () => {
+  let tmpDir: string;
+
+  beforeAll(() => {
+    // Verify prerequisites
+    try {
+      execFileSync('which', ['sessionlog'], { stdio: 'pipe' });
+    } catch {
+      throw new Error('sessionlog not found in PATH. Run: npm run build && npm link');
+    }
+    try {
+      execFileSync('which', ['claude'], { stdio: 'pipe' });
+    } catch {
+      throw new Error('claude CLI not found in PATH');
+    }
+  });
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sessionlog-live-e2e-'));
+    initRepo(tmpDir);
+    enableSessionlog(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // ==========================================================================
+  // Suite 1: Session Lifecycle
+  // ==========================================================================
+
+  describe('Session Lifecycle', () => {
+    it('should create session state when Claude edits a file', async () => {
+      const output = runClaude(
+        tmpDir,
+        'Create a file called src/hello.ts with this exact content: export function hello() { return "Hello"; }',
+        {
+          allowedTools: ['Write'],
+          systemPrompt: 'Create only the requested file. Do not run any other commands.',
+          timeoutMs: 120_000,
+        },
+      );
+
+      console.log('Claude output:', output.slice(0, 500));
+
+      await new Promise((r) => setTimeout(r, HOOK_WAIT_MS));
+
+      // Verify file was created
+      const srcDir = path.join(tmpDir, 'src');
+      const fileCreated =
+        fs.existsSync(path.join(srcDir, 'hello.ts')) ||
+        fs.existsSync(path.join(tmpDir, 'hello.ts'));
+      console.log('File created:', fileCreated);
+
+      // Verify session state
+      const sessions = readSessionStates(tmpDir);
+      console.log('Sessions found:', sessions.length);
+
+      expect(sessions.length).toBeGreaterThan(0);
+
+      const session = sessions[0];
+      expect(session.agentType).toBe('Claude Code');
+      expect(session.startedAt).toBeDefined();
+      expect(typeof session.startedAt).toBe('string');
+      expect(session.baseCommit).toBeDefined();
+      expect(typeof session.baseCommit).toBe('string');
+      expect((session.baseCommit as string).length).toBe(40);
+    }, 180_000);
+
+    it('should track files and commit when Claude creates and commits', async () => {
+      const initialHead = getHead(tmpDir);
+
+      const output = runClaude(
+        tmpDir,
+        [
+          'Do these two steps exactly:',
+          '1. Create a file at src/greet.ts with content: export const greet = (n: string) => "Hi " + n;',
+          '2. Then run these exact shell commands: git add src/greet.ts && git commit -m "feat: add greet function"',
+        ].join('\n'),
+        {
+          allowedTools: ['Write', 'Bash'],
+          systemPrompt:
+            'Create the file and commit it using the exact commands specified. Do not do anything else.',
+          timeoutMs: 120_000,
+        },
+      );
+
+      console.log('Claude output:', output.slice(0, 500));
+
+      await new Promise((r) => setTimeout(r, HOOK_WAIT_MS));
+
+      // Verify file exists
+      const fileExists = fs.existsSync(path.join(tmpDir, 'src', 'greet.ts'));
+      console.log('File exists:', fileExists);
+      expect(fileExists).toBe(true);
+
+      // Verify a new commit was made
+      const commitCount = getCommitCount(tmpDir);
+      console.log('Commit count:', commitCount);
+      expect(commitCount).toBeGreaterThan(1);
+
+      // Verify HEAD changed
+      const newHead = getHead(tmpDir);
+      console.log('HEAD changed:', initialHead !== newHead);
+      expect(newHead).not.toBe(initialHead);
+
+      // Check commit message for checkpoint trailer (informational only).
+      // In single-turn -p mode, the shadow branch doesn't exist yet when
+      // prepare-commit-msg fires, so the trailer won't be injected.
+      // Checkpoint creation is tested deterministically in Suite 7 via CLI piping.
+      const commitMsg = getLastCommitMessage(tmpDir);
+      console.log('Commit message:', commitMsg.trim());
+      const hasCheckpointTrailer = /Sessionlog-Checkpoint:\s*[0-9a-f]{12}/.test(commitMsg);
+      console.log('Has checkpoint trailer:', hasCheckpointTrailer);
+
+      // Check for sessionlog branches (informational)
+      const checkpointBranches = listGitBranches(tmpDir, 'sessionlog/*');
+      console.log('Sessionlog branches:', checkpointBranches);
+
+      // Session state should exist with tracked files
+      const sessions = readSessionStates(tmpDir);
+      expect(sessions.length).toBeGreaterThan(0);
+
+      const session = sessions[0];
+      console.log(
+        'Session state:',
+        JSON.stringify(
+          {
+            phase: session.phase,
+            baseCommit: (session.baseCommit as string)?.slice(0, 8),
+            stepCount: session.stepCount,
+            filesTouched: session.filesTouched,
+          },
+          null,
+          2,
+        ),
+      );
+
+      // Session should track the file Claude touched
+      const filesTouched = session.filesTouched as string[];
+      expect(filesTouched.length).toBeGreaterThan(0);
+    }, 180_000);
+
+    it('should mark session as ended after -p mode completes', async () => {
+      runClaude(tmpDir, 'Create a file called END_TEST.md with content: # End Test', {
+        allowedTools: ['Write'],
+        timeoutMs: 120_000,
+      });
+
+      await new Promise((r) => setTimeout(r, HOOK_WAIT_MS));
+
+      const sessions = readSessionStates(tmpDir);
+      expect(sessions.length).toBeGreaterThan(0);
+
+      const session = sessions[0];
+      console.log('Session phase:', session.phase, 'endedAt:', session.endedAt);
+
+      // In -p mode, session_end hook fires, so phase should be 'ended'
+      // or at minimum endedAt should be set
+      const isEnded = session.phase === 'ended' || session.endedAt !== undefined;
+      expect(isEnded).toBe(true);
+    }, 180_000);
+  });
+
+  // ==========================================================================
+  // Suite 2: Commit & Explain
+  // ==========================================================================
+
+  describe('Commit & Explain', () => {
+    it('should show commit info via explain command after Claude commits', async () => {
+      runClaude(
+        tmpDir,
+        [
+          'Do these two steps exactly:',
+          '1. Create a file at lib/utils.ts with content: export const noop = () => {};',
+          '2. Then run: git add lib/utils.ts && git commit -m "feat: add noop utility"',
+        ].join('\n'),
+        {
+          allowedTools: ['Write', 'Bash'],
+          systemPrompt: 'Create the file and commit it. Do exactly as instructed.',
+          timeoutMs: 120_000,
+        },
+      );
+
+      await new Promise((r) => setTimeout(r, HOOK_WAIT_MS));
+
+      const commitCount = getCommitCount(tmpDir);
+      console.log('Commit count:', commitCount);
+
+      if (commitCount <= 1) {
+        console.warn('Claude did not commit — skipping explain test');
+        return;
+      }
+
+      // Run explain command — should always show commit info
+      const output = runSessionlog(tmpDir, ['explain', 'HEAD']);
+      console.log('Explain output:', output);
+
+      expect(output).toContain('Commit:');
+      expect(output).toContain('Message:');
+
+      // Checkpoint details are only present if shadow branch existed during commit.
+      // In single-turn -p mode this won't happen. Tested deterministically in Suite 7.
+      const hasCheckpoint = output.includes('Checkpoint:');
+      console.log('Has checkpoint in explain (expected false in single-turn):', hasCheckpoint);
+    }, 180_000);
+
+    it('should run rewind --list without errors after a session', async () => {
+      runClaude(tmpDir, 'Create a file called REWIND_TEST.md with content: # Rewind Test', {
+        allowedTools: ['Write'],
+        timeoutMs: 120_000,
+      });
+
+      await new Promise((r) => setTimeout(r, HOOK_WAIT_MS));
+
+      // rewind --list should return valid JSON even with no checkpoints
+      const output = runSessionlog(tmpDir, ['rewind', '--list']);
+      console.log('Rewind list output:', output.slice(0, 300));
+
+      const points = JSON.parse(output);
+      expect(Array.isArray(points)).toBe(true);
+      console.log('Rewind points:', points.length);
+    }, 180_000);
+  });
+
+  // ==========================================================================
+  // Suite 3: Status Command
+  // ==========================================================================
+
+  describe('Status Command', () => {
+    it('should report enabled state and sessions after Claude session', async () => {
+      runClaude(tmpDir, 'Create a file called HELLO.md with content: # Hello', {
+        allowedTools: ['Write'],
+        systemPrompt: 'Only create the file.',
+        timeoutMs: 120_000,
+      });
+
+      await new Promise((r) => setTimeout(r, HOOK_WAIT_MS));
+
+      const status = getStatus(tmpDir);
+      console.log('Status:', JSON.stringify(status, null, 2));
+
+      expect(status.enabled).toBe(true);
+      expect(status.strategy).toBe('manual-commit');
+      expect(status.gitHooksInstalled).toBe(true);
+      expect(status.agents).toBeDefined();
+      expect(status.agents as string[]).toContain('claude-code');
+
+      const sessions = status.sessions as Record<string, unknown>[];
+      expect(sessions.length).toBeGreaterThan(0);
+
+      const session = sessions[0];
+      expect(session.agentType).toBe('Claude Code');
+      expect(session.startedAt).toBeDefined();
+      expect(['idle', 'active', 'ended']).toContain(session.phase);
+    }, 180_000);
+
+    it('should report zero sessions before any Claude invocation', () => {
+      const status = getStatus(tmpDir);
+      console.log('Status (no sessions):', JSON.stringify(status, null, 2));
+
+      expect(status.enabled).toBe(true);
+      expect(status.strategy).toBe('manual-commit');
+      expect(status.gitHooksInstalled).toBe(true);
+
+      const sessions = status.sessions as Record<string, unknown>[];
+      expect(sessions).toHaveLength(0);
+    });
+  });
+
+  // ==========================================================================
+  // Suite 4: Doctor & Clean (no live Claude needed)
+  // ==========================================================================
+
+  describe('Doctor & Clean', () => {
+    it('should diagnose stuck sessions', () => {
+      // Create a synthetic stuck session
+      const sessionsDir = path.join(tmpDir, '.git', 'sessionlog-sessions');
+      fs.mkdirSync(sessionsDir, { recursive: true });
+
+      const head = getHead(tmpDir);
+      const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
+
+      const stuckState = {
+        sessionID: 'stuck-session-001',
+        baseCommit: head,
+        startedAt: twoHoursAgo,
+        lastInteractionTime: twoHoursAgo,
+        phase: 'active',
+        turnCheckpointIDs: [],
+        stepCount: 0,
+        checkpointTranscriptStart: 0,
+        untrackedFilesAtStart: [],
+        filesTouched: [],
+        agentType: 'Claude Code',
+      };
+
+      fs.writeFileSync(
+        path.join(sessionsDir, 'stuck-session-001.json'),
+        JSON.stringify(stuckState, null, 2),
+      );
+
+      const output = runSessionlog(tmpDir, ['doctor']);
+      console.log('Doctor output:', output);
+
+      expect(output).toContain('stuck');
+    });
+
+    it('should fix stuck sessions with --force', () => {
+      const sessionsDir = path.join(tmpDir, '.git', 'sessionlog-sessions');
+      fs.mkdirSync(sessionsDir, { recursive: true });
+
+      const head = getHead(tmpDir);
+      const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
+
+      const stuckState = {
+        sessionID: 'stuck-session-fix',
+        baseCommit: head,
+        startedAt: twoHoursAgo,
+        lastInteractionTime: twoHoursAgo,
+        phase: 'active',
+        turnCheckpointIDs: [],
+        stepCount: 0,
+        checkpointTranscriptStart: 0,
+        untrackedFilesAtStart: [],
+        filesTouched: [],
+        agentType: 'Claude Code',
+      };
+
+      fs.writeFileSync(
+        path.join(sessionsDir, 'stuck-session-fix.json'),
+        JSON.stringify(stuckState, null, 2),
+      );
+
+      const output = runSessionlog(tmpDir, ['doctor', '--force']);
+      console.log('Doctor --force output:', output);
+
+      expect(output).toContain('Discarded:');
+
+      // Session file should be deleted
+      const sessionFile = path.join(sessionsDir, 'stuck-session-fix.json');
+      expect(fs.existsSync(sessionFile)).toBe(false);
+    });
+
+    it('should report nothing to clean in a healthy repo', () => {
+      const output = runSessionlog(tmpDir, ['clean']);
+      console.log('Clean output:', output);
+
+      expect(output).toContain('Nothing to clean');
+    });
+
+    it('should detect orphaned shadow branches', () => {
+      // Create an orphaned shadow branch
+      execFileSync('git', ['branch', 'sessionlog/0000000'], { cwd: tmpDir, stdio: 'pipe' });
+
+      const branches = listGitBranches(tmpDir, 'sessionlog/*');
+      console.log('Branches before clean:', branches);
+      expect(branches).toContain('sessionlog/0000000');
+
+      const output = runSessionlog(tmpDir, ['clean']);
+      console.log('Clean output:', output);
+
+      // Should detect the orphaned branch
+      expect(output).toContain('sessionlog/0000000');
+    });
+  });
+
+  // ==========================================================================
+  // Suite 5: Token Usage
+  // ==========================================================================
+
+  describe('Token Usage', () => {
+    it('should populate token usage after a Claude session', async () => {
+      runClaude(tmpDir, 'What is 2 plus 2? Answer with just the number.', {
+        timeoutMs: 60_000,
+      });
+
+      await new Promise((r) => setTimeout(r, HOOK_WAIT_MS));
+
+      const sessions = readSessionStates(tmpDir);
+      console.log('Sessions found:', sessions.length);
+      expect(sessions.length).toBeGreaterThan(0);
+
+      const session = sessions[0];
+      console.log('Token usage:', JSON.stringify(session.tokenUsage, null, 2));
+
+      // Token usage depends on transcript parsing which may not fire in -p mode.
+      // Use soft assertions.
+      if (session.tokenUsage) {
+        const usage = session.tokenUsage as Record<string, number>;
+        expect.soft(usage.inputTokens, 'Expected inputTokens > 0').toBeGreaterThan(0);
+        expect.soft(usage.outputTokens, 'Expected outputTokens > 0').toBeGreaterThan(0);
+      } else {
+        console.warn('tokenUsage not populated — this is timing-dependent and may be expected');
+      }
+    }, 180_000);
+  });
+
+  // ==========================================================================
+  // Suite 6: Multiple Sessions
+  // ==========================================================================
+
+  describe('Multiple Sessions', () => {
+    it('should create separate session states for sequential invocations', async () => {
+      // First invocation: create a file
+      runClaude(tmpDir, 'Create a file called app/main.ts with content: console.log("hello");', {
+        allowedTools: ['Write'],
+        timeoutMs: 120_000,
+      });
+
+      await new Promise((r) => setTimeout(r, HOOK_WAIT_MS));
+
+      const sessionsAfterFirst = readSessionStates(tmpDir);
+      console.log('Sessions after first invocation:', sessionsAfterFirst.length);
+
+      // Second invocation: modify the file
+      runClaude(tmpDir, 'Read the file app/main.ts and add a second line: console.log("world");', {
+        allowedTools: ['Edit', 'Read', 'Write'],
+        timeoutMs: 120_000,
+      });
+
+      await new Promise((r) => setTimeout(r, HOOK_WAIT_MS));
+
+      const sessionsAfterSecond = readSessionStates(tmpDir);
+      console.log('Sessions after second invocation:', sessionsAfterSecond.length);
+
+      // Each -p invocation creates a new session, so we should have >= 2
+      expect(sessionsAfterSecond.length).toBeGreaterThanOrEqual(2);
+
+      // Verify sessions have different IDs
+      const sessionIDs = sessionsAfterSecond.map((s) => s.sessionID);
+      const uniqueIDs = new Set(sessionIDs);
+      expect(uniqueIDs.size).toBeGreaterThanOrEqual(2);
+
+      // Status should list all sessions
+      const status = getStatus(tmpDir);
+      const statusSessions = status.sessions as Record<string, unknown>[];
+      console.log('Status sessions count:', statusSessions.length);
+      expect(statusSessions.length).toBeGreaterThanOrEqual(2);
+    }, 300_000);
+  });
+
+  // ==========================================================================
+  // Suite 7: Checkpoint Lifecycle via CLI Binary (deterministic, no timing issues)
+  // ==========================================================================
+
+  describe('Checkpoint Lifecycle — CLI Binary', () => {
+    /**
+     * These tests pipe hook events directly to the sessionlog CLI binary,
+     * bypassing the need for a real Claude session. This allows deterministic
+     * testing of the checkpoint creation, rewind, and explain flows.
+     */
+
+    let sessionsDir: string;
+
+    beforeEach(() => {
+      sessionsDir = path.join(tmpDir, '.git', 'sessionlog-sessions');
+      fs.mkdirSync(sessionsDir, { recursive: true });
+
+      // Pre-create an active session state
+      const head = getHead(tmpDir);
+      const sessionState = {
+        sessionID: 'cli-e2e-session',
+        baseCommit: head,
+        startedAt: new Date().toISOString(),
+        phase: 'active',
+        turnCheckpointIDs: [],
+        stepCount: 0,
+        checkpointTranscriptStart: 0,
+        untrackedFilesAtStart: [],
+        filesTouched: [],
+        agentType: 'Claude Code',
+      };
+      fs.writeFileSync(
+        path.join(sessionsDir, 'cli-e2e-session.json'),
+        JSON.stringify(sessionState, null, 2),
+      );
+    });
+
+    it('should dispatch session_start through the CLI and create session state', () => {
+      const payload = JSON.stringify({
+        session_id: 'cli-e2e-session',
+        transcript_path: '/path/to/transcript.jsonl',
+      });
+
+      execSync(`echo ${JSON.stringify(payload)} | sessionlog hooks claude-code session-start`, {
+        cwd: tmpDir,
+        timeout: 10_000,
+        stdio: 'pipe',
+      });
+
+      const sessionFile = path.join(sessionsDir, 'cli-e2e-session.json');
+      const state = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+      expect(state.sessionID).toBe('cli-e2e-session');
+      expect(state.agentType).toBe('Claude Code');
+    });
+
+    it('should dispatch session_end and mark session as ended', () => {
+      const payload = JSON.stringify({
+        session_id: 'cli-e2e-session',
+        transcript_path: '/path/to/transcript.jsonl',
+      });
+
+      execSync(`echo ${JSON.stringify(payload)} | sessionlog hooks claude-code session-end`, {
+        cwd: tmpDir,
+        timeout: 10_000,
+        stdio: 'pipe',
+      });
+
+      const sessionFile = path.join(sessionsDir, 'cli-e2e-session.json');
+      const state = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+      expect(state.phase).toBe('ended');
+      expect(state.endedAt).toBeDefined();
+    });
+
+    it('should handle full hook lifecycle: start → prompt → tool use → stop → end', () => {
+      // 1. Session start
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+          }),
+        )} | sessionlog hooks claude-code session-start`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // 2. User prompt submit (turn start)
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+          }),
+        )} | sessionlog hooks claude-code user-prompt-submit`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // 3. Post tool use (Write tool)
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+            tool_use_id: 'toolu_01',
+            tool_name: 'Write',
+            tool_input: { file_path: '/tmp/test/src/app.ts', content: 'console.log("hi")' },
+          }),
+        )} | sessionlog hooks claude-code post-tool-Write`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // 4. Stop
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+          }),
+        )} | sessionlog hooks claude-code stop`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // 5. Session end
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+          }),
+        )} | sessionlog hooks claude-code session-end`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // Verify final state
+      const sessionFile = path.join(sessionsDir, 'cli-e2e-session.json');
+      const state = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+
+      expect(state.phase).toBe('ended');
+      expect(state.endedAt).toBeDefined();
+    });
+
+    it('should track tasks and plan mode through full CLI lifecycle', () => {
+      // 1. Enter plan mode
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+          }),
+        )} | sessionlog hooks claude-code post-plan-enter`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // 2. Exit plan mode with plan file
+      const planDir = path.join(tmpDir, '.claude', 'plans');
+      fs.mkdirSync(planDir, { recursive: true });
+      const planPath = path.join(planDir, 'e2e-plan.md');
+      fs.writeFileSync(planPath, '# E2E Plan\n\n1. Create files\n2. Run tests');
+
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+            tool_input: {},
+            tool_response: { planFilePath: planPath },
+          }),
+        )} | sessionlog hooks claude-code post-plan-exit`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // 3. Create task
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+            tool_use_id: 'toolu_01',
+            tool_input: {
+              subject: 'Set up project',
+              description: 'Initialize project structure and dependencies',
+            },
+            tool_response: { taskId: '1' },
+          }),
+        )} | sessionlog hooks claude-code post-task-create`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // 4. Create second task
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+            tool_use_id: 'toolu_02',
+            tool_input: {
+              subject: 'Write tests',
+              description: 'Add unit and integration tests',
+            },
+            tool_response: { taskId: '2' },
+          }),
+        )} | sessionlog hooks claude-code post-task-create`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // 5. Update first task to completed
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+            tool_use_id: 'toolu_03',
+            tool_input: { taskId: '1', status: 'completed' },
+          }),
+        )} | sessionlog hooks claude-code post-task-update`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // Verify final state
+      const sessionFile = path.join(sessionsDir, 'cli-e2e-session.json');
+      const state = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+
+      // Plan mode tracking
+      expect(state.inPlanMode).toBe(false);
+      expect(state.planModeEntries).toBe(1);
+      expect(state.planEntries).toHaveLength(1);
+      expect(state.planEntries[0].content).toBe('# E2E Plan\n\n1. Create files\n2. Run tests');
+      expect(state.planEntries[0].exitedAt).toBeDefined();
+
+      // Task tracking
+      expect(Object.keys(state.tasks)).toHaveLength(2);
+      expect(state.tasks['1'].subject).toBe('Set up project');
+      expect(state.tasks['1'].description).toBe('Initialize project structure and dependencies');
+      expect(state.tasks['1'].status).toBe('completed');
+      expect(state.tasks['2'].subject).toBe('Write tests');
+      expect(state.tasks['2'].description).toBe('Add unit and integration tests');
+      expect(state.tasks['2'].status).toBe('pending');
+    });
+
+    it('should verify status command reflects CLI-dispatched session state', () => {
+      // Dispatch some events
+      execSync(
+        `echo ${JSON.stringify(
+          JSON.stringify({
+            session_id: 'cli-e2e-session',
+            transcript_path: '/path/to/transcript.jsonl',
+          }),
+        )} | sessionlog hooks claude-code session-start`,
+        { cwd: tmpDir, timeout: 10_000, stdio: 'pipe' },
+      );
+
+      // Check status reflects the session
+      const status = getStatus(tmpDir);
+      const sessions = status.sessions as Record<string, unknown>[];
+
+      expect(sessions.length).toBeGreaterThanOrEqual(1);
+
+      const session = sessions.find((s) => s.sessionID === 'cli-e2e-session');
+      expect(session).toBeDefined();
+      expect(session!.agentType).toBe('Claude Code');
+    });
+  });
+});