chapterhouse 0.2.0 → 0.3.0

package/README.md

@@ -239,8 +239,31 @@ The deployment assets for the shared instance set Entra auth and `CHAPTERHOUSE_M
 | `chapterhouse update --check-only` | Print current/latest version without updating                    |
 | `chapterhouse update --ref <ver>`  | Install a specific version                                       |
 | `chapterhouse daemon <sub>`    | Manage the persistent background service          |
+| `chapterhouse squad worktree <sub>` | Manage per-agent git worktrees for concurrent squad work |
 | `chapterhouse help`            | Show available commands                           |
 
+### Squad Worktree Commands
+
+Squad agents that work on GitHub issues each get a dedicated git worktree so they never step on each other. The `chapterhouse squad worktree` subcommands manage these worktrees:
+
+```sh
+chapterhouse squad worktree create <agent> <issue> [--base main] [--slug <slug>]
+    # Creates .worktrees/{agent}-{issue}/ and branch squad/{issue}-{slug}
+    # Prints the worktree path to stdout. Reuses existing worktree if present.
+
+chapterhouse squad worktree list
+    # Shows all active squad worktrees: agent, issue, branch, status, path
+
+chapterhouse squad worktree remove <agent> <issue> [--force] [--delete-branch]
+    # Removes a worktree. Refuses if dirty unless --force is passed.
+
+chapterhouse squad worktree prune [--base main] [--dry-run]
+    # Removes all worktrees whose branch has been merged into main.
+    # Skips dirty worktrees with a warning.
+```
+
+**How it works:** Worktrees live at `.worktrees/{agent}-{issue}/` inside the repo (gitignored). The Squad coordinator creates each worktree *before* spawning an agent and passes the path as `WORKTREE_PATH` in the spawn prompt. Agents do all their work—reads, edits, commits—inside that path. No agent ever runs `git checkout` in a working tree it doesn't own.
+
 ### Flags
 
 | Flag          | Description                                                                      |
@@ -428,3 +451,13 @@ git push origin main --follow-tags
 ```
 
 `npm version` handles the commit and tag automatically. `prepublishOnly` runs `npm run build` before publish so the tarball always contains a fresh build. If you don't have CI set up, publish manually with `npm publish` after the tag push.
+
+> **Pre-release gate:** `preversion` runs `npm run release:check` automatically before any `npm version` call. The script aborts with a clear error if the git working tree is dirty. Stash or commit all changes (including `.squad/` metadata edits) before bumping the version.
+
+### Commit message convention
+
+All commits on this repository follow **[Conventional Commits v1.0.0](https://www.conventionalcommits.org/en/v1.0.0/)**. The format is `<type>(<scope>): <subject>` (e.g. `feat(api): add session export endpoint`). Allowed types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `chore`, `build`, `ci`, `revert`, `release`.
+
+This is automatically enforced:
+- **Locally:** `husky` installs a `commit-msg` git hook on `npm install` that runs `commitlint` against every commit message. Bad messages are rejected before the commit lands.
+- **On PRs:** A GitHub Action (`lint-pr-title.yml`) validates the PR title on every open/edit. This matters because squash-merges use the PR title as the commit message on `main`.

package/dist/cli.js

@@ -25,6 +25,7 @@ Commands:
   setup            Pick a default model and write ~/.chapterhouse/.env
   update           Check for updates and install the latest version
   daemon <sub>     Manage the persistent background service (install/uninstall/start/stop/restart/status/logs)
+  squad <sub>      Squad agent tools (worktree management)
   help             Show this help message
 
 Flags (start):
@@ -178,6 +179,29 @@ switch (command) {
         }
         break;
     }
+    case "squad": {
+        const squadSub = args[1];
+        if (squadSub === 'worktree') {
+            const { runWorktreeCli, printWorktreeHelp } = await import("./squad/worktree.js");
+            await runWorktreeCli(args.slice(2));
+        }
+        else {
+            if (squadSub) {
+                console.error(`Unknown squad subcommand: ${squadSub}\n`);
+            }
+            console.log(`
+chapterhouse squad — Squad agent tools
+
+Subcommands:
+  worktree   Manage per-agent git worktrees (create / list / remove / prune)
+
+Run \`chapterhouse squad worktree\` for worktree subcommand help.
+`.trim());
+            if (squadSub)
+                process.exit(1);
+        }
+        break;
+    }
     case "help":
     case "--help":
     case "-h":

package/dist/squad/index.js

@@ -4,4 +4,5 @@ export * from './registry.js';
 export * from './context.js';
 export * from './charter.js';
 export * from './mirror.js';
+export * from './worktree.js';
 //# sourceMappingURL=index.js.map

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "chapterhouse",
-  "version": "0.2.0",
-  "description": "Chapterhouse \u2014 a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
+  "version": "0.3.0",
+  "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"
   },
@@ -22,8 +22,12 @@
     "dev:server": "tsx --watch src/daemon.ts",
     "dev:web": "npm --prefix web run dev",
     "dev": "tsx --watch src/daemon.ts",
+    "release:check": "if [ -n \"$(git status --porcelain)\" ]; then echo '❌ Working tree is not clean. Stage or stash changes before running npm version.'; git status --short; exit 1; fi",
+    "preversion": "npm run release:check",
+    "prepare": "husky",
     "test": "npm run clean && npm run build:server && node --experimental-test-module-mocks --import ./dist/test/setup-env.js --test 'dist/**/*.test.js'",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "prepare": "husky"
   },
   "engines": {
     "node": ">=22.5.0"
@@ -62,11 +66,14 @@
   },
   "devDependencies": {
     "@bradygaster/squad-cli": "^0.9.4",
+    "@commitlint/cli": "^21.0.0",
+    "@commitlint/config-conventional": "^21.0.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^25.6.0",
+    "husky": "^9.1.7",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }