cc-plan-viewer 0.1.0 → 0.2.1

package/dist/server/server/app.test.js

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import request from 'supertest';
+import { createApp } from './app.js';
+// Suppress lifecycle idle timer output
+vi.mock('./lifecycle.js', () => ({
+    resetIdleTimer: vi.fn(),
+}));
+describe('server app', () => {
+    let testDir;
+    let app;
+    let server;
+    let wss;
+    beforeEach(() => {
+        // Create a temp directory for plan files
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-plan-viewer-test-'));
+        const result = createApp([testDir]);
+        app = result.app;
+        server = result.server;
+        wss = result.wss;
+    });
+    afterEach(() => {
+        // Close server and clean up
+        server.close();
+        wss.close();
+        // Clean up temp directory
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    describe('GET /health', () => {
+        it('returns status ok with plan dirs', async () => {
+            const res = await request(app).get('/health');
+            expect(res.status).toBe(200);
+            expect(res.body.status).toBe('ok');
+            expect(res.body.plansDirs).toContain(testDir);
+        });
+    });
+    describe('GET /api/plans', () => {
+        it('returns empty array when no plans exist', async () => {
+            const res = await request(app).get('/api/plans');
+            expect(res.status).toBe(200);
+            expect(res.body).toEqual([]);
+        });
+        it('returns list of plan files', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan-a.md'), '# Plan A');
+            fs.writeFileSync(path.join(testDir, 'plan-b.md'), '# Plan B');
+            const res = await request(app).get('/api/plans');
+            expect(res.status).toBe(200);
+            expect(res.body).toHaveLength(2);
+            expect(res.body.map((p) => p.filename).sort()).toEqual(['plan-a.md', 'plan-b.md']);
+        });
+        it('sorts by modification time descending', async () => {
+            fs.writeFileSync(path.join(testDir, 'old.md'), '# Old');
+            // Touch the file with a future time to ensure ordering
+            const futureTime = new Date(Date.now() + 10000);
+            fs.writeFileSync(path.join(testDir, 'new.md'), '# New');
+            fs.utimesSync(path.join(testDir, 'new.md'), futureTime, futureTime);
+            const res = await request(app).get('/api/plans');
+            expect(res.body[0].filename).toBe('new.md');
+        });
+        it('excludes .review.json files', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan.md'), '# Plan');
+            fs.writeFileSync(path.join(testDir, 'plan.review.json'), '{}');
+            const res = await request(app).get('/api/plans');
+            expect(res.body).toHaveLength(1);
+            expect(res.body[0].filename).toBe('plan.md');
+        });
+    });
+    describe('GET /api/plans/:filename', () => {
+        it('returns parsed plan data', async () => {
+            fs.writeFileSync(path.join(testDir, 'test.md'), '# My Plan\n\nSome content');
+            const res = await request(app).get('/api/plans/test.md');
+            expect(res.status).toBe(200);
+            expect(res.body.filename).toBe('test.md');
+            expect(res.body.parsed.title).toBe('My Plan');
+            expect(res.body.parsed.rawMarkdown).toContain('Some content');
+        });
+        it('returns 404 for missing plan', async () => {
+            const res = await request(app).get('/api/plans/missing.md');
+            expect(res.status).toBe(404);
+        });
+        it('returns 400 for non-.md filename', async () => {
+            const res = await request(app).get('/api/plans/bad.txt');
+            expect(res.status).toBe(400);
+        });
+        it('returns 400 for path traversal', async () => {
+            const res = await request(app).get('/api/plans/..%2Fetc%2Fpasswd.md');
+            expect(res.status).toBe(400);
+        });
+    });
+    describe('POST /api/plan-updated', () => {
+        it('returns ok', async () => {
+            const res = await request(app)
+                .post('/api/plan-updated')
+                .send({ filePath: '/some/path/plan.md' });
+            expect(res.status).toBe(200);
+            expect(res.body.ok).toBe(true);
+        });
+    });
+    describe('POST /api/reviews/:filename', () => {
+        it('saves review and returns it', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan.md'), '# Plan');
+            const res = await request(app)
+                .post('/api/reviews/plan.md')
+                .send({
+                action: 'approve',
+                overallComment: 'LGTM',
+                inlineComments: [],
+            });
+            expect(res.status).toBe(200);
+            expect(res.body.ok).toBe(true);
+            expect(res.body.review.action).toBe('approve');
+            expect(res.body.review.overallComment).toBe('LGTM');
+            // Verify file was written
+            const reviewPath = path.join(testDir, 'plan.review.json');
+            expect(fs.existsSync(reviewPath)).toBe(true);
+        });
+        it('returns 404 for missing plan', async () => {
+            const res = await request(app)
+                .post('/api/reviews/missing.md')
+                .send({ action: 'approve' });
+            expect(res.status).toBe(404);
+        });
+        it('returns 400 for path traversal', async () => {
+            const res = await request(app)
+                .post('/api/reviews/..%2Fhack.md')
+                .send({ action: 'approve' });
+            expect(res.status).toBe(400);
+        });
+    });
+    describe('GET /api/reviews/:filename', () => {
+        it('returns saved review', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan.md'), '# Plan');
+            // First save a review
+            await request(app)
+                .post('/api/reviews/plan.md')
+                .send({ action: 'feedback', overallComment: 'Nice' });
+            const res = await request(app).get('/api/reviews/plan.md');
+            expect(res.status).toBe(200);
+            expect(res.body.action).toBe('feedback');
+            expect(res.body.overallComment).toBe('Nice');
+        });
+        it('returns 404 when no review exists', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan.md'), '# Plan');
+            const res = await request(app).get('/api/reviews/plan.md');
+            expect(res.status).toBe(404);
+        });
+        it('returns 404 for missing plan file', async () => {
+            const res = await request(app).get('/api/reviews/missing.md');
+            expect(res.status).toBe(404);
+        });
+    });
+});

package/dist/server/server/index.js

@@ -1,178 +1,36 @@
-import express from 'express';
-import { createServer } from 'node:http';
-import { WebSocketServer, WebSocket } from 'ws';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { parsePlan } from './planParser.js';
-import { saveReview, getReview } from './reviewStore.js';
+import { WebSocket } from 'ws';
+import { createApp } from './app.js';
 import { writePidFile, writePortFile, cleanupFiles, resetIdleTimer } from './lifecycle.js';
 import { watchPlansDir } from './planWatcher.js';
 const PORT = parseInt(process.env.PORT || '3847', 10);
-// Auto-detect plans directory
-function findPlansDir() {
+// Auto-detect all ~/.claude*/plans/ directories
+function findAllPlansDirs() {
     const home = os.homedir();
-    const candidates = [
-        path.join(home, '.claude-personal', 'plans'),
-        path.join(home, '.claude', 'plans'),
-    ];
-    for (const dir of candidates) {
-        if (fs.existsSync(dir))
-            return dir;
-    }
-    // Default to first candidate even if it doesn't exist yet
-    return candidates[0];
-}
-const plansDir = findPlansDir();
-const app = express();
-const server = createServer(app);
-const wss = new WebSocketServer({ server });
-app.use(express.json());
-// Reset idle timer on every request
-app.use((_req, _res, next) => {
-    resetIdleTimer();
-    next();
-});
-// Health check
-app.get('/health', (_req, res) => {
-    res.json({ status: 'ok', plansDir });
-});
-// List all plans
-app.get('/api/plans', (_req, res) => {
-    try {
-        if (!fs.existsSync(plansDir)) {
-            res.json([]);
-            return;
-        }
-        const files = fs.readdirSync(plansDir)
-            .filter(f => f.endsWith('.md') && !f.endsWith('.review.json'))
-            .map(f => {
-            const filePath = path.join(plansDir, f);
-            const stat = fs.statSync(filePath);
-            const review = getReview(filePath);
-            return {
-                filename: f,
-                modified: stat.mtime.toISOString(),
-                size: stat.size,
-                hasReview: !!review,
-                reviewAction: review?.action ?? null,
-            };
-        })
-            .sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
-        res.json(files);
-    }
-    catch (err) {
-        res.status(500).json({ error: 'Failed to list plans' });
-    }
-});
-// Get a specific plan
-app.get('/api/plans/:filename', (req, res) => {
-    const filename = req.params.filename;
-    if (!filename.endsWith('.md') || filename.includes('..')) {
-        res.status(400).json({ error: 'Invalid filename' });
-        return;
-    }
-    const filePath = path.join(plansDir, filename);
     try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const parsed = parsePlan(content);
-        const review = getReview(filePath);
-        res.json({ filename, parsed, review });
+        return fs.readdirSync(home)
+            .filter(name => name.startsWith('.claude'))
+            .map(name => path.join(home, name, 'plans'))
+            .filter(dir => fs.existsSync(dir));
     }
     catch {
-        res.status(404).json({ error: 'Plan not found' });
-    }
-});
-// Hook notifies of plan update
-app.post('/api/plan-updated', (req, res) => {
-    const { filePath, planOptions } = req.body;
-    const filename = path.basename(filePath || '');
-    // Broadcast to all WebSocket clients
-    const message = JSON.stringify({
-        type: 'plan-updated',
-        filename,
-        planOptions: planOptions || null,
-    });
-    for (const client of wss.clients) {
-        if (client.readyState === WebSocket.OPEN) {
-            client.send(message);
-        }
-    }
-    res.json({ ok: true });
-});
-// Save a review
-app.post('/api/reviews/:filename', (req, res) => {
-    const filename = req.params.filename;
-    if (!filename.endsWith('.md') || filename.includes('..')) {
-        res.status(400).json({ error: 'Invalid filename' });
-        return;
-    }
-    const filePath = path.join(plansDir, filename);
-    if (!fs.existsSync(filePath)) {
-        res.status(404).json({ error: 'Plan not found' });
-        return;
-    }
-    const review = {
-        planFile: filename,
-        action: req.body.action || 'feedback',
-        submittedAt: new Date().toISOString(),
-        consumedAt: null,
-        overallComment: req.body.overallComment || '',
-        inlineComments: req.body.inlineComments || [],
-    };
-    saveReview(filePath, review);
-    // Notify clients
-    const message = JSON.stringify({
-        type: 'review-submitted',
-        filename,
-        action: review.action,
-    });
-    for (const client of wss.clients) {
-        if (client.readyState === WebSocket.OPEN) {
-            client.send(message);
-        }
+        return [path.join(home, '.claude', 'plans')];
     }
-    res.json({ ok: true, review });
-});
-// Get a review
-app.get('/api/reviews/:filename', (req, res) => {
-    const filename = req.params.filename;
-    const filePath = path.join(plansDir, filename);
-    const review = getReview(filePath);
-    if (!review) {
-        res.status(404).json({ error: 'No review found' });
-        return;
-    }
-    res.json(review);
-});
-// Serve SPA static files
-// Try multiple paths: dist/client relative to project root, or relative to compiled output
-const clientDistCandidates = [
-    path.join(import.meta.dirname, '..', '..', 'client'), // prod: dist/server/server/ → dist/client/
-    path.join(import.meta.dirname, '..', 'dist', 'client'), // dev: server/ → dist/client/
-];
-const clientDist = clientDistCandidates.find((d) => fs.existsSync(d));
-if (clientDist) {
-    app.use(express.static(clientDist));
-    app.get('/{*path}', (_req, res) => {
-        res.sendFile(path.join(clientDist, 'index.html'));
-    });
 }
-// WebSocket connection
-wss.on('connection', (ws) => {
-    resetIdleTimer();
-    ws.on('message', () => resetIdleTimer());
-});
+const plansDirs = findAllPlansDirs();
+const { server, wss } = createApp(plansDirs);
 // Start
 server.listen(PORT, () => {
     writePidFile();
     writePortFile(PORT);
     resetIdleTimer();
     console.log(`[cc-plan-viewer] Server running at http://localhost:${PORT}`);
-    console.log(`[cc-plan-viewer] Plans directory: ${plansDir}`);
+    console.log(`[cc-plan-viewer] Plans directories: ${plansDirs.join(', ')}`);
 });
-// Watch for plan file changes
-watchPlansDir(plansDir, (filename, content) => {
+// Watch all plan directories for changes
+const onPlanChange = (filename, _content) => {
     const message = JSON.stringify({
         type: 'plan-updated',
         filename,
@@ -182,7 +40,10 @@ watchPlansDir(plansDir, (filename, content) => {
             client.send(message);
         }
     }
-});
+};
+for (const dir of plansDirs) {
+    watchPlansDir(dir, onPlanChange);
+}
 // Cleanup on exit
 process.on('SIGINT', () => { cleanupFiles(); process.exit(0); });
 process.on('SIGTERM', () => { cleanupFiles(); process.exit(0); });

package/dist/server/server/lifecycle.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const mockFs = vi.hoisted(() => ({
+    writeFileSync: vi.fn(),
+    readFileSync: vi.fn(),
+    unlinkSync: vi.fn(),
+}));
+vi.mock('node:fs', () => ({ default: mockFs, ...mockFs }));
+vi.mock('node:os', () => ({
+    default: { tmpdir: () => '/tmp' },
+    tmpdir: () => '/tmp',
+}));
+const { writePidFile, writePortFile, cleanupFiles, readPortFile, isServerRunning, resetIdleTimer } = await import('./lifecycle.js');
+describe('lifecycle', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('writePidFile', () => {
+        it('writes process PID to correct path', () => {
+            writePidFile();
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith('/tmp/cc-plan-viewer.pid', String(process.pid), 'utf8');
+        });
+    });
+    describe('writePortFile', () => {
+        it('writes port number to correct path', () => {
+            writePortFile(3847);
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith('/tmp/cc-plan-viewer-port', '3847', 'utf8');
+        });
+    });
+    describe('cleanupFiles', () => {
+        it('unlinks both PID and port files', () => {
+            cleanupFiles();
+            expect(mockFs.unlinkSync).toHaveBeenCalledWith('/tmp/cc-plan-viewer.pid');
+            expect(mockFs.unlinkSync).toHaveBeenCalledWith('/tmp/cc-plan-viewer-port');
+        });
+        it('swallows errors when files do not exist', () => {
+            mockFs.unlinkSync.mockImplementation(() => {
+                throw new Error('ENOENT');
+            });
+            expect(() => cleanupFiles()).not.toThrow();
+        });
+    });
+    describe('readPortFile', () => {
+        it('returns port number from file', () => {
+            mockFs.readFileSync.mockReturnValue('3847');
+            expect(readPortFile()).toBe(3847);
+        });
+        it('returns null when file does not exist', () => {
+            mockFs.readFileSync.mockImplementation(() => {
+                throw new Error('ENOENT');
+            });
+            expect(readPortFile()).toBeNull();
+        });
+        it('returns null when file contains non-numeric content', () => {
+            mockFs.readFileSync.mockReturnValue('not-a-number');
+            expect(readPortFile()).toBeNull();
+        });
+        it('handles port with whitespace', () => {
+            mockFs.readFileSync.mockReturnValue('  3847\n');
+            expect(readPortFile()).toBe(3847);
+        });
+    });
+    describe('isServerRunning', () => {
+        it('returns true when PID file exists and process is alive', () => {
+            mockFs.readFileSync.mockReturnValue('12345');
+            const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true);
+            expect(isServerRunning()).toBe(true);
+            expect(killSpy).toHaveBeenCalledWith(12345, 0);
+            killSpy.mockRestore();
+        });
+        it('returns false when PID file does not exist', () => {
+            mockFs.readFileSync.mockImplementation(() => {
+                throw new Error('ENOENT');
+            });
+            expect(isServerRunning()).toBe(false);
+        });
+        it('returns false when process is not alive', () => {
+            mockFs.readFileSync.mockReturnValue('12345');
+            const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => {
+                throw new Error('ESRCH');
+            });
+            expect(isServerRunning()).toBe(false);
+            killSpy.mockRestore();
+        });
+        it('returns false when PID is NaN', () => {
+            mockFs.readFileSync.mockReturnValue('garbage');
+            expect(isServerRunning()).toBe(false);
+        });
+    });
+    describe('resetIdleTimer', () => {
+        it('sets a timer', () => {
+            const spy = vi.spyOn(global, 'setTimeout');
+            resetIdleTimer();
+            expect(spy).toHaveBeenCalled();
+            spy.mockRestore();
+        });
+    });
+});

package/dist/server/server/planParser.test.js

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import { parsePlan } from './planParser.js';
+describe('parsePlan', () => {
+    it('returns untitled plan for empty string', () => {
+        const result = parsePlan('');
+        expect(result.title).toBe('Untitled Plan');
+        expect(result.sections).toEqual([]);
+        expect(result.rawMarkdown).toBe('');
+    });
+    it('extracts title from first h1', () => {
+        const result = parsePlan('# My Plan\n\nSome content');
+        expect(result.title).toBe('My Plan');
+    });
+    it('uses Untitled Plan when no h1 exists', () => {
+        const result = parsePlan('## Section A\n\nContent');
+        expect(result.title).toBe('Untitled Plan');
+    });
+    it('only uses the first h1 as title', () => {
+        const result = parsePlan('# First Title\n\n# Second Title');
+        expect(result.title).toBe('First Title');
+    });
+    it('creates a single root section for one heading', () => {
+        const result = parsePlan('# Title\n\nContent here');
+        expect(result.sections).toHaveLength(1);
+        expect(result.sections[0].heading).toBe('Title');
+        expect(result.sections[0].level).toBe(1);
+    });
+    it('creates flat siblings for multiple h2 headings', () => {
+        const md = '## Section A\n\nContent A\n\n## Section B\n\nContent B';
+        const result = parsePlan(md);
+        expect(result.sections).toHaveLength(2);
+        expect(result.sections[0].heading).toBe('Section A');
+        expect(result.sections[1].heading).toBe('Section B');
+    });
+    it('nests h3 under preceding h2', () => {
+        const md = '## Parent\n\n### Child\n\nContent';
+        const result = parsePlan(md);
+        expect(result.sections).toHaveLength(1);
+        expect(result.sections[0].heading).toBe('Parent');
+        expect(result.sections[0].children).toHaveLength(1);
+        expect(result.sections[0].children[0].heading).toBe('Child');
+    });
+    it('builds correct h2/h3/h4 hierarchy', () => {
+        const md = '## A\n### B\n#### C\n### D\n## E';
+        const result = parsePlan(md);
+        expect(result.sections).toHaveLength(2); // A and E
+        expect(result.sections[0].children).toHaveLength(2); // B and D
+        expect(result.sections[0].children[0].children).toHaveLength(1); // C
+    });
+    it('calculates correct startLine for sections', () => {
+        const md = '# Title\n\nParagraph\n\n## Section';
+        const result = parsePlan(md);
+        expect(result.sections[0].startLine).toBe(0); // # Title is line 0
+        expect(result.sections[0].children[0].startLine).toBe(4); // ## Section is line 4
+    });
+    it('calculates correct endLine for sections', () => {
+        const md = '## A\nContent A\n## B\nContent B';
+        const result = parsePlan(md);
+        // A ends at line 2 (start of B)
+        expect(result.sections[0].endLine).toBe(2);
+        // B ends at the total number of lines
+        expect(result.sections[1].endLine).toBe(4);
+    });
+    it('extracts rawContent for each section', () => {
+        const md = '## Section\nLine 1\nLine 2';
+        const result = parsePlan(md);
+        expect(result.sections[0].rawContent).toBe('## Section\nLine 1\nLine 2');
+    });
+    it('generates slugified section IDs', () => {
+        const md = '## Hello World!';
+        const result = parsePlan(md);
+        expect(result.sections[0].id).toBe('hello-world');
+    });
+    it('generates fallback ID for empty heading text after slugify', () => {
+        // Heading with only special chars that slugify removes
+        const md = '## !!!';
+        const result = parsePlan(md);
+        expect(result.sections[0].id).toBe('section-0');
+    });
+    it('preserves rawMarkdown in output', () => {
+        const md = '# Title\n\nSome content';
+        const result = parsePlan(md);
+        expect(result.rawMarkdown).toBe(md);
+    });
+    it('handles headings with trailing spaces', () => {
+        const md = '## Trimmed   ';
+        const result = parsePlan(md);
+        expect(result.sections[0].heading).toBe('Trimmed');
+    });
+    it('handles deeply nested sections (h2 through h6)', () => {
+        const md = '## L2\n### L3\n#### L4\n##### L5\n###### L6';
+        const result = parsePlan(md);
+        expect(result.sections).toHaveLength(1);
+        expect(result.sections[0].children[0].children[0].children[0].children[0].heading).toBe('L6');
+    });
+    it('sibling at same level after nested children pops back correctly', () => {
+        const md = '## A\n### A1\n### A2\n## B';
+        const result = parsePlan(md);
+        expect(result.sections).toHaveLength(2);
+        expect(result.sections[0].children).toHaveLength(2);
+        expect(result.sections[1].heading).toBe('B');
+        expect(result.sections[1].children).toHaveLength(0);
+    });
+});

package/dist/server/server/planWatcher.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const mockFs = vi.hoisted(() => ({
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+    watch: vi.fn(),
+}));
+vi.mock('node:fs', () => ({ default: mockFs, ...mockFs }));
+const { watchPlansDir } = await import('./planWatcher.js');
+describe('watchPlansDir', () => {
+    let watchCallback;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.useFakeTimers();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.watch.mockImplementation((_path, callback) => {
+            watchCallback = callback;
+            return { close: vi.fn() };
+        });
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('warns and returns early if directory does not exist', () => {
+        mockFs.existsSync.mockReturnValue(false);
+        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const onUpdate = vi.fn();
+        watchPlansDir('/nonexistent', onUpdate);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('not found'));
+        expect(mockFs.watch).not.toHaveBeenCalled();
+        consoleSpy.mockRestore();
+    });
+    it('calls fs.watch on the provided directory', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        watchPlansDir('/plans', vi.fn());
+        expect(mockFs.watch).toHaveBeenCalledWith('/plans', expect.any(Function));
+    });
+    it('ignores non-.md files', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const onUpdate = vi.fn();
+        watchPlansDir('/plans', onUpdate);
+        watchCallback('change', 'file.txt');
+        vi.advanceTimersByTime(500);
+        expect(onUpdate).not.toHaveBeenCalled();
+    });
+    it('ignores null filename', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const onUpdate = vi.fn();
+        watchPlansDir('/plans', onUpdate);
+        watchCallback('change', null);
+        vi.advanceTimersByTime(500);
+        expect(onUpdate).not.toHaveBeenCalled();
+    });
+    it('calls onUpdate with filename and content after debounce', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const onUpdate = vi.fn();
+        mockFs.readFileSync.mockReturnValue('# Plan content');
+        watchPlansDir('/plans', onUpdate);
+        watchCallback('change', 'test.md');
+        vi.advanceTimersByTime(100);
+        expect(onUpdate).not.toHaveBeenCalled();
+        vi.advanceTimersByTime(200);
+        expect(onUpdate).toHaveBeenCalledWith('test.md', '# Plan content');
+    });
+    it('debounces rapid events for the same file', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const onUpdate = vi.fn();
+        mockFs.readFileSync.mockReturnValue('content');
+        watchPlansDir('/plans', onUpdate);
+        watchCallback('change', 'test.md');
+        vi.advanceTimersByTime(100);
+        watchCallback('change', 'test.md');
+        vi.advanceTimersByTime(100);
+        watchCallback('change', 'test.md');
+        vi.advanceTimersByTime(300);
+        expect(onUpdate).toHaveBeenCalledTimes(1);
+    });
+    it('handles file deleted between event and read', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const onUpdate = vi.fn();
+        mockFs.readFileSync.mockImplementation(() => {
+            throw new Error('ENOENT');
+        });
+        watchPlansDir('/plans', onUpdate);
+        watchCallback('change', 'deleted.md');
+        vi.advanceTimersByTime(300);
+        expect(onUpdate).not.toHaveBeenCalled();
+    });
+    it('handles different files independently', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const onUpdate = vi.fn();
+        mockFs.readFileSync.mockReturnValue('content');
+        watchPlansDir('/plans', onUpdate);
+        watchCallback('change', 'a.md');
+        watchCallback('change', 'b.md');
+        vi.advanceTimersByTime(300);
+        expect(onUpdate).toHaveBeenCalledTimes(2);
+        expect(onUpdate).toHaveBeenCalledWith('a.md', 'content');
+        expect(onUpdate).toHaveBeenCalledWith('b.md', 'content');
+    });
+});