chapterhouse 0.3.13 → 0.3.14

package/dist/squad/mirror.scheduler.test.js

@@ -1,197 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { DecisionsSyncScheduler, DEFAULT_DECISIONS_SYNC_INTERVAL_MS } from './mirror.scheduler.js';
-function makeFakeInterval() {
-    let nextId = 1;
-    const timers = new Map();
-    const setIntervalImpl = (cb, ms) => {
-        const id = nextId++;
-        timers.set(id, { cb, ms });
-        return { id, unref: () => { } };
-    };
-    const clearIntervalImpl = (handle) => {
-        timers.delete(handle.id);
-    };
-    const tick = () => {
-        for (const { cb } of timers.values())
-            cb();
-    };
-    const activeCount = () => timers.size;
-    return { setIntervalImpl, clearIntervalImpl, tick, activeCount };
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-test('DecisionsSyncScheduler: default interval matches 5 minutes', () => {
-    assert.equal(DEFAULT_DECISIONS_SYNC_INTERVAL_MS, 300_000);
-});
-test('DecisionsSyncScheduler: start registers a timer with the configured interval', () => {
-    const intervals = [];
-    const handles = [];
-    const setIntervalImpl = (cb, ms) => {
-        intervals.push(ms);
-        const handle = { id: 1, unref: () => { } };
-        handles.push(handle);
-        return handle;
-    };
-    const clearIntervalImpl = (_h) => { };
-    const scheduler = new DecisionsSyncScheduler({
-        intervalMs: 60_000,
-        getRegisteredProjectRoots: () => [],
-        syncFn: async () => null,
-        setIntervalImpl: setIntervalImpl,
-        clearIntervalImpl: clearIntervalImpl,
-    });
-    scheduler.start();
-    assert.equal(intervals.length, 1, 'should register exactly one interval');
-    assert.equal(intervals[0], 60_000, 'interval should match configured value');
-});
-test('DecisionsSyncScheduler: does not register a timer when intervalMs <= 0', () => {
-    let registered = 0;
-    const setIntervalImpl = (_cb, _ms) => {
-        registered++;
-        return { id: 1 };
-    };
-    const clearIntervalImpl = (_h) => { };
-    const scheduler = new DecisionsSyncScheduler({
-        intervalMs: 0,
-        getRegisteredProjectRoots: () => ['/some/project'],
-        syncFn: async () => null,
-        setIntervalImpl: setIntervalImpl,
-        clearIntervalImpl: clearIntervalImpl,
-    });
-    scheduler.start();
-    assert.equal(registered, 0, 'should not register any interval when disabled');
-});
-test('DecisionsSyncScheduler: tick calls syncFn once per registered project', async () => {
-    const synced = [];
-    const scheduler = new DecisionsSyncScheduler({
-        intervalMs: 60_000,
-        getRegisteredProjectRoots: () => ['/project/alpha', '/project/beta', '/project/gamma'],
-        syncFn: async (root) => { synced.push(root); return { entriesSynced: 1, wikiPath: 'pages/x.md' }; },
-        setIntervalImpl: setInterval,
-        clearIntervalImpl: clearInterval,
-    });
-    await scheduler.tick();
-    assert.deepEqual(synced, ['/project/alpha', '/project/beta', '/project/gamma'], 'should call syncFn once per project in order');
-});
-test('DecisionsSyncScheduler: tick calls syncFn on each interval tick', async () => {
-    const { setIntervalImpl, clearIntervalImpl, tick } = makeFakeInterval();
-    const syncCalls = [];
-    const scheduler = new DecisionsSyncScheduler({
-        intervalMs: 60_000,
-        getRegisteredProjectRoots: () => ['/project/alpha', '/project/beta'],
-        syncFn: async (root) => { syncCalls.push(root); return null; },
-        setIntervalImpl: setIntervalImpl,
-        clearIntervalImpl: clearIntervalImpl,
-    });
-    scheduler.start();
-    // Simulate two interval ticks — we need to await async propagation
-    tick();
-    await new Promise(r => setImmediate(r));
-    tick();
-    await new Promise(r => setImmediate(r));
-    // Two ticks × two projects = 4 sync calls
-    assert.equal(syncCalls.length, 4, 'should call syncFn 2 projects × 2 ticks = 4 times');
-    assert.ok(syncCalls.filter(r => r === '/project/alpha').length === 2, 'alpha synced twice');
-    assert.ok(syncCalls.filter(r => r === '/project/beta').length === 2, 'beta synced twice');
-});
-test('DecisionsSyncScheduler: stop clears the timer', () => {
-    const { setIntervalImpl, clearIntervalImpl, activeCount } = makeFakeInterval();
-    const scheduler = new DecisionsSyncScheduler({
-        intervalMs: 60_000,
-        getRegisteredProjectRoots: () => ['/project/x'],
-        syncFn: async () => null,
-        setIntervalImpl: setIntervalImpl,
-        clearIntervalImpl: clearIntervalImpl,
-    });
-    scheduler.start();
-    assert.equal(activeCount(), 1, 'timer should be registered after start');
-    scheduler.stop();
-    assert.equal(activeCount(), 0, 'timer should be cleared after stop');
-});
-test('DecisionsSyncScheduler: stop is idempotent', () => {
-    const { setIntervalImpl, clearIntervalImpl, activeCount } = makeFakeInterval();
-    const scheduler = new DecisionsSyncScheduler({
-        intervalMs: 60_000,
-        getRegisteredProjectRoots: () => [],
-        syncFn: async () => null,
-        setIntervalImpl: setIntervalImpl,
-        clearIntervalImpl: clearIntervalImpl,
-    });
-    scheduler.start();
-    scheduler.stop();
-    scheduler.stop(); // second stop should not throw
-    assert.equal(activeCount(), 0, 'timer count still 0 after double stop');
-});
-test('DecisionsSyncScheduler: tick skips sync when no projects registered', async () => {
-    let syncCount = 0;
-    const scheduler = new DecisionsSyncScheduler({
-        intervalMs: 60_000,
-        getRegisteredProjectRoots: () => [],
-        syncFn: async () => { syncCount++; return null; },
-        setIntervalImpl: setInterval,
-        clearIntervalImpl: clearInterval,
-    });
-    await scheduler.tick();
-    assert.equal(syncCount, 0, 'should not call syncFn when there are no registered projects');
-});
-test('DecisionsSyncScheduler: tick is resilient — continues after syncFn throws', async () => {
-    const synced = [];
-    const scheduler = new DecisionsSyncScheduler({
-        intervalMs: 60_000,
-        getRegisteredProjectRoots: () => ['/project/throws', '/project/ok'],
-        syncFn: async (root) => {
-            if (root === '/project/throws')
-                throw new Error('boom');
-            synced.push(root);
-            return { entriesSynced: 1, wikiPath: 'pages/ok.md' };
-        },
-        setIntervalImpl: setInterval,
-        clearIntervalImpl: clearInterval,
-    });
-    await scheduler.tick();
-    assert.deepEqual(synced, ['/project/ok'], 'should continue syncing after an error in one project');
-});
-test('DecisionsSyncScheduler: start is idempotent — only one timer registered', () => {
-    const { setIntervalImpl, clearIntervalImpl, activeCount } = makeFakeInterval();
-    const scheduler = new DecisionsSyncScheduler({
-        intervalMs: 60_000,
-        getRegisteredProjectRoots: () => [],
-        syncFn: async () => null,
-        setIntervalImpl: setIntervalImpl,
-        clearIntervalImpl: clearIntervalImpl,
-    });
-    scheduler.start();
-    scheduler.start(); // second start should be a no-op
-    assert.equal(activeCount(), 1, 'only one timer should be registered after double start');
-    scheduler.stop();
-});
-test('DecisionsSyncScheduler: reads interval from CHAPTERHOUSE_DECISIONS_SYNC_INTERVAL_MS env var', () => {
-    const original = process.env.CHAPTERHOUSE_DECISIONS_SYNC_INTERVAL_MS;
-    process.env.CHAPTERHOUSE_DECISIONS_SYNC_INTERVAL_MS = '12345';
-    try {
-        const intervals = [];
-        const scheduler = new DecisionsSyncScheduler({
-            getRegisteredProjectRoots: () => [],
-            syncFn: async () => null,
-            setIntervalImpl: ((_cb, ms) => {
-                intervals.push(ms);
-                return { id: 99, unref: () => { } };
-            }),
-            clearIntervalImpl: (_h) => { },
-        });
-        scheduler.start();
-        assert.equal(intervals[0], 12345, 'should use env var value for interval');
-        scheduler.stop();
-    }
-    finally {
-        if (original === undefined) {
-            delete process.env.CHAPTERHOUSE_DECISIONS_SYNC_INTERVAL_MS;
-        }
-        else {
-            process.env.CHAPTERHOUSE_DECISIONS_SYNC_INTERVAL_MS = original;
-        }
-    }
-});
-//# sourceMappingURL=mirror.scheduler.test.js.map

package/dist/squad/mirror.test.js

@@ -1,172 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import { join, basename } from "node:path";
-import test from "node:test";
-const repoRoot = process.cwd();
-const sandboxRoot = join(repoRoot, ".test-work", `squad-mirror-${process.pid}`);
-// Point CHAPTERHOUSE_HOME at sandbox so wiki writes land in an isolated location
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-const mockProjectPath = join(repoRoot, "src/test/fixtures/mock-squad-repo");
-const mockLink = {
-    taskId: "task-001",
-    projectRoot: mockProjectPath,
-    squadAgentSlug: "ripley",
-    wikiDecisionPath: `pages/projects/${basename(mockProjectPath).toLowerCase().replace(/[^a-z0-9-]/g, "-")}/decisions.md`,
-};
-async function loadMirror() {
-    return await import(new URL(`./mirror.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-test.before(() => {
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    mkdirSync(join(sandboxRoot, ".chapterhouse"), { recursive: true });
-});
-test.after(() => {
-    rmSync(sandboxRoot, { recursive: true, force: true });
-});
-test("projectDecisionWikiPath returns path matching pages/projects/{basename}/decisions.md", async () => {
-    const m = await loadMirror();
-    assert.equal(typeof m.projectDecisionWikiPath, "function", "projectDecisionWikiPath should be exported");
-    const projectRoot = "/home/user/my-cool-project";
-    const result = m.projectDecisionWikiPath(projectRoot);
-    const expectedBasename = basename(projectRoot).toLowerCase().replace(/[^a-z0-9-]/g, "-");
-    assert.ok(typeof result === "string" && result.startsWith("pages/projects/"), `expected path to start with 'pages/projects/', got: ${result}`);
-    assert.ok(result.includes(expectedBasename), `expected path to include project basename '${expectedBasename}', got: ${result}`);
-    assert.ok(result.endsWith("decisions.md"), `expected path to end with 'decisions.md', got: ${result}`);
-});
-test("mirrorDecisionToWiki creates a wiki page if it doesn't exist", async () => {
-    const m = await loadMirror();
-    assert.equal(typeof m.mirrorDecisionToWiki, "function", "mirrorDecisionToWiki should be exported");
-    // Clean state for this test
-    rmSync(sandboxRoot, { recursive: true, force: true });
-    mkdirSync(join(sandboxRoot, ".chapterhouse"), { recursive: true });
-    const wikiPath = await m.mirrorDecisionToWiki(mockLink, "Designed module layout", "Adopted layered architecture");
-    assert.ok(typeof wikiPath === "string" && wikiPath.length > 0, "should return a wiki path");
-    const wikiDir = join(sandboxRoot, ".chapterhouse", "wiki");
-    const fullPath = join(wikiDir, ...wikiPath.split("/"));
-    assert.ok(existsSync(fullPath), `wiki page should exist at ${fullPath}`);
-});
-test("mirrorDecisionToWiki appends to an existing wiki page", async () => {
-    const m = await loadMirror();
-    await m.mirrorDecisionToWiki(mockLink, "First decision", "First result");
-    const dallasLink = { ...mockLink, taskId: "task-002", squadAgentSlug: "dallas" };
-    await m.mirrorDecisionToWiki(dallasLink, "Second decision", "Second result");
-    const wikiPath = m.projectDecisionWikiPath(mockProjectPath);
-    const wikiDir = join(sandboxRoot, ".chapterhouse", "wiki");
-    const fullPath = join(wikiDir, ...wikiPath.split("/"));
-    assert.ok(existsSync(fullPath), `wiki page should exist at ${fullPath}`);
-    const content = readFileSync(fullPath, "utf-8");
-    assert.ok(content.includes("First decision"), "first entry should be present after append");
-    assert.ok(content.includes("Second decision"), "second entry should be present after append");
-});
-test("appended entry includes agent slug, task summary, and result summary", async () => {
-    const m = await loadMirror();
-    const dallasLink = { ...mockLink, taskId: "task-003", squadAgentSlug: "dallas" };
-    await m.mirrorDecisionToWiki(dallasLink, "API design task", "Chose REST over GraphQL");
-    const wikiPath = m.projectDecisionWikiPath(mockProjectPath);
-    const wikiDir = join(sandboxRoot, ".chapterhouse", "wiki");
-    const fullPath = join(wikiDir, ...wikiPath.split("/"));
-    const content = readFileSync(fullPath, "utf-8");
-    assert.ok(content.includes("dallas"), "entry should include agent slug 'dallas'");
-    assert.ok(content.includes("API design task"), "entry should include task summary");
-    assert.ok(content.includes("Chose REST over GraphQL"), "entry should include result summary");
-});
-test("mirrorDecisionToWiki returns the wiki page path", async () => {
-    const m = await loadMirror();
-    const returned = await m.mirrorDecisionToWiki({ ...mockLink, taskId: "task-final" }, "Final check", "All good");
-    const expected = m.projectDecisionWikiPath(mockProjectPath);
-    assert.equal(returned, expected, "mirrorDecisionToWiki should return the wiki page path");
-});
-// ---------------------------------------------------------------------------
-// syncDecisionsFileToWiki tests
-// ---------------------------------------------------------------------------
-async function loadMirrorFresh() {
-    return await import(new URL(`./mirror.js?fresh=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-test("syncDecisionsFileToWiki returns null when decisions.md does not exist", async () => {
-    const m = await loadMirrorFresh();
-    const sync = m.syncDecisionsFileToWiki;
-    const result = await sync("/nonexistent/path/that/does/not/exist");
-    assert.equal(result, null, "should return null for missing decisions.md");
-});
-test("syncDecisionsFileToWiki writes decisions.md content to the wiki page", async () => {
-    const m = await loadMirrorFresh();
-    const sync = m.syncDecisionsFileToWiki;
-    const projectDecisionWikiPath = m.projectDecisionWikiPath;
-    // Set up a temp project with a .squad/decisions.md
-    const projectDir = join(repoRoot, ".test-work", `sync-test-${process.pid}-1`);
-    const squadDir = join(projectDir, ".squad");
-    mkdirSync(squadDir, { recursive: true });
-    const decisionsContent = `# Squad Decisions\n\n## Decision 1\nUse TypeScript.\n\n## Decision 2\nUse SQLite.\n`;
-    const { writeFileSync } = await import("node:fs");
-    writeFileSync(join(squadDir, "decisions.md"), decisionsContent, "utf-8");
-    try {
-        const result = await sync(projectDir);
-        assert.ok(result !== null, "should return a result object, not null");
-        assert.equal(result.entriesSynced, 2, "should count 2 second-level headings");
-        const wikiDir = join(sandboxRoot, ".chapterhouse", "wiki");
-        const wikiPath = projectDecisionWikiPath(projectDir);
-        const fullPath = join(wikiDir, ...wikiPath.split("/"));
-        assert.ok(existsSync(fullPath), `wiki page should exist at ${fullPath}`);
-        const written = readFileSync(fullPath, "utf-8");
-        assert.ok(written.includes("Use TypeScript"), "wiki page should contain decisions content");
-        assert.ok(written.includes("Use SQLite"), "wiki page should contain second decision");
-        assert.ok(written.includes("Last synced:"), "wiki page should include sync timestamp header");
-    }
-    finally {
-        rmSync(projectDir, { recursive: true, force: true });
-    }
-});
-test("syncDecisionsFileToWiki overwrites (not appends) on re-run with updated content", async () => {
-    const m = await loadMirrorFresh();
-    const sync = m.syncDecisionsFileToWiki;
-    const projectDecisionWikiPath = m.projectDecisionWikiPath;
-    const projectDir = join(repoRoot, ".test-work", `sync-test-${process.pid}-2`);
-    const squadDir = join(projectDir, ".squad");
-    mkdirSync(squadDir, { recursive: true });
-    const { writeFileSync } = await import("node:fs");
-    const decisionsFile = join(squadDir, "decisions.md");
-    // First sync
-    writeFileSync(decisionsFile, "## Original decision\nContent A.\n", "utf-8");
-    await sync(projectDir);
-    // Update and re-sync
-    writeFileSync(decisionsFile, "## Updated decision\nContent B.\n", "utf-8");
-    await sync(projectDir);
-    try {
-        const wikiDir = join(sandboxRoot, ".chapterhouse", "wiki");
-        const wikiPath = projectDecisionWikiPath(projectDir);
-        const fullPath = join(wikiDir, ...wikiPath.split("/"));
-        const written = readFileSync(fullPath, "utf-8");
-        assert.ok(written.includes("Content B"), "wiki should contain updated content after re-sync");
-        assert.ok(!written.includes("Content A"), "wiki should NOT contain old content after overwrite");
-    }
-    finally {
-        rmSync(projectDir, { recursive: true, force: true });
-    }
-});
-test("checkDecisionsInbox returns 0 and empty array when inbox is absent", async () => {
-    const m = await loadMirrorFresh();
-    const checkInbox = m.checkDecisionsInbox;
-    const result = await checkInbox("/nonexistent/project/path");
-    assert.equal(result.count, 0, "count should be 0 for missing inbox");
-    assert.deepEqual(result.files, [], "files should be empty array for missing inbox");
-});
-test("checkDecisionsInbox returns files in inbox", async () => {
-    const m = await loadMirrorFresh();
-    const checkInbox = m.checkDecisionsInbox;
-    const projectDir = join(repoRoot, ".test-work", `inbox-test-${process.pid}`);
-    const inboxDir = join(projectDir, ".squad", "decisions", "inbox");
-    mkdirSync(inboxDir, { recursive: true });
-    const { writeFileSync } = await import("node:fs");
-    writeFileSync(join(inboxDir, "drop-one.md"), "# Drop", "utf-8");
-    writeFileSync(join(inboxDir, "drop-two.md"), "# Drop", "utf-8");
-    try {
-        const result = await checkInbox(projectDir);
-        assert.equal(result.count, 2, "should count 2 inbox files");
-        assert.ok(result.files.includes("drop-one.md"), "should list drop-one.md");
-        assert.ok(result.files.includes("drop-two.md"), "should list drop-two.md");
-    }
-    finally {
-        rmSync(projectDir, { recursive: true, force: true });
-    }
-});
-//# sourceMappingURL=mirror.test.js.map

package/dist/squad/registry.js

@@ -1,162 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { getDb } from '../store/db.js';
-import { loadProjectSquad } from './discovery.js';
-function extractRoleFromCharter(content) {
-    const roleMatch = content.match(/\*\*Role:\*\*\s*(.+)/);
-    if (roleMatch)
-        return roleMatch[1].trim();
-    const headingMatch = content.match(/^#\s+.+?—\s*(.+)/m);
-    if (headingMatch)
-        return headingMatch[1].trim();
-    const h2Match = content.match(/^##\s+(.+)/m);
-    if (h2Match)
-        return h2Match[1].trim();
-    return 'Agent';
-}
-function extractDescriptionFromCharter(content) {
-    const blockquoteMatch = content.match(/^#[^\n]*\n+>\s*(.+)/m);
-    if (blockquoteMatch)
-        return blockquoteMatch[1].trim();
-    const lines = content.split('\n');
-    let pastHeading = false;
-    for (const line of lines) {
-        if (!pastHeading && line.startsWith('#')) {
-            pastHeading = true;
-            continue;
-        }
-        if (pastHeading && line.trim() && !line.startsWith('#') && !line.startsWith('>')) {
-            return line.trim();
-        }
-    }
-    return undefined;
-}
-function loadProjectSquadSync(projectRoot) {
-    const squadDir = join(projectRoot, '.squad');
-    if (!existsSync(squadDir)) {
-        return null;
-    }
-    const agentsDir = join(squadDir, 'agents');
-    const agents = [];
-    if (existsSync(agentsDir)) {
-        for (const entry of readdirSync(agentsDir)) {
-            const agentDir = join(agentsDir, entry);
-            try {
-                if (!statSync(agentDir).isDirectory())
-                    continue;
-            }
-            catch {
-                continue;
-            }
-            const charterPath = join(agentDir, 'charter.md');
-            if (!existsSync(charterPath))
-                continue;
-            let charterContent = '';
-            try {
-                charterContent = readFileSync(charterPath, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            agents.push({
-                slug: entry,
-                mention: `@${entry}`,
-                role: extractRoleFromCharter(charterContent),
-                description: extractDescriptionFromCharter(charterContent),
-                charterPath,
-                origin: 'project-squad',
-            });
-        }
-    }
-    return {
-        projectRoot,
-        squadDir,
-        teamDir: squadDir,
-        personalDir: null,
-        mode: 'local',
-        projectKey: null,
-        config: {},
-        agents,
-        decisionsPath: join(squadDir, 'decisions.md'),
-        routingPath: existsSync(join(squadDir, 'routing.md')) ? join(squadDir, 'routing.md') : undefined,
-        loadedAt: new Date().toISOString(),
-    };
-}
-export function getProjectSquad(projectRoot) {
-    return loadProjectSquadSync(projectRoot);
-}
-export function listProjectSquadAgents(projectRoot) {
-    return getProjectSquad(projectRoot)?.agents ?? [];
-}
-export function findSquadAgent(projectRoot, mention) {
-    const agents = listProjectSquadAgents(projectRoot);
-    const slug = mention.replace(/^@/, '').toLowerCase();
-    const normalised = `@${slug}`;
-    return agents.find((a) => a.mention.toLowerCase() === normalised || a.slug.toLowerCase() === slug) ?? null;
-}
-export function renderProjectAgentRoster(projectRoot) {
-    const agents = listProjectSquadAgents(projectRoot);
-    if (agents.length === 0)
-        return '';
-    return agents
-        .map((agent) => `- **${agent.mention}** — ${agent.role}${agent.description ? ` — ${agent.description}` : ''}`)
-        .join('\n');
-}
-export async function registerProject(projectRoot) {
-    try {
-        const db = getDb();
-        // Ensure the row exists before marking registered
-        const row = db.prepare(`SELECT project_root FROM project_squads WHERE project_root = ?`)
-            .get(projectRoot);
-        if (!row) {
-            // Load first so the row is created
-            const ctx = await loadProjectSquad(projectRoot);
-            if (!ctx)
-                return false;
-        }
-        db.prepare(`UPDATE project_squads SET registered = 1 WHERE project_root = ?`).run(projectRoot);
-        // Refresh cache
-        await loadProjectSquad(projectRoot);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function unregisterProject(projectRoot) {
-    try {
-        const db = getDb();
-        db.prepare(`DELETE FROM squad_agents WHERE project_root = ?`).run(projectRoot);
-        db.prepare(`DELETE FROM project_squads WHERE project_root = ?`).run(projectRoot);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function listRegisteredProjects() {
-    try {
-        const db = getDb();
-        const rows = db.prepare(`
-      SELECT
-        ps.project_root,
-        ps.squad_dir,
-        ps.loaded_at,
-        COUNT(sa.slug) as agent_count
-      FROM project_squads ps
-      LEFT JOIN squad_agents sa ON sa.project_root = ps.project_root
-      WHERE ps.registered = 1
-      GROUP BY ps.project_root
-    `).all();
-        return rows.map(r => ({
-            projectRoot: r.project_root,
-            squadDir: r.squad_dir,
-            agentCount: r.agent_count,
-            loadedAt: r.loaded_at,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-//# sourceMappingURL=registry.js.map

package/dist/squad/registry.test.js

@@ -1,31 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import test from "node:test";
-const repoRoot = process.cwd();
-const fixtureRoot = join(repoRoot, "src/test/fixtures/mock-squad-repo");
-const sandboxRoot = join(repoRoot, ".test-work", `squad-registry-${process.pid}`);
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-async function loadRegistry() {
-    return await import(new URL(`./registry.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-test.before(() => {
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    mkdirSync(join(sandboxRoot, ".chapterhouse"), { recursive: true });
-});
-test.after(() => {
-    rmSync(sandboxRoot, { recursive: true, force: true });
-});
-test("findSquadAgent returns a fixture agent descriptor synchronously", async () => {
-    const m = await loadRegistry();
-    const result = m.findSquadAgent(fixtureRoot, "ripley");
-    assert.equal(result?.slug, "ripley");
-    assert.equal(result?.mention, "@ripley");
-});
-test("renderProjectAgentRoster returns squad roster lines synchronously", async () => {
-    const m = await loadRegistry();
-    const roster = m.renderProjectAgentRoster(fixtureRoot);
-    assert.match(roster, /@ripley/);
-    assert.match(roster, /@dallas/);
-});
-//# sourceMappingURL=registry.test.js.map