@contextgit/store 0.1.10 → 0.2.0

package/dist/local/local-store.test.js

@@ -1,5 +1,10 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { LocalStore } from './index.js';
+import { SnapshotFormatter } from '@contextgit/core';
+/** Advance the mocked clock by 1 minute. Use between commits in decay tests so each gets a distinct created_at. */
+function tick() {
+    vi.setSystemTime(new Date(Date.now() + 60_000));
+}
 describe('LocalStore (in-memory)', () => {
     let store;
     beforeEach(() => {
@@ -182,7 +187,8 @@ describe('LocalStore (in-memory)', () => {
         const project = await store.createProject({ name: 'fmt-test' });
         const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
         const text = await store.getFormattedSnapshot(project.id, branch.id, 'text');
-        expect(text).toContain('=== PROJECT STATE ===');
+        // Note: === PROJECT STATE === was removed in 02 DELTA gate 1 (commit b11e6e4).
+        // The text format now emits live ## Git facts + branch + threads + claims, no stored prose.
         expect(text).toContain('=== CURRENT BRANCH: main ===');
         expect(text).toContain('=== OPEN THREADS ===');
     });
@@ -211,6 +217,85 @@ describe('LocalStore (in-memory)', () => {
         expect(mainThreads).toHaveLength(1);
         expect(mainThreads[0].description).toBe('Thread from feat');
     });
+    it('getSessionSnapshot respects commitWindow option (default 5, custom honored)', async () => {
+        vi.useFakeTimers({ now: new Date('2026-01-01T00:00:00Z') });
+        try {
+            const project = await store.createProject({ name: 'p' });
+            const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+            await store.upsertAgent({
+                id: 'agent-1',
+                projectId: project.id,
+                role: 'dev',
+                tool: 'claude-code',
+                workflowType: 'interactive',
+            });
+            for (let i = 0; i < 10; i++) {
+                tick();
+                await store.createCommit({
+                    branchId: branch.id,
+                    agentId: 'agent-1',
+                    agentRole: 'dev',
+                    tool: 'claude-code',
+                    workflowType: 'interactive',
+                    message: `commit ${i}`,
+                    content: 'c',
+                    summary: 's',
+                    commitType: 'manual',
+                });
+            }
+            const defaultSnap = await store.getSessionSnapshot(project.id, branch.id);
+            expect(defaultSnap.recentCommits).toHaveLength(5);
+            const windowed = await store.getSessionSnapshot(project.id, branch.id, { commitWindow: 8 });
+            expect(windowed.recentCommits).toHaveLength(8);
+            const tiny = await store.getSessionSnapshot(project.id, branch.id, { commitWindow: 2 });
+            expect(tiny.recentCommits).toHaveLength(2);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('appends and lists trace entries in reverse-chronological order with paging', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        const first = await store.appendTraceEntry({
+            projectId: project.id,
+            branchId: branch.id,
+            note: 'tried X, abandoned because Y',
+        });
+        const second = await store.appendTraceEntry({
+            projectId: project.id,
+            branchId: branch.id,
+            note: 'considered Z, picked W',
+            gitCommitSha: 'abc1234',
+        });
+        expect(first.id).toBeTruthy();
+        expect(first.id).not.toBe(second.id);
+        const page = await store.listTraceEntries(project.id, { limit: 10, offset: 0 });
+        expect(page).toHaveLength(2);
+        // Most-recent-first
+        expect(page[0].note).toBe('considered Z, picked W');
+        expect(page[0].gitCommitSha).toBe('abc1234');
+        expect(page[1].note).toBe('tried X, abandoned because Y');
+        const offset1 = await store.listTraceEntries(project.id, { limit: 10, offset: 1 });
+        expect(offset1).toHaveLength(1);
+        expect(offset1[0].note).toBe('tried X, abandoned because Y');
+        const empty = await store.listTraceEntries(project.id, { limit: 10, offset: 5 });
+        expect(empty).toHaveLength(0);
+    });
+    it('does not include trace entries in getSessionSnapshot', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.appendTraceEntry({
+            projectId: project.id,
+            branchId: branch.id,
+            note: 'this must NEVER auto-load',
+        });
+        const snapshot = await store.getSessionSnapshot(project.id, branch.id);
+        const formatter = new SnapshotFormatter();
+        const out = formatter.format(snapshot, 'agents-md');
+        expect(out).not.toContain('this must NEVER auto-load');
+        expect(out).not.toContain('trace');
+    });
     it('uses explicit dbPath when provided, ignoring projectId for path computation', async () => {
         // Passing ':memory:' as dbPath bypasses projectId-based path computation entirely.
         // If projectId were used, it would try to open ~/.contextgit/projects/ignored-id.db.
@@ -218,5 +303,560 @@ describe('LocalStore (in-memory)', () => {
         await expect(store2.createProject({ id: 'p1', name: 'Test' })).resolves.toMatchObject({ id: 'p1' });
         store2.close();
     });
+    it('dedupes thread opens on normalized subject and updates lastTouchedCommit', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.upsertAgent({
+            id: 'agent-1',
+            projectId: project.id,
+            role: 'dev',
+            tool: 'claude-code',
+            workflowType: 'interactive',
+        });
+        const first = await store.createCommit({
+            branchId: branch.id,
+            agentId: 'agent-1',
+            agentRole: 'dev',
+            tool: 'claude-code',
+            workflowType: 'interactive',
+            message: 'open thread',
+            content: 'c',
+            summary: 's',
+            commitType: 'manual',
+            threads: { open: ['Write Plan B Extension'] },
+        });
+        const afterFirst = await store.listOpenThreads(project.id);
+        expect(afterFirst).toHaveLength(1);
+        expect(afterFirst[0].description).toBe('Write Plan B Extension');
+        expect(afterFirst[0].lastTouchedCommit).toBe(first.id);
+        const second = await store.createCommit({
+            branchId: branch.id,
+            agentId: 'agent-1',
+            agentRole: 'dev',
+            tool: 'claude-code',
+            workflowType: 'interactive',
+            message: 'duplicate subject, varied casing + spacing',
+            content: 'c',
+            summary: 's',
+            commitType: 'manual',
+            threads: { open: ['  write  PLAN b   extension  '] },
+        });
+        const afterSecond = await store.listOpenThreads(project.id);
+        expect(afterSecond).toHaveLength(1);
+        expect(afterSecond[0].id).toBe(afterFirst[0].id);
+        expect(afterSecond[0].description).toBe('Write Plan B Extension');
+        expect(afterSecond[0].lastTouchedCommit).toBe(second.id);
+    });
+    it('opens a thread as kind="watch" when input is {subject, kind: "watch"}', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.upsertAgent({
+            id: 'agent-1',
+            projectId: project.id,
+            role: 'dev',
+            tool: 'claude-code',
+            workflowType: 'interactive',
+        });
+        await store.createCommit({
+            branchId: branch.id,
+            agentId: 'agent-1',
+            agentRole: 'dev',
+            tool: 'claude-code',
+            workflowType: 'interactive',
+            message: 'open one open and one watch',
+            content: 'c',
+            summary: 's',
+            commitType: 'manual',
+            threads: {
+                open: [
+                    'committed thread',
+                    { subject: 'speculative reminder', kind: 'watch' },
+                ],
+            },
+        });
+        const threads = await store.listOpenThreads(project.id);
+        expect(threads).toHaveLength(2);
+        const byDesc = Object.fromEntries(threads.map((t) => [t.description, t]));
+        expect(byDesc['committed thread'].kind).toBe('open');
+        expect(byDesc['speculative reminder'].kind).toBe('watch');
+    });
+    it('flags an open thread as stale only when BOTH age AND distance signals fire (03 DELTA recalibration)', async () => {
+        vi.useFakeTimers({ now: new Date('2026-01-01T00:00:00Z') });
+        try {
+            const project = await store.createProject({ name: 'p' });
+            const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+            await store.upsertAgent({
+                id: 'agent-1',
+                projectId: project.id,
+                role: 'dev',
+                tool: 'claude-code',
+                workflowType: 'interactive',
+            });
+            // Open the thread at T0.
+            await store.createCommit({
+                branchId: branch.id,
+                agentId: 'agent-1',
+                agentRole: 'dev',
+                tool: 'claude-code',
+                workflowType: 'interactive',
+                message: 'open',
+                content: 'c',
+                summary: 's',
+                commitType: 'manual',
+                threads: { open: ['the stale-soon thread'] },
+            });
+            const before = await store.listOpenThreads(project.id);
+            expect(before).toHaveLength(1);
+            expect(before[0].stale).toBeUndefined();
+            // Distance signal alone: 31 noise commits, all within ~31 minutes. AND-rule
+            // says the thread must STAY LIVE — recency has not aged out yet.
+            for (let i = 0; i < 31; i++) {
+                tick();
+                await store.createCommit({
+                    branchId: branch.id,
+                    agentId: 'agent-1',
+                    agentRole: 'dev',
+                    tool: 'claude-code',
+                    workflowType: 'interactive',
+                    message: `noise ${i}`,
+                    content: 'c',
+                    summary: 's',
+                    commitType: 'manual',
+                });
+            }
+            const stillLive = await store.listOpenThreads(project.id);
+            expect(stillLive).toHaveLength(1);
+            expect(stillLive[0].description).toBe('the stale-soon thread');
+            // Now jump the clock past the 14-day age threshold and trigger one more
+            // commit. Sweep-on-save now sees BOTH age (>14d since touch) AND distance
+            // (≥30 commits since touch) → thread is archived.
+            vi.setSystemTime(new Date(Date.now() + 15 * 24 * 60 * 60 * 1000));
+            await store.createCommit({
+                branchId: branch.id,
+                agentId: 'agent-1',
+                agentRole: 'dev',
+                tool: 'claude-code',
+                workflowType: 'interactive',
+                message: 'final noise',
+                content: 'c',
+                summary: 's',
+                commitType: 'manual',
+            });
+            const after = await store.listOpenThreads(project.id);
+            expect(after).toHaveLength(0);
+            const archived = await store.listArchivedThreads(project.id);
+            expect(archived).toHaveLength(1);
+            expect(archived[0].archivedReason).toMatch(/stale/);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('flags a watch thread as expired once branch commits past its touch hit the watch threshold', async () => {
+        vi.useFakeTimers({ now: new Date('2026-01-01T00:00:00Z') });
+        try {
+            const project = await store.createProject({ name: 'p' });
+            const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+            await store.upsertAgent({
+                id: 'agent-1',
+                projectId: project.id,
+                role: 'dev',
+                tool: 'claude-code',
+                workflowType: 'interactive',
+            });
+            await store.createCommit({
+                branchId: branch.id,
+                agentId: 'agent-1',
+                agentRole: 'dev',
+                tool: 'claude-code',
+                workflowType: 'interactive',
+                message: 'open watch',
+                content: 'c',
+                summary: 's',
+                commitType: 'manual',
+                threads: { open: [{ subject: 'watch this', kind: 'watch' }] },
+            });
+            for (let i = 0; i < 16; i++) {
+                tick();
+                await store.createCommit({
+                    branchId: branch.id,
+                    agentId: 'agent-1',
+                    agentRole: 'dev',
+                    tool: 'claude-code',
+                    workflowType: 'interactive',
+                    message: `noise ${i}`,
+                    content: 'c',
+                    summary: 's',
+                    commitType: 'manual',
+                });
+            }
+            // 03 DELTA: sweep runs on every createCommit. After 15+ noise commits, the
+            // watch thread is watch-expired and gets archived — no longer in listOpenThreads.
+            const after = await store.listOpenThreads(project.id);
+            expect(after).toHaveLength(0);
+            const archived = await store.listArchivedThreads(project.id);
+            expect(archived).toHaveLength(1);
+            expect(archived[0].archivedReason).toBe('watch-expired');
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('curates getSessionSnapshot: filters stale + expired threads and sets counts', async () => {
+        vi.useFakeTimers({ now: new Date('2026-01-01T00:00:00Z') });
+        try {
+            const project = await store.createProject({ name: 'p' });
+            const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+            await store.upsertAgent({
+                id: 'agent-1',
+                projectId: project.id,
+                role: 'dev',
+                tool: 'claude-code',
+                workflowType: 'interactive',
+            });
+            // Open one open thread that will go stale, one watch that will expire, and one live open
+            await store.createCommit({
+                branchId: branch.id,
+                agentId: 'agent-1',
+                agentRole: 'dev',
+                tool: 'claude-code',
+                workflowType: 'interactive',
+                message: 'open three',
+                content: 'c',
+                summary: 's',
+                commitType: 'manual',
+                threads: {
+                    open: [
+                        'will go stale',
+                        { subject: 'will expire', kind: 'watch' },
+                        'will stay live',
+                    ],
+                },
+            });
+            // Push enough noise to drive up branch-distance, then jump the clock past
+            // the 14-day age threshold so AND-rule's age + distance signals BOTH fire
+            // on the stale-target threads. (Distance alone no longer ages anything out
+            // — 03 DELTA decay recalibration.)
+            for (let i = 0; i < 31; i++) {
+                tick();
+                await store.createCommit({
+                    branchId: branch.id,
+                    agentId: 'agent-1',
+                    agentRole: 'dev',
+                    tool: 'claude-code',
+                    workflowType: 'interactive',
+                    message: `noise ${i}`,
+                    content: 'c',
+                    summary: 's',
+                    commitType: 'manual',
+                });
+            }
+            // Advance past the age threshold so the AND-rule fires on the targeted threads.
+            vi.setSystemTime(new Date(Date.now() + 15 * 24 * 60 * 60 * 1000));
+            // Touch the live one on the most recent commit so it doesn't go stale
+            tick();
+            await store.createCommit({
+                branchId: branch.id,
+                agentId: 'agent-1',
+                agentRole: 'dev',
+                tool: 'claude-code',
+                workflowType: 'interactive',
+                message: 'touch the live thread',
+                content: 'c',
+                summary: 's',
+                commitType: 'manual',
+                threads: { open: ['will stay live'] },
+            });
+            const snapshot = await store.getSessionSnapshot(project.id, branch.id);
+            // 03 DELTA: sweep runs on every createCommit. Stale + expired threads are
+            // archived before the snapshot is taken, so counts are 0 and only the live
+            // thread remains in openThreads.
+            expect(snapshot.staleThreadCount).toBe(0);
+            expect(snapshot.expiredWatchCount).toBe(0);
+            expect(snapshot.openThreads).toHaveLength(1);
+            expect(snapshot.openThreads[0].description).toBe('will stay live');
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('archiveThread + restoreThread round-trip via LocalStore', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        const commit = await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'm', content: 'c', summary: 's',
+            commitType: 'manual',
+            threads: { open: ['subj-arch'] },
+        });
+        const open = await store.listOpenThreads(project.id);
+        const thread = open[0];
+        const archived = await store.archiveThread(thread.id, 'manual', commit.id);
+        expect(archived.archivedReason).toBe('manual');
+        const list = await store.listArchivedThreads(project.id);
+        expect(list.map((t) => t.id)).toContain(thread.id);
+        await store.restoreThread(thread.id);
+        const reopened = await store.listOpenThreads(project.id);
+        expect(reopened.map((t) => t.id)).toContain(thread.id);
+    });
+    it('createCommit closesThreads — handle match archives the thread', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'open', content: 'x', summary: 'x',
+            commitType: 'manual',
+            threads: { open: ['close-me'] },
+        });
+        const open = await store.listOpenThreads(project.id);
+        const handle = open[0].id.slice(0, 6);
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'close', content: 'y', summary: 'y',
+            commitType: 'manual',
+            threads: { closes: [handle] },
+        });
+        const stillOpen = await store.listOpenThreads(project.id);
+        expect(stillOpen.length).toBe(0);
+        const archived = await store.listArchivedThreads(project.id);
+        expect(archived.length).toBe(1);
+        expect(archived[0].archivedReason).toBe('manual');
+    });
+    it('createCommit closesThreads — subject match archives the thread', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'o', content: 'x', summary: 'x',
+            commitType: 'manual',
+            threads: { open: ['need to do the thing'] },
+        });
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'c', content: 'y', summary: 'y',
+            commitType: 'manual',
+            threads: { closes: ['Need to do the thing'] },
+        });
+        const archived = await store.listArchivedThreads(project.id);
+        expect(archived.length).toBe(1);
+    });
+    it('createCommit closesThreads — already-archived handle is a no-op success', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        const c1 = await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'o', content: 'x', summary: 'x',
+            commitType: 'manual',
+            threads: { open: ['will-archive-twice'] },
+        });
+        const open = await store.listOpenThreads(project.id);
+        const handle = open[0].id.slice(0, 6);
+        await store.archiveThread(open[0].id, 'manual', c1.id);
+        // Save uses the same handle; thread is already archived; save must NOT throw.
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'c', content: 'y', summary: 'y',
+            commitType: 'manual',
+            threads: { closes: [handle] },
+        });
+        // No second archive insert — list count remains 1.
+        const archived = await store.listArchivedThreads(project.id);
+        expect(archived.length).toBe(1);
+    });
+    it('createCommit closesThreads — no match aborts the entire save atomically', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        const before = (await store.listCommits(branch.id, { limit: 100, offset: 0 })).length;
+        await expect(store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'c', content: 'y', summary: 'y',
+            commitType: 'manual',
+            threads: { closes: ['xxxxxx'] },
+        })).rejects.toThrow(/closesThreads/);
+        const after = (await store.listCommits(branch.id, { limit: 100, offset: 0 })).length;
+        expect(after).toBe(before);
+    });
+    it('createCommit closesThreads — singular close (N=1) writes archived_reason="manual"', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'open', content: 'x', summary: 'x',
+            commitType: 'manual',
+            threads: { open: ['only-one'] },
+        });
+        const open = await store.listOpenThreads(project.id);
+        const handle = open[0].id.slice(0, 6);
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'close', content: 'y', summary: 'y',
+            commitType: 'manual',
+            threads: { closes: [handle] },
+        });
+        const archived = await store.listArchivedThreads(project.id);
+        expect(archived).toHaveLength(1);
+        expect(archived[0].archivedReason).toBe('manual');
+    });
+    it('createCommit closesThreads — batch close (N>1) writes archived_reason="bulk-cleanup"', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'open three', content: 'x', summary: 'x',
+            commitType: 'manual',
+            threads: { open: ['t-1', 't-2', 't-3'] },
+        });
+        const open = await store.listOpenThreads(project.id);
+        expect(open).toHaveLength(3);
+        const handles = open.map((t) => t.id.slice(0, 6));
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'close three', content: 'y', summary: 'y',
+            commitType: 'manual',
+            threads: { closes: handles },
+        });
+        const archived = await store.listArchivedThreads(project.id);
+        expect(archived).toHaveLength(3);
+        for (const a of archived) {
+            expect(a.archivedReason).toBe('bulk-cleanup');
+        }
+    });
+    it('createCommit legacy threads.close — singular vs batch follows the same rule', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'o', content: 'x', summary: 'x',
+            commitType: 'manual',
+            threads: { open: ['L1', 'L2'] },
+        });
+        const open = await store.listOpenThreads(project.id);
+        // Batch (N=2) via legacy close path
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'close batch', content: 'y', summary: 'y',
+            commitType: 'manual',
+            threads: { close: open.map((t) => ({ id: t.id, note: 'closed' })) },
+        });
+        const archived = await store.listArchivedThreads(project.id);
+        expect(archived).toHaveLength(2);
+        for (const a of archived)
+            expect(a.archivedReason).toBe('bulk-cleanup');
+    });
+    it('opens distinct threads when normalized subjects differ', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.upsertAgent({
+            id: 'agent-1',
+            projectId: project.id,
+            role: 'dev',
+            tool: 'claude-code',
+            workflowType: 'interactive',
+        });
+        await store.createCommit({
+            branchId: branch.id,
+            agentId: 'agent-1',
+            agentRole: 'dev',
+            tool: 'claude-code',
+            workflowType: 'interactive',
+            message: 'open two threads',
+            content: 'c',
+            summary: 's',
+            commitType: 'manual',
+            threads: { open: ['Subject A', 'Subject B'] },
+        });
+        const threads = await store.listOpenThreads(project.id);
+        expect(threads).toHaveLength(2);
+        expect(threads.map((t) => t.description).sort()).toEqual(['Subject A', 'Subject B']);
+    });
+    // ─── 04 DELTA planning hierarchy ─────────────────────────────────────────
+    it('LocalStore plan-tree round-trip: insertPlanTree → getPlanTree → updatePlanNodeStatus → completed', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const plan = await store.insertPlanTree(project.id, {
+            title: 'Plan Z',
+            children: [{ title: 'Step 1', children: [{ title: 'Task A' }] }],
+        });
+        expect(plan.level).toBe('plan');
+        expect(plan.children?.[0].children?.[0].title).toBe('Task A');
+        const active = await store.getPlanTree(project.id);
+        expect(active).toHaveLength(1);
+        const taskId = plan.children[0].children[0].id;
+        await store.updatePlanNodeStatus(taskId, 'done', null);
+        expect(await store.getPlanTree(project.id)).toHaveLength(0);
+        expect((await store.listCompletedPlans(project.id))[0].title).toBe('Plan Z');
+    });
+    it('SessionSnapshot.planTree is populated from getPlanTree', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.insertPlanTree(project.id, {
+            title: 'In-progress plan',
+            children: [{ title: 'S', children: [{ title: 'T' }] }],
+        });
+        const snap = await store.getSessionSnapshot(project.id, branch.id);
+        expect(snap.planTree).toBeDefined();
+        expect(snap.planTree.length).toBe(1);
+        expect(snap.planTree[0].title).toBe('In-progress plan');
+    });
+    it('createCommit completesTasks — handle match marks the task done', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        const plan = await store.insertPlanTree(project.id, {
+            title: 'P', children: [{ title: 'S', children: [{ title: 'T1' }] }],
+        });
+        const taskId = plan.children[0].children[0].id;
+        const handle = taskId.slice(0, 6);
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'done T1', content: 'x', summary: 'x',
+            commitType: 'manual',
+            completesTasks: [handle],
+        });
+        expect(await store.listCompletedPlans(project.id)).toHaveLength(1);
+    });
+    it('createCommit completesTasks — title match marks the task done', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        await store.insertPlanTree(project.id, {
+            title: 'P', children: [{ title: 'S', children: [{ title: 'Specific Task Title' }] }],
+        });
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'done', content: 'x', summary: 'x',
+            commitType: 'manual',
+            completesTasks: ['Specific Task Title'],
+        });
+        expect(await store.listCompletedPlans(project.id)).toHaveLength(1);
+    });
+    it('createCommit completesTasks — already-done node is a no-op success', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        const plan = await store.insertPlanTree(project.id, {
+            title: 'P', children: [{ title: 'S', children: [{ title: 'T' }] }],
+        });
+        const taskId = plan.children[0].children[0].id;
+        const handle = taskId.slice(0, 6);
+        await store.updatePlanNodeStatus(taskId, 'done', 'prior-commit');
+        // Same handle on a new save — must NOT throw.
+        await store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'c', content: 'y', summary: 'y',
+            commitType: 'manual',
+            completesTasks: [handle],
+        });
+        expect(await store.listCompletedPlans(project.id)).toHaveLength(1);
+    });
+    it('createCommit completesTasks — no match aborts the entire save atomically', async () => {
+        const project = await store.createProject({ name: 'p' });
+        const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' });
+        const before = (await store.listCommits(branch.id, { limit: 100, offset: 0 })).length;
+        await expect(store.createCommit({
+            branchId: branch.id, agentId: 'a', agentRole: 'solo', tool: 't',
+            workflowType: 'interactive', message: 'c', content: 'y', summary: 'y',
+            commitType: 'manual',
+            completesTasks: ['xxxxxx-bogus'],
+        })).rejects.toThrow(/completesTasks/);
+        const after = (await store.listCommits(branch.id, { limit: 100, offset: 0 })).length;
+        expect(after).toBe(before);
+    });
 });
 //# sourceMappingURL=local-store.test.js.map