chapterhouse 0.1.1

package/dist/squad/index.js

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './discovery.js';
+export * from './registry.js';
+export * from './context.js';
+export * from './charter.js';
+export * from './mirror.js';
+//# sourceMappingURL=index.js.map

package/dist/squad/mirror.js

@@ -0,0 +1,81 @@
+import { basename, join } from 'path';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { readPage, writePage } from '../wiki/fs.js';
+import { ensureWikiStructure } from '../wiki/fs.js';
+/**
+ * Returns the wiki-relative path for a project's squad decisions page.
+ * e.g. "pages/projects/chapterhouse/decisions.md"
+ */
+export function projectDecisionWikiPath(projectRoot) {
+    const slug = basename(projectRoot).toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    return `pages/projects/${slug}/decisions.md`;
+}
+/**
+ * Append a decision entry to the project's wiki decisions page.
+ * Returns the wiki page path that was written.
+ *
+ * Only call this on successful task completion — the caller is responsible for
+ * not invoking on failure.
+ */
+export async function mirrorDecisionToWiki(link, taskSummary, resultSummary) {
+    ensureWikiStructure();
+    const wikiPath = projectDecisionWikiPath(link.projectRoot);
+    const dateStr = new Date().toISOString().slice(0, 10);
+    const existing = readPage(wikiPath) ?? `# Squad Decisions — ${basename(link.projectRoot)}\n\n`;
+    const entry = `## ${dateStr}\n- **Agent:** @${link.squadAgentSlug} | **Task:** ${taskSummary} | **Result:** ${resultSummary}\n`;
+    // Append entry, ensuring a blank line separator
+    const separator = existing.endsWith('\n\n') ? '' : existing.endsWith('\n') ? '\n' : '\n\n';
+    const updated = existing + separator + entry;
+    writePage(wikiPath, updated);
+    return wikiPath;
+}
+/**
+ * Check the decisions inbox for unmerged decision drops.
+ * Returns count and filenames — never throws.
+ */
+export async function checkDecisionsInbox(projectRoot) {
+    const inboxPath = join(projectRoot, '.squad', 'decisions', 'inbox');
+    try {
+        if (!existsSync(inboxPath))
+            return { count: 0, files: [] };
+        const files = readdirSync(inboxPath).filter(f => f.endsWith('.md'));
+        return { count: files.length, files };
+    }
+    catch {
+        return { count: 0, files: [] };
+    }
+}
+/**
+ * Sync the content of <projectRoot>/.squad/decisions.md verbatim to the
+ * project's wiki decisions page.  decisions.md is the source of truth — the
+ * wiki page is overwritten on every call.
+ *
+ * Returns null when decisions.md does not exist (project may not be squad-
+ * initialized); never throws — errors are logged and the caller is unaffected.
+ */
+export async function syncDecisionsFileToWiki(projectRoot) {
+    const decisionsPath = join(projectRoot, '.squad', 'decisions.md');
+    try {
+        if (!existsSync(decisionsPath))
+            return null;
+        const source = readFileSync(decisionsPath, 'utf-8');
+        ensureWikiStructure();
+        const wikiPath = projectDecisionWikiPath(projectRoot);
+        const timestamp = new Date().toISOString();
+        const header = `<!-- Last synced: ${timestamp} -->\n\n`;
+        writePage(wikiPath, header + source);
+        // Count entries as second-level headings (## …) in the decisions file
+        const entriesSynced = (source.match(/^##\s/gm) ?? []).length;
+        // Visibility check: warn if inbox has unmerged drops
+        const inbox = await checkDecisionsInbox(projectRoot);
+        if (inbox.count > 0) {
+            console.warn(`[squad] Project at ${projectRoot} has ${inbox.count} unmerged decision drops in inbox: ${inbox.files.join(', ')}. Run Scribe to merge.`);
+        }
+        return { entriesSynced, wikiPath };
+    }
+    catch (err) {
+        console.error('[squad] syncDecisionsFileToWiki failed (non-fatal):', err instanceof Error ? err.message : err);
+        return null;
+    }
+}
+//# sourceMappingURL=mirror.js.map

package/dist/squad/mirror.scheduler.js

@@ -0,0 +1,78 @@
+import { getDb } from '../store/db.js';
+import { syncDecisionsFileToWiki } from './mirror.js';
+export const DEFAULT_DECISIONS_SYNC_INTERVAL_MS = 300_000; // 5 minutes
+function readIntervalFromEnv() {
+    const raw = process.env.CHAPTERHOUSE_DECISIONS_SYNC_INTERVAL_MS;
+    if (raw === undefined)
+        return DEFAULT_DECISIONS_SYNC_INTERVAL_MS;
+    const parsed = Number(raw);
+    return isNaN(parsed) ? DEFAULT_DECISIONS_SYNC_INTERVAL_MS : parsed;
+}
+function defaultGetRegisteredProjectRoots() {
+    try {
+        const db = getDb();
+        const rows = db
+            .prepare(`SELECT project_root FROM project_squads WHERE registered = 1`)
+            .all();
+        return rows.map(r => r.project_root);
+    }
+    catch (err) {
+        console.error('[squad] DecisionsSyncScheduler: failed to query registered projects (non-fatal):', err instanceof Error ? err.message : err);
+        return [];
+    }
+}
+export class DecisionsSyncScheduler {
+    intervalMs;
+    getRegisteredProjectRoots;
+    syncFn;
+    setIntervalImpl;
+    clearIntervalImpl;
+    handle;
+    constructor(options = {}) {
+        this.intervalMs = options.intervalMs ?? readIntervalFromEnv();
+        this.getRegisteredProjectRoots = options.getRegisteredProjectRoots ?? defaultGetRegisteredProjectRoots;
+        this.syncFn = options.syncFn ?? syncDecisionsFileToWiki;
+        this.setIntervalImpl = options.setIntervalImpl ?? setInterval;
+        this.clearIntervalImpl = options.clearIntervalImpl ?? clearInterval;
+    }
+    /** Start the periodic sync. No-op if intervalMs <= 0. */
+    start() {
+        if (this.intervalMs <= 0) {
+            console.log('[squad] DecisionsSyncScheduler: disabled (intervalMs <= 0)');
+            return;
+        }
+        if (this.handle !== undefined)
+            return; // already running
+        console.log(`[squad] DecisionsSyncScheduler: starting, interval=${this.intervalMs}ms`);
+        this.handle = this.setIntervalImpl(() => { void this.tick(); }, this.intervalMs);
+        // Allow Node.js to exit even if the interval is still active
+        this.handle?.unref?.();
+    }
+    /** Stop the periodic sync and clear the timer. */
+    stop() {
+        if (this.handle !== undefined) {
+            this.clearIntervalImpl(this.handle);
+            this.handle = undefined;
+            console.log('[squad] DecisionsSyncScheduler: stopped');
+        }
+    }
+    async tick() {
+        const projects = this.getRegisteredProjectRoots();
+        if (projects.length === 0)
+            return;
+        console.log(`[squad] DecisionsSyncScheduler: syncing ${projects.length} project(s)`);
+        for (const root of projects) {
+            try {
+                const result = await this.syncFn(root);
+                if (result) {
+                    console.log(`[squad] DecisionsSyncScheduler: synced ${result.entriesSynced} entries for ${root}`);
+                }
+            }
+            catch (err) {
+                // syncDecisionsFileToWiki already swallows errors; belt-and-suspenders here
+                console.error(`[squad] DecisionsSyncScheduler: unexpected error for ${root}:`, err instanceof Error ? err.message : err);
+            }
+        }
+    }
+}
+//# sourceMappingURL=mirror.scheduler.js.map

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

@@ -0,0 +1,197 @@
+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

@@ -0,0 +1,172 @@
+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