chapterhouse 0.1.5 → 0.3.0

package/dist/squad/worktree.js

@@ -0,0 +1,295 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+// ---------------------------------------------------------------------------
+// Path convention
+// ---------------------------------------------------------------------------
+/**
+ * Location: `.worktrees/{agent}-{issueNum}/` inside the repo root.
+ * This keeps worktrees discoverable (they're adjacent to the code) and
+ * `git worktree list` always surfaces them. The directory is gitignored.
+ *
+ * Tradeoff vs `~/.cache/chapterhouse-worktrees/<repo>/`:
+ *   + Visible without knowing a cache path
+ *   + `chapterhouse squad worktree list` doesn't need to guess the home
+ *   - Must be added to .gitignore (done once, documented here)
+ */
+export function getWorktreePath(repoRoot, agent, issueNum) {
+    return join(repoRoot, '.worktrees', `${agent}-${issueNum}`);
+}
+export function getBranchName(issueNum, slug) {
+    const safeslug = slug ? `-${slug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')}` : '';
+    return `squad/${issueNum}${safeslug}`;
+}
+// ---------------------------------------------------------------------------
+// Git helpers
+// ---------------------------------------------------------------------------
+function git(args, cwd) {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf-8' });
+    return {
+        ok: result.status === 0,
+        stdout: (result.stdout ?? '').trim(),
+        stderr: (result.stderr ?? '').trim(),
+    };
+}
+function hasUncommittedChanges(worktreePath) {
+    const r = git(['status', '--porcelain'], worktreePath);
+    return r.ok && r.stdout.length > 0;
+}
+function isBranchMerged(repoRoot, branch, base = 'main') {
+    // merged if branch tip is reachable from base
+    const r = git(['branch', '--merged', base, '--list', branch], repoRoot);
+    return r.ok && r.stdout.length > 0;
+}
+function getRepoRoot(cwd) {
+    const r = git(['rev-parse', '--show-toplevel'], cwd);
+    if (!r.ok)
+        throw new Error(`Not inside a git repo: ${r.stderr}`);
+    return r.stdout;
+}
+/**
+ * Create a dedicated worktree for an agent + issue pair.
+ * Branch: `squad/{issueNum}-{agent}` (off `main` by default).
+ * Returns the worktree path.
+ */
+export function createWorktree(repoRoot, agent, issueNum, opts = {}) {
+    const baseBranch = opts.baseBranch ?? 'main';
+    const branch = getBranchName(issueNum, opts.slug ?? agent);
+    const worktreePath = getWorktreePath(repoRoot, agent, issueNum);
+    if (existsSync(worktreePath)) {
+        // Reuse existing worktree
+        console.log(`↩  Reusing existing worktree: ${relative(repoRoot, worktreePath)}`);
+        return worktreePath;
+    }
+    // Check if branch already exists (another agent on same issue)
+    const branchExists = git(['show-ref', '--verify', `refs/heads/${branch}`], repoRoot);
+    let result;
+    if (branchExists.ok) {
+        result = git(['worktree', 'add', worktreePath, branch], repoRoot);
+    }
+    else {
+        result = git(['worktree', 'add', '-b', branch, worktreePath, baseBranch], repoRoot);
+    }
+    if (!result.ok) {
+        throw new Error(`Failed to create worktree: ${result.stderr}`);
+    }
+    console.log(`✅ Worktree created: ${relative(repoRoot, worktreePath)} (branch: ${branch})`);
+    return worktreePath;
+}
+/**
+ * List all squad worktrees (worktrees under `.worktrees/` with `squad/` branches).
+ */
+export function listWorktrees(repoRoot) {
+    const r = git(['worktree', 'list', '--porcelain'], repoRoot);
+    if (!r.ok)
+        throw new Error(`git worktree list failed: ${r.stderr}`);
+    const entries = parseWorktreePorcelain(r.stdout);
+    const squadEntries = entries.filter(e => e.path.includes('/.worktrees/'));
+    return squadEntries.map(e => {
+        const dirName = e.path.split('/.worktrees/')[1] ?? '';
+        const match = dirName.match(/^([^-]+)-(\d+)/);
+        const agent = match ? match[1] : dirName;
+        const issueNum = match ? match[2] : '?';
+        const dirty = existsSync(e.path) && hasUncommittedChanges(e.path);
+        return {
+            agent,
+            issueNum,
+            path: e.path,
+            branch: e.branch ?? '(detached)',
+            exists: existsSync(e.path),
+            dirty,
+            head: e.head ?? '',
+        };
+    });
+}
+/**
+ * Remove a specific worktree. Warns but refuses if the worktree has
+ * uncommitted changes (pass `force: true` to override).
+ */
+export function removeWorktree(repoRoot, agent, issueNum, opts = {}) {
+    const worktreePath = getWorktreePath(repoRoot, agent, issueNum);
+    if (!existsSync(worktreePath)) {
+        console.log(`ℹ  Worktree not found: ${worktreePath} (nothing to remove)`);
+        return;
+    }
+    if (!opts.force && hasUncommittedChanges(worktreePath)) {
+        console.error(`⚠  Worktree ${relative(repoRoot, worktreePath)} has uncommitted changes.\n` +
+            `   Commit or stash your work before removing, or pass --force to discard.`);
+        process.exitCode = 1;
+        return;
+    }
+    const removeArgs = ['worktree', 'remove', worktreePath];
+    if (opts.force)
+        removeArgs.push('--force');
+    const r = git(removeArgs, repoRoot);
+    if (!r.ok)
+        throw new Error(`Failed to remove worktree: ${r.stderr}`);
+    if (opts.deleteBranch) {
+        const branch = getBranchName(issueNum, agent);
+        const del = git(['branch', '-d', branch], repoRoot);
+        if (!del.ok) {
+            console.warn(`⚠  Could not delete branch ${branch}: ${del.stderr}`);
+        }
+    }
+    console.log(`🗑  Removed worktree: ${relative(repoRoot, worktreePath)}`);
+}
+/**
+ * Remove all squad worktrees whose branch has been merged into `main`.
+ * Warns and skips worktrees with uncommitted changes.
+ */
+export function pruneWorktrees(repoRoot, opts = {}) {
+    const base = opts.base ?? 'main';
+    const worktrees = listWorktrees(repoRoot);
+    if (worktrees.length === 0) {
+        console.log('ℹ  No squad worktrees found.');
+        return;
+    }
+    for (const wt of worktrees) {
+        const merged = isBranchMerged(repoRoot, wt.branch, base);
+        if (!merged) {
+            console.log(`↷  Skipping ${wt.agent}-${wt.issueNum} (branch not merged into ${base})`);
+            continue;
+        }
+        if (wt.dirty) {
+            console.warn(`⚠  Skipping ${wt.agent}-${wt.issueNum} (has uncommitted changes — clean up manually)`);
+            continue;
+        }
+        if (opts.dryRun) {
+            console.log(`[dry-run] Would remove: ${wt.agent}-${wt.issueNum} (branch: ${wt.branch})`);
+            continue;
+        }
+        removeWorktree(repoRoot, wt.agent, Number(wt.issueNum), { deleteBranch: true });
+    }
+}
+// ---------------------------------------------------------------------------
+// Print helpers
+// ---------------------------------------------------------------------------
+export function printWorktreeList(repoRoot) {
+    const worktrees = listWorktrees(repoRoot);
+    if (worktrees.length === 0) {
+        console.log('No squad worktrees found.');
+        return;
+    }
+    const header = ['AGENT', 'ISSUE', 'BRANCH', 'STATUS', 'PATH'];
+    const rows = worktrees.map(wt => [
+        wt.agent,
+        wt.issueNum,
+        wt.branch,
+        wt.dirty ? '⚠ dirty' : '✓ clean',
+        wt.path,
+    ]);
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map(r => r[i].length)));
+    const fmt = (cols) => cols.map((c, i) => c.padEnd(widths[i])).join('  ');
+    console.log(fmt(header));
+    console.log(widths.map(w => '-'.repeat(w)).join('  '));
+    for (const row of rows)
+        console.log(fmt(row));
+}
+export function printWorktreeHelp() {
+    console.log(`
+chapterhouse squad worktree — manage per-agent git worktrees
+
+Usage:
+  chapterhouse squad worktree <subcommand>
+
+Subcommands:
+  create <agent> <issue> [--base <branch>] [--slug <slug>]
+      Create a dedicated worktree for an agent + issue.
+      Path: .worktrees/{agent}-{issue}/   Branch: squad/{issue}-{agent}
+
+  list
+      List all squad worktrees with agent, branch, and status.
+
+  remove <agent> <issue> [--force] [--delete-branch]
+      Remove a worktree. Refuses if there are uncommitted changes
+      unless --force is passed (which discards the changes).
+
+  prune [--base <branch>] [--dry-run]
+      Remove all worktrees whose branch has been merged into main
+      (or the specified --base branch). Skips dirty worktrees.
+`.trim());
+}
+function parseWorktreePorcelain(output) {
+    const entries = [];
+    let current = null;
+    for (const line of output.split('\n')) {
+        if (line.startsWith('worktree ')) {
+            if (current?.path)
+                entries.push(current);
+            current = { path: line.slice('worktree '.length) };
+        }
+        else if (line.startsWith('HEAD ') && current) {
+            current.head = line.slice('HEAD '.length);
+        }
+        else if (line.startsWith('branch ') && current) {
+            current.branch = line.slice('branch refs/heads/'.length);
+        }
+        else if (line === '' && current?.path) {
+            entries.push(current);
+            current = null;
+        }
+    }
+    if (current?.path)
+        entries.push(current);
+    return entries;
+}
+// ---------------------------------------------------------------------------
+// CLI entry point
+// ---------------------------------------------------------------------------
+export async function runWorktreeCli(args) {
+    let repoRoot;
+    try {
+        repoRoot = getRepoRoot(process.cwd());
+    }
+    catch {
+        console.error('❌ Not inside a git repository.');
+        process.exit(1);
+    }
+    const subcommand = args[0];
+    switch (subcommand) {
+        case 'create': {
+            const agent = args[1];
+            const issueNum = args[2];
+            if (!agent || !issueNum) {
+                console.error('Usage: chapterhouse squad worktree create <agent> <issue> [--base <branch>] [--slug <slug>]');
+                process.exit(1);
+            }
+            const baseIdx = args.indexOf('--base');
+            const baseBranch = baseIdx !== -1 ? args[baseIdx + 1] : undefined;
+            const slugIdx = args.indexOf('--slug');
+            const slug = slugIdx !== -1 ? args[slugIdx + 1] : undefined;
+            const path = createWorktree(repoRoot, agent, issueNum, { baseBranch, slug });
+            console.log(path);
+            break;
+        }
+        case 'list':
+            printWorktreeList(repoRoot);
+            break;
+        case 'remove': {
+            const agent = args[1];
+            const issueNum = args[2];
+            if (!agent || !issueNum) {
+                console.error('Usage: chapterhouse squad worktree remove <agent> <issue> [--force] [--delete-branch]');
+                process.exit(1);
+            }
+            removeWorktree(repoRoot, agent, issueNum, {
+                force: args.includes('--force'),
+                deleteBranch: args.includes('--delete-branch'),
+            });
+            break;
+        }
+        case 'prune': {
+            const baseIdx = args.indexOf('--base');
+            const base = baseIdx !== -1 ? args[baseIdx + 1] : undefined;
+            pruneWorktrees(repoRoot, { base, dryRun: args.includes('--dry-run') });
+            break;
+        }
+        default:
+            if (subcommand)
+                console.error(`Unknown worktree subcommand: ${subcommand}\n`);
+            printWorktreeHelp();
+            if (subcommand)
+                process.exit(1);
+    }
+}
+//# sourceMappingURL=worktree.js.map

package/dist/squad/worktree.test.js

@@ -0,0 +1,189 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import test from 'node:test';
+// ---------------------------------------------------------------------------
+// Test fixture: minimal git repo
+// ---------------------------------------------------------------------------
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, '.test-work', `worktree-${process.pid}`);
+function initRepo(dir) {
+    mkdirSync(dir, { recursive: true });
+    // --initial-branch=main ensures the branch is named 'main' regardless of
+    // the runner's global init.defaultBranch setting (older git may default to 'master').
+    execSync('git init --initial-branch=main', { cwd: dir, stdio: 'pipe' });
+    execSync('git config user.email "test@example.com"', { cwd: dir, stdio: 'pipe' });
+    execSync('git config user.name "Test CI"', { cwd: dir, stdio: 'pipe' });
+    writeFileSync(join(dir, 'README.md'), '# test\n');
+    execSync('git add .', { cwd: dir, stdio: 'pipe' });
+    // An initial commit is required so that 'main' resolves as a ref.
+    // Without it, `git worktree add <path> -b <branch> main` fails with
+    // "fatal: invalid reference: main" because the branch has no commits.
+    execSync('git commit -m "chore: initial commit"', { cwd: dir, stdio: 'pipe' });
+}
+// We need a separate repo because the main repo's worktrees would interfere.
+// Each test suite gets its own isolated sandbox git repo.
+const testRepo = join(sandboxRoot, 'repo');
+test.before(() => {
+    mkdirSync(sandboxRoot, { recursive: true });
+    initRepo(testRepo);
+});
+test.after(() => {
+    // Clean up any worktrees first (git worktree remove) then the sandbox
+    try {
+        execSync('git worktree prune', { cwd: testRepo });
+    }
+    catch { /* ignore */ }
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+async function loadWorktree() {
+    return await import(new URL(`./worktree.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+// ---------------------------------------------------------------------------
+// getWorktreePath
+// ---------------------------------------------------------------------------
+test('getWorktreePath returns correct path inside .worktrees/', async () => {
+    const m = await loadWorktree();
+    const result = m.getWorktreePath('/repo', 'kaylee', 42);
+    assert.equal(result, '/repo/.worktrees/kaylee-42');
+});
+test('getWorktreePath works with string issue number', async () => {
+    const m = await loadWorktree();
+    const result = m.getWorktreePath('/repo', 'wash', '17');
+    assert.equal(result, '/repo/.worktrees/wash-17');
+});
+// ---------------------------------------------------------------------------
+// getBranchName
+// ---------------------------------------------------------------------------
+test('getBranchName without slug uses squad/{issue} format', async () => {
+    const m = await loadWorktree();
+    assert.equal(m.getBranchName(49), 'squad/49');
+});
+test('getBranchName with slug appends kebab-case slug', async () => {
+    const m = await loadWorktree();
+    assert.equal(m.getBranchName(49, 'git worktrees'), 'squad/49-git-worktrees');
+});
+test('getBranchName normalises special characters in slug', async () => {
+    const m = await loadWorktree();
+    assert.equal(m.getBranchName(10, 'Fix Login!!'), 'squad/10-fix-login');
+});
+// ---------------------------------------------------------------------------
+// createWorktree
+// ---------------------------------------------------------------------------
+test('createWorktree creates a worktree at .worktrees/{agent}-{issue}/', async () => {
+    const m = await loadWorktree();
+    const { existsSync } = await import('node:fs');
+    const wt = m.createWorktree(testRepo, 'kaylee', 1);
+    assert.ok(existsSync(wt), `Worktree path should exist: ${wt}`);
+    assert.ok(wt.endsWith('.worktrees/kaylee-1'), `Path should end with .worktrees/kaylee-1, got: ${wt}`);
+    // Verify branch was created
+    const { spawnSync } = await import('node:child_process');
+    const r = spawnSync('git', ['branch', '--list', 'squad/1-kaylee'], { cwd: testRepo, encoding: 'utf-8' });
+    assert.ok(r.stdout.trim().length > 0, 'Branch squad/1-kaylee should exist');
+});
+test('createWorktree reuses existing worktree without error', async () => {
+    const m = await loadWorktree();
+    // create again (already exists from above)
+    assert.doesNotThrow(() => {
+        m.createWorktree(testRepo, 'kaylee', 1);
+    });
+});
+test('createWorktree respects --base option', async () => {
+    const m = await loadWorktree();
+    const { existsSync } = await import('node:fs');
+    // We guarantee 'main' exists via --initial-branch=main in initRepo
+    const wt = m.createWorktree(testRepo, 'wash', 2, { baseBranch: 'main' });
+    assert.ok(existsSync(wt), `Worktree should be created at ${wt}`);
+});
+test('createWorktree with slug uses slug in branch name', async () => {
+    const m = await loadWorktree();
+    const wt = m.createWorktree(testRepo, 'zoe', 3, { slug: 'test-isolation' });
+    const { spawnSync } = await import('node:child_process');
+    const r = spawnSync('git', ['branch', '--list', 'squad/3-test-isolation'], { cwd: testRepo, encoding: 'utf-8' });
+    assert.ok(r.stdout.trim().length > 0, 'Branch squad/3-test-isolation should exist');
+    void wt;
+});
+// ---------------------------------------------------------------------------
+// listWorktrees
+// ---------------------------------------------------------------------------
+test('listWorktrees returns entries for squad worktrees', async () => {
+    const m = await loadWorktree();
+    const list = m.listWorktrees(testRepo);
+    // We created kaylee-1 above; at minimum it should appear
+    assert.ok(list.length >= 1, 'Should have at least 1 squad worktree');
+    const kaylee = list.find(w => w.agent === 'kaylee' && w.issueNum === '1');
+    assert.ok(kaylee, 'Should include kaylee-1 worktree');
+    assert.equal(kaylee?.branch, 'squad/1-kaylee');
+    assert.equal(typeof kaylee?.dirty, 'boolean');
+});
+test('listWorktrees does not include the main checkout', async () => {
+    const m = await loadWorktree();
+    const list = m.listWorktrees(testRepo);
+    const hasMain = list.some(w => !w.path.includes('/.worktrees/'));
+    assert.ok(!hasMain, 'Main checkout should not appear in squad worktree list');
+});
+// ---------------------------------------------------------------------------
+// removeWorktree
+// ---------------------------------------------------------------------------
+test('removeWorktree removes a clean worktree', async () => {
+    const m = await loadWorktree();
+    // Create a fresh worktree to remove
+    m.createWorktree(testRepo, 'scribe', 5);
+    const wtPath = m.getWorktreePath(testRepo, 'scribe', 5);
+    const { existsSync } = await import('node:fs');
+    assert.ok(existsSync(wtPath));
+    m.removeWorktree(testRepo, 'scribe', 5);
+    assert.ok(!existsSync(wtPath), 'Worktree should be removed');
+});
+test('removeWorktree is a no-op for non-existent worktree', async () => {
+    const m = await loadWorktree();
+    assert.doesNotThrow(() => {
+        m.removeWorktree(testRepo, 'ghost', 999);
+    });
+});
+test('removeWorktree refuses to remove dirty worktree without --force', async () => {
+    const m = await loadWorktree();
+    const { writeFileSync } = await import('node:fs');
+    // Create worktree, then add an uncommitted file
+    m.createWorktree(testRepo, 'mal', 6);
+    const wtPath = m.getWorktreePath(testRepo, 'mal', 6);
+    writeFileSync(join(wtPath, 'uncommitted.txt'), 'dirty\n');
+    // Should set exitCode=1 but not throw
+    const prev = process.exitCode;
+    process.exitCode = 0;
+    m.removeWorktree(testRepo, 'mal', 6, { force: false });
+    const rejected = process.exitCode === 1;
+    process.exitCode = prev; // restore
+    assert.ok(rejected, 'Should set exitCode=1 for dirty worktree');
+    // cleanup with force
+    m.removeWorktree(testRepo, 'mal', 6, { force: true });
+});
+// ---------------------------------------------------------------------------
+// pruneWorktrees
+// ---------------------------------------------------------------------------
+test('pruneWorktrees dry-run lists worktrees that would be removed', async () => {
+    const m = await loadWorktree();
+    // Capture stdout (basic test — just ensure it doesn't throw)
+    assert.doesNotThrow(() => {
+        m.pruneWorktrees(testRepo, { dryRun: true });
+    });
+});
+test('pruneWorktrees skips worktrees on unmerged branches', async () => {
+    const m = await loadWorktree();
+    const { existsSync, writeFileSync } = await import('node:fs');
+    const { spawnSync } = await import('node:child_process');
+    const { join } = await import('node:path');
+    // zoe-3 worktree should exist (created in earlier test)
+    const wt = m.getWorktreePath(testRepo, 'zoe', 3);
+    assert.ok(existsSync(wt), 'zoe-3 worktree should exist');
+    // Add a commit so the branch diverges from base — otherwise git considers
+    // a branch with no extra commits as already merged into its parent.
+    writeFileSync(join(wt, 'feature.txt'), 'in progress\n');
+    spawnSync('git', ['add', 'feature.txt'], { cwd: wt, stdio: 'pipe' });
+    spawnSync('git', ['commit', '-m', 'feat: in-progress work'], { cwd: wt, stdio: 'pipe' });
+    // We guarantee 'main' via --initial-branch=main in initRepo
+    m.pruneWorktrees(testRepo, { base: 'main' });
+    assert.ok(existsSync(wt), 'Unmerged worktree should NOT be pruned');
+});
+//# sourceMappingURL=worktree.test.js.map

package/dist/store/db.js

@@ -150,6 +150,13 @@ export function getDb() {
         if (!taskCols.some((c) => c.name === 'source')) {
             db.exec(`ALTER TABLE agent_tasks ADD COLUMN source TEXT NOT NULL DEFAULT 'adhoc'`);
         }
+        // Migrate: add last_used_at column to project_squads (epoch ms, nullable)
+        const projectCols = db.prepare(`PRAGMA table_info(project_squads)`).all();
+        if (!projectCols.some((c) => c.name === 'last_used_at')) {
+            db.exec(`ALTER TABLE project_squads ADD COLUMN last_used_at INTEGER`);
+            // Backfill from loaded_at so sidebar is not empty for existing projects
+            db.exec(`UPDATE project_squads SET last_used_at = CAST((julianday(loaded_at) - 2440587.5) * 86400000 AS INTEGER) WHERE last_used_at IS NULL`);
+        }
         // Prune conversation log at startup — keep more history for better recovery
         db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 1000)`).run();
         // Set up FTS5 for memory search (graceful fallback if not available)
@@ -280,11 +287,42 @@ export function getRecentConversation(limit, sessionKey) {
         return `${tag}: ${content}`;
     }).join("\n\n");
 }
+const MAX_SESSION_MESSAGES_LIMIT = 500;
+const DEFAULT_SESSION_MESSAGES_LIMIT = 100;
+/**
+ * Return conversation_log rows for a specific session as structured JSON,
+ * suitable for seeding the frontend Zustand store on mount.
+ *
+ * Unlike `getRecentConversation()`, this returns structured objects (not a
+ * formatted string) and omits system messages (role = 'system') because the
+ * UI only renders user/assistant turns.
+ */
+export function getSessionMessages(sessionKey, limit) {
+    const db = getDb();
+    const effectiveLimit = Math.min(limit ?? DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT);
+    const rows = db
+        .prepare(`SELECT role, content, ts FROM conversation_log
+       WHERE session_key = ? AND role IN ('user', 'assistant')
+       ORDER BY id DESC LIMIT ?`)
+        .all(sessionKey, effectiveLimit);
+    // Reverse so oldest is first (chronological order for the UI)
+    rows.reverse();
+    return rows.map((r) => ({
+        role: r.role,
+        content: r.content,
+        ts: r.ts,
+    }));
+}
 // ---------------------------------------------------------------------------
 // SQLite memory functions removed — wiki is the single source of truth.
 // The memories table and FTS5 index are preserved in the schema for safety
 // (existing data is not deleted), but no code reads or writes to them.
 // ---------------------------------------------------------------------------
+export function bumpProjectLastUsed(projectRoot) {
+    getDb()
+        .prepare(`UPDATE project_squads SET last_used_at = ? WHERE project_root = ?`)
+        .run(Date.now(), projectRoot);
+}
 export function closeDb() {
     if (db) {
         db.close();

package/dist/store/db.test.js

@@ -123,4 +123,92 @@ test("getDb prunes oversized conversation logs on startup and during inserts", a
         dbModule.closeDb();
     }
 });
+test("getSessionMessages returns empty array for unknown session", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        dbModule.getDb();
+        const result = dbModule.getSessionMessages("nonexistent-session");
+        assert.deepEqual(result, []);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("getSessionMessages returns structured messages in chronological order, excludes system rows, respects limit", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        dbModule.getDb();
+        dbModule.logConversation("user", "hello", "web", "test-session");
+        dbModule.logConversation("assistant", "hi there", "web", "test-session");
+        dbModule.logConversation("system", "system noise", "worker", "test-session");
+        dbModule.logConversation("user", "second message", "web", "test-session");
+        dbModule.logConversation("user", "from other session", "web", "other-session");
+        const all = dbModule.getSessionMessages("test-session");
+        assert.equal(all.length, 3, "3 user/assistant rows, system excluded");
+        assert.equal(all[0].role, "user");
+        assert.equal(all[0].content, "hello");
+        assert.equal(all[1].role, "assistant");
+        assert.equal(all[1].content, "hi there");
+        assert.equal(all[2].role, "user");
+        assert.equal(all[2].content, "second message");
+        // Limit clamping
+        const limited = dbModule.getSessionMessages("test-session", 2);
+        assert.equal(limited.length, 2, "limit=2 returns 2 most recent rows");
+        // After reversal, these should be the 2 most-recent (assistant + second user)
+        assert.equal(limited[0].content, "hi there");
+        assert.equal(limited[1].content, "second message");
+        // Other session not leaked
+        const other = dbModule.getSessionMessages("other-session");
+        assert.equal(other.length, 1);
+        assert.equal(other[0].content, "from other session");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+// ---------------------------------------------------------------------------
+// #26 — bumpProjectLastUsed
+// ---------------------------------------------------------------------------
+test("migration adds last_used_at column to project_squads when absent", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        const cols = db.prepare(`PRAGMA table_info(project_squads)`).all();
+        assert.equal(cols.some((c) => c.name === "last_used_at"), true, "last_used_at column should exist after migration");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("bumpProjectLastUsed updates last_used_at for the given project_root", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare(`INSERT INTO project_squads (project_root, squad_dir, team_dir, mode, registered) VALUES (?, ?, ?, 'local', 1)`).run("/home/user/test-proj", "/home/user/test-proj/.squad", "/home/user/test-proj/.squad");
+        const before = db
+            .prepare(`SELECT last_used_at FROM project_squads WHERE project_root = ?`)
+            .get("/home/user/test-proj");
+        const beforeTs = before.last_used_at ?? 0;
+        await new Promise((r) => setTimeout(r, 5));
+        dbModule.bumpProjectLastUsed("/home/user/test-proj");
+        const after = db
+            .prepare(`SELECT last_used_at FROM project_squads WHERE project_root = ?`)
+            .get("/home/user/test-proj");
+        assert.ok(after.last_used_at !== null, "last_used_at should not be null after bump");
+        assert.ok(after.last_used_at > beforeTs, "last_used_at should advance after bump");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("bumpProjectLastUsed is a no-op for unknown project_root (no throw)", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        dbModule.getDb();
+        dbModule.bumpProjectLastUsed("/does/not/exist");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 //# sourceMappingURL=db.test.js.map