chapterhouse 0.1.1

package/dist/copilot/tools.okr.test.js

@@ -0,0 +1,260 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+async function loadToolsModule() {
+    try {
+        return await import(new URL(`./tools.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    }
+    catch {
+        return null;
+    }
+}
+test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = mkdtempSync(join(tmpdir(), "chapterhouse-tools-okr-"));
+});
+test.afterEach(async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    if (home) {
+        const dbModule = await import("../store/db.js");
+        dbModule.closeDb();
+        rmSync(home, { recursive: true, force: true });
+    }
+});
+test("createTools registers OKR progress tools", async () => {
+    const toolsModule = await loadToolsModule();
+    assert.ok(toolsModule, "tools module should exist");
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    assert.ok(tools.some((tool) => tool.name === "log_okr_progress"));
+    assert.ok(tools.some((tool) => tool.name === "get_my_okrs"));
+    assert.ok(tools.some((tool) => tool.name === "write_team_wiki"));
+});
+test("log_okr_progress suggests a KR when the user did not specify one", async () => {
+    const toolsModule = await loadToolsModule();
+    assert.ok(toolsModule, "tools module should exist");
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+        createTeamPushClient: () => ({
+            async pushUpdate() {
+                throw new Error("should not push before confirmation");
+            },
+            async fetchOKRs() {
+                return "";
+            },
+            async writePage() {
+                throw new Error("should not write team wiki in this test");
+            },
+        }),
+        createOKRMapper: () => ({
+            async findMatchingKRs() {
+                return [
+                    {
+                        krId: "O1-KR2",
+                        title: "Reduce auth service latency",
+                        objectiveTitle: "Improve auth platform reliability",
+                        confidence: "high",
+                    },
+                ];
+            },
+            formatUpdatePrompt() {
+                return "Suggested prompt";
+            },
+            recordConfirmedMapping() {
+                throw new Error("should not record a mapping before confirmation");
+            },
+        }),
+        getCurrentUser: () => ({
+            id: "eng-1",
+            name: "Ada Lovelace",
+            email: "ada@example.com",
+            role: "engineer",
+        }),
+    });
+    const result = await tools.find((tool) => tool.name === "log_okr_progress")?.handler({
+        activity: "merged auth refactor PR",
+    });
+    assert.equal(result, "Suggested prompt");
+});
+test("log_okr_progress records a confirmed mapping after a successful push", async () => {
+    const toolsModule = await loadToolsModule();
+    assert.ok(toolsModule, "tools module should exist");
+    let recorded;
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+        createTeamPushClient: () => ({
+            async pushUpdate() {
+                return {
+                    ok: true,
+                    entry: { delta: 5 },
+                };
+            },
+            async fetchOKRs() {
+                return "";
+            },
+            async writePage() {
+                throw new Error("should not write team wiki in this test");
+            },
+        }),
+        createOKRMapper: () => ({
+            async findMatchingKRs() {
+                return [];
+            },
+            formatUpdatePrompt() {
+                return "";
+            },
+            recordConfirmedMapping(activity, krId) {
+                recorded = { activity, krId };
+            },
+        }),
+        getCurrentUser: () => ({
+            id: "eng-1",
+            name: "Ada Lovelace",
+            email: "ada@example.com",
+            role: "engineer",
+        }),
+    });
+    const result = await tools.find((tool) => tool.name === "log_okr_progress")?.handler({
+        activity: "merged auth refactor PR",
+        krId: "O1-KR1",
+        delta: 5,
+    });
+    assert.equal(result, "Logged OKR progress for O1-KR1 (5% logged).");
+    assert.deepEqual(recorded, {
+        activity: "merged auth refactor PR",
+        krId: "O1-KR1",
+    });
+});
+test("get_my_okrs returns KRs owned by the current user", async () => {
+    const toolsModule = await loadToolsModule();
+    assert.ok(toolsModule, "tools module should exist");
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+        createTeamPushClient: () => ({
+            async pushUpdate() {
+                throw new Error("not used in this test");
+            },
+            async fetchOKRs() {
+                return `# OKRs — 2026 Q2
+
+## O1: Improve auth platform reliability
+**Owner**: Team Lead
+
+### O1-KR1: Reduce auth service latency
+- **Owner**: Ada Lovelace
+- **Target**: 100%
+- **Current**: 40%
+- **Unit**: %
+- **Due**: 2026-06-30
+
+### O1-KR2: Migrate legacy auth flows
+- **Owner**: Grace Hopper
+- **Target**: 100%
+- **Current**: 60%
+- **Unit**: %
+- **Due**: 2026-06-30
+        `;
+            },
+            async writePage() {
+                throw new Error("not used in this test");
+            },
+        }),
+        getCurrentUser: () => ({
+            id: "eng-1",
+            name: "Ada Lovelace",
+            email: "ada@example.com",
+            role: "engineer",
+        }),
+    });
+    const result = await tools.find((tool) => tool.name === "get_my_okrs")?.handler({ period: "2026-Q2" });
+    assert.match(result, /O1-KR1: Reduce auth service latency/);
+    assert.doesNotMatch(result, /O1-KR2: Migrate legacy auth flows/);
+});
+test("write_team_wiki writes shared wiki pages through the team push client", async () => {
+    const toolsModule = await loadToolsModule();
+    assert.ok(toolsModule, "tools module should exist");
+    const writes = [];
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+        createTeamPushClient: () => ({
+            async pushUpdate() {
+                throw new Error("not used in this test");
+            },
+            async fetchOKRs() {
+                throw new Error("not used in this test");
+            },
+            async writePage(path, content) {
+                writes.push({ path, content });
+                return { ok: true, path };
+            },
+        }),
+    });
+    const result = await tools.find((tool) => tool.name === "write_team_wiki")?.handler({
+        path: "pages/shared/runbooks/deploy.md",
+        content: "# Deploy Runbook\n",
+    });
+    assert.equal(result, "Wrote shared team wiki page: pages/shared/runbooks/deploy.md");
+    assert.deepEqual(writes, [{
+            path: "pages/shared/runbooks/deploy.md",
+            content: "# Deploy Runbook\n",
+        }]);
+});
+test("write_team_wiki rejects paths outside pages/shared", async () => {
+    const toolsModule = await loadToolsModule();
+    assert.ok(toolsModule, "tools module should exist");
+    let writeAttempts = 0;
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+        createTeamPushClient: () => ({
+            async pushUpdate() {
+                throw new Error("not used in this test");
+            },
+            async fetchOKRs() {
+                throw new Error("not used in this test");
+            },
+            async writePage() {
+                writeAttempts += 1;
+                return { ok: true, path: "pages/team/index.md" };
+            },
+        }),
+    });
+    const result = await tools.find((tool) => tool.name === "write_team_wiki")?.handler({
+        path: "pages/team/index.md",
+        content: "# Team Directory\n",
+    });
+    assert.match(result, /must start with "pages\/shared\/"/i);
+    assert.equal(writeAttempts, 0);
+});
+test("generate_okr_report is available with ADO_PAT and returns the generated narrative", async () => {
+    process.env.ADO_PAT = "test-pat";
+    try {
+        const toolsModule = await loadToolsModule();
+        assert.ok(toolsModule, "tools module should exist");
+        const tools = toolsModule.createTools({
+            client: { async listModels() { return []; } },
+            onAgentTaskComplete: () => { },
+            createReportGenerator: () => ({
+                async generateMonthlyReport(period) {
+                    assert.equal(period, "2026-Q2");
+                    return "Executive summary goes here.";
+                },
+            }),
+        });
+        const tool = tools.find((entry) => entry.name === "generate_okr_report");
+        assert.ok(tool, "generate_okr_report should be registered");
+        const result = await tool.handler({ period: "2026-Q2" });
+        assert.equal(result, "Executive summary goes here.");
+    }
+    finally {
+        delete process.env.ADO_PAT;
+    }
+});
+//# sourceMappingURL=tools.okr.test.js.map

package/dist/copilot/tools.squad.test.js

@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+const fixtureProjectRoot = `${process.cwd()}/src/test/fixtures/mock-squad-repo`;
+async function loadToolsModule(t, state) {
+    const fakeSession = {
+        on() {
+            return () => { };
+        },
+        async sendAndWait() {
+            return { data: { content: "Squad result" } };
+        },
+        async destroy() { },
+    };
+    t.mock.module("../config.js", {
+        namedExports: {
+            config: {
+                workerTimeoutMs: 1_000,
+                chapterhouseMode: "personal",
+                adoPat: "",
+                squadEnabled: true,
+                copilotModel: "claude-sonnet-4.6",
+            },
+            persistModel: () => { },
+        },
+    });
+    t.mock.module("./orchestrator.js", {
+        namedExports: {
+            getCurrentSourceChannel: () => "web",
+            getCurrentActivityCallback: () => undefined,
+            getCurrentAuthenticatedUser: () => undefined,
+            getLastAuthenticatedUser: () => undefined,
+            getCurrentAuthorizationHeader: () => undefined,
+            getCurrentChannelKey: () => "conn-squad",
+            getCurrentSessionKey: () => "default",
+            switchSessionModel: async () => { },
+        },
+    });
+    t.mock.module("./agents.js", {
+        namedExports: {
+            getAgentRegistry: () => [{ slug: "coder" }, { slug: "designer" }],
+            getAgent: () => undefined,
+            createEphemeralAgentSession: async () => {
+                throw new Error("should not create a Chapterhouse registry agent session");
+            },
+            createSquadAgentSession: async (slug, _client, allTools, systemMessagePrefix, modelOverride) => {
+                state.createSquadSessionCalls.push({
+                    slug,
+                    toolNames: allTools.map((tool) => tool.name),
+                    systemMessagePrefix,
+                    modelOverride,
+                });
+                return fakeSession;
+            },
+            getAgentSessionStatus: () => ({ taskCount: 0, tasks: [] }),
+            getActiveTasks: () => [],
+            getTask: () => undefined,
+            registerTask: (agentSlug, description, originChannel) => ({
+                taskId: "task-squad-1",
+                agentSlug,
+                description,
+                status: "running",
+                startedAt: Date.now(),
+                originChannel,
+            }),
+            completeTask: () => { },
+            failTask: () => { },
+            createAgentFile: () => null,
+            removeAgentFile: () => null,
+            loadAgents: () => [],
+        },
+    });
+    t.mock.module("../squad/context.js", {
+        namedExports: {
+            getChannelProject: () => fixtureProjectRoot,
+        },
+    });
+    t.mock.module("../squad/registry.js", {
+        namedExports: {
+            findSquadAgent: (_projectRoot, mention) => mention === "ripley"
+                ? {
+                    slug: "ripley",
+                    mention: "@ripley",
+                    role: "Lead",
+                    charterPath: `${fixtureProjectRoot}/.squad/agents/ripley/charter.md`,
+                    origin: "project-squad",
+                }
+                : null,
+        },
+    });
+    t.mock.module("../squad/charter.js", {
+        namedExports: {
+            buildSquadSystemPrefix: (context, descriptor) => {
+                state.charterCalls.push({ projectRoot: context.projectRoot, slug: descriptor.slug });
+                return "SQUAD SYSTEM PREFIX";
+            },
+        },
+    });
+    t.mock.module("../squad/mirror.js", {
+        namedExports: {
+            mirrorDecisionToWiki: async (link, taskSummary, resultSummary) => {
+                state.mirrorCalls.push({ link, taskSummary, resultSummary });
+                return "pages/projects/mock-squad-repo/decisions.md";
+            },
+            syncDecisionsFileToWiki: async (_projectRoot) => null,
+        },
+    });
+    t.mock.module("../store/db.js", {
+        namedExports: {
+            getDb: () => ({
+                prepare: (sql) => ({
+                    run: (...args) => {
+                        state.dbWrites.push({ sql, args });
+                        return {};
+                    },
+                    get: () => undefined,
+                    all: () => [],
+                }),
+            }),
+            getState: () => undefined,
+            setState: () => { },
+            logConversation: () => { },
+        },
+    });
+    t.mock.module("../wiki/team-sync.js", {
+        namedExports: {
+            readWikiPage: async () => undefined,
+            teamWikiSync: {
+                isEnabled: () => false,
+                syncAll: async () => { },
+            },
+        },
+    });
+    return await import(new URL(`./tools.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+test("delegate_to_agent routes squad virtual agents with charter injection and mirrors results", async (t) => {
+    const state = {
+        taskCompleteCalls: [],
+        createSquadSessionCalls: [],
+        charterCalls: [],
+        mirrorCalls: [],
+        dbWrites: [],
+    };
+    const toolsModule = await loadToolsModule(t, state);
+    const tools = toolsModule.createTools({
+        client: {},
+        onAgentTaskComplete: (taskId, agentSlug, result) => {
+            state.taskCompleteCalls.push({ taskId, agentSlug, result });
+        },
+    });
+    const delegateTool = tools.find((tool) => tool.name === "delegate_to_agent");
+    assert.ok(delegateTool, "delegate_to_agent should exist");
+    const result = await delegateTool.handler({
+        agent_name: "ripley",
+        task: "Audit the squad routing",
+        summary: "Audit squad routing",
+    }, {});
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.match(String(result), /@ripley/);
+    assert.equal(state.createSquadSessionCalls.length, 1);
+    assert.deepEqual(state.charterCalls, [{ projectRoot: fixtureProjectRoot, slug: "ripley" }]);
+    assert.equal(state.taskCompleteCalls[0]?.result, "Squad result");
+    assert.equal(state.mirrorCalls.length, 1);
+    assert.equal(state.mirrorCalls[0]?.taskSummary, "Audit squad routing");
+    assert.equal(state.mirrorCalls[0]?.resultSummary, "Squad result");
+    assert.ok(state.dbWrites.some((write) => write.sql.includes("INSERT INTO agent_tasks")));
+    assert.ok(state.dbWrites.some((write) => write.sql.includes("squad_task_links")));
+});
+//# sourceMappingURL=tools.squad.test.js.map

package/dist/daemon.js

@@ -0,0 +1,235 @@
+import { getClient, stopClient } from "./copilot/client.js";
+import { initOrchestrator, setMessageLogger, setProactiveNotify, getAgentInfo, shutdownAgents } from "./copilot/orchestrator.js";
+import { stopEpisodeWriter } from "./copilot/episode-writer.js";
+import { startApiServer, broadcastToSSE } from "./api/server.js";
+import { getDb, closeDb, getState } from "./store/db.js";
+import { config } from "./config.js";
+import { spawn } from "child_process";
+import { readdirSync, statSync, rmSync } from "fs";
+import { join } from "path";
+import { checkForUpdate } from "./update.js";
+import { ensureWikiStructure } from "./wiki/fs.js";
+import { seedTeamWiki } from "./wiki/seed-team-wiki.js";
+import { shouldMigrate, migrateMemoriesToWiki, shouldReorganize, reorganizeWiki } from "./wiki/migrate.js";
+import { SESSIONS_DIR } from "./paths.js";
+import { getDisplayHost } from "./api/server-runtime.js";
+import { StandupScheduler } from "./copilot/standup.js";
+import { DecisionsSyncScheduler } from "./squad/mirror.scheduler.js";
+import { registerShutdownSignals } from "./shutdown-signals.js";
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+/** Remove orphaned session folders older than 7 days, preserving the current session. */
+function pruneOldSessions() {
+    try {
+        const sessionStateDir = join(SESSIONS_DIR, "session-state");
+        const currentSessionId = getState("orchestrator_session_id");
+        let entries;
+        try {
+            entries = readdirSync(sessionStateDir);
+        }
+        catch {
+            return; // directory may not exist yet
+        }
+        const cutoff = Date.now() - SEVEN_DAYS_MS;
+        let pruned = 0;
+        for (const entry of entries) {
+            if (entry === currentSessionId)
+                continue;
+            const fullPath = join(sessionStateDir, entry);
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory() && stat.mtimeMs < cutoff) {
+                    rmSync(fullPath, { recursive: true, force: true });
+                    pruned++;
+                }
+            }
+            catch {
+                // skip entries we can't stat or remove
+            }
+        }
+        if (pruned > 0) {
+            console.log(`[chapterhouse] Pruned ${pruned} orphaned session folder(s)`);
+        }
+    }
+    catch (err) {
+        console.error("[chapterhouse] Session pruning failed (non-fatal):", err instanceof Error ? err.message : err);
+    }
+}
+function truncate(text, max = 200) {
+    const oneLine = text.replace(/\n/g, " ").trim();
+    return oneLine.length > max ? oneLine.slice(0, max) + "…" : oneLine;
+}
+async function main() {
+    console.log("[chapterhouse] Starting Chapterhouse daemon...");
+    if (config.selfEditEnabled) {
+        console.log("[chapterhouse] ⚠ Self-edit mode enabled — Chapterhouse can modify his own source code");
+    }
+    // Set up message logging to daemon console
+    setMessageLogger((direction, source, text) => {
+        const arrow = direction === "in" ? "⟶" : "⟵";
+        const tag = source.padEnd(8);
+        console.log(`[chapterhouse] ${tag} ${arrow}  ${truncate(text)}`);
+    });
+    // Initialize SQLite
+    getDb();
+    console.log("[chapterhouse] Database initialized");
+    // Initialize wiki knowledge base
+    const wikiIsNew = ensureWikiStructure();
+    if (wikiIsNew) {
+        console.log("[chapterhouse] Created wiki at ~/.chapterhouse/wiki/");
+    }
+    if (config.chapterhouseMode === "team") {
+        const seed = seedTeamWiki();
+        if (seed.created.length > 0) {
+            console.log(`[chapterhouse] Seeded ${seed.created.length} team wiki page(s): ${seed.created.join(", ")}`);
+        }
+    }
+    if (shouldMigrate()) {
+        console.log("[chapterhouse] Migrating SQLite memories to wiki...");
+        const count = migrateMemoriesToWiki();
+        console.log(`[chapterhouse] Migrated ${count} memories to wiki`);
+    }
+    if (shouldReorganize()) {
+        console.log("[chapterhouse] Reorganizing wiki pages into entity structure...");
+        const count = reorganizeWiki();
+        console.log(`[chapterhouse] Created ${count} entity pages`);
+    }
+    // Prune orphaned session folders older than 7 days
+    pruneOldSessions();
+    // One-time deprecation note for legacy Telegram users (v1 → v2)
+    if (process.env.TELEGRAM_BOT_TOKEN) {
+        console.log("[chapterhouse] ℹ TELEGRAM_BOT_TOKEN found in env — Telegram support was removed in v2. The web UI is now the only client. You can delete this line from ~/.chapterhouse/.env.");
+    }
+    // Start Copilot SDK client
+    console.log("[chapterhouse] Starting Copilot SDK client...");
+    const client = await getClient();
+    console.log("[chapterhouse] Copilot SDK client ready");
+    // Initialize orchestrator session
+    console.log("[chapterhouse] Creating orchestrator session...");
+    await initOrchestrator(client);
+    console.log("[chapterhouse] Orchestrator session ready");
+    // Wire up proactive notifications — broadcast to all connected web clients
+    setProactiveNotify((text) => {
+        console.log(`[chapterhouse] bg-notify ⟵  ${truncate(text)}`);
+        broadcastToSSE(text);
+    });
+    // Start HTTP API + serve the web UI
+    await startApiServer();
+    if (config.chapterhouseMode === "personal" && (config.adoPat || config.teamChapterhouseUrl)) {
+        new StandupScheduler().schedule();
+    }
+    // Start periodic decisions→wiki sync for all registered projects
+    decisionsSyncScheduler = new DecisionsSyncScheduler();
+    decisionsSyncScheduler.start();
+    const url = `http://${getDisplayHost(config.apiHost)}:${config.apiPort}`;
+    console.log(`[chapterhouse] Chapterhouse is fully operational — open ${url} in your browser`);
+    if (process.env.CHAPTERHOUSE_OPEN_BROWSER === "1") {
+        const opener = process.platform === "darwin" ? "open" :
+            process.platform === "win32" ? "explorer.exe" : "xdg-open";
+        try {
+            spawn(opener, [url], { detached: true, stdio: "ignore" }).unref();
+        }
+        catch (err) {
+            console.error(`[chapterhouse] Could not open browser:`, err instanceof Error ? err.message : err);
+        }
+    }
+    // Non-blocking update check
+    checkForUpdate()
+        .then(({ updateAvailable, current, latest }) => {
+        if (updateAvailable) {
+            console.log(`[chapterhouse] ⬆ Update available: v${current} → v${latest}  —  run 'chapterhouse update' to install`);
+        }
+    })
+        .catch(() => { }); // silent — network may be unavailable
+    if (process.env.CHAPTERHOUSE_RESTARTED === "1") {
+        delete process.env.CHAPTERHOUSE_RESTARTED;
+    }
+}
+// Graceful shutdown
+let shutdownState = "idle";
+let decisionsSyncScheduler;
+async function shutdown() {
+    if (shutdownState === "shutting_down") {
+        console.log("\n[chapterhouse] Forced exit.");
+        process.exit(1);
+    }
+    // Check for running workers before shutting down
+    const workers = getAgentInfo();
+    if (workers.length > 0 && shutdownState === "idle") {
+        const names = workers.map(w => `@${w.slug}`).join(", ");
+        console.log(`\n[chapterhouse] ⚠ ${workers.length} running worker(s) will be stopped: ${names}`);
+        console.log("[chapterhouse] Press Ctrl+C again to shut down, or wait for workers to finish.");
+        shutdownState = "warned";
+        return;
+    }
+    shutdownState = "shutting_down";
+    console.log("\n[chapterhouse] Shutting down... (Ctrl+C again to force)");
+    // Force exit after 3 seconds no matter what
+    const forceTimer = setTimeout(() => {
+        console.log("[chapterhouse] Shutdown timed out — forcing exit.");
+        process.exit(1);
+    }, 3000);
+    forceTimer.unref();
+    // Destroy all active agent sessions
+    await shutdownAgents();
+    try {
+        decisionsSyncScheduler?.stop();
+    }
+    catch { /* best effort */ }
+    try {
+        stopEpisodeWriter();
+    }
+    catch { /* best effort */ }
+    try {
+        await stopClient();
+    }
+    catch { /* best effort */ }
+    closeDb();
+    console.log("[chapterhouse] Goodbye.");
+    process.exit(0);
+}
+/** Restart the daemon by spawning a new process and exiting. */
+export async function restartDaemon() {
+    console.log("[chapterhouse] Restarting...");
+    const workers = getAgentInfo();
+    if (workers.length > 0) {
+        console.log(`[chapterhouse] ⚠ Stopping ${workers.length} running worker(s) for restart`);
+    }
+    // Destroy all active agent sessions
+    await shutdownAgents();
+    try {
+        decisionsSyncScheduler?.stop();
+    }
+    catch { /* best effort */ }
+    try {
+        stopEpisodeWriter();
+    }
+    catch { /* best effort */ }
+    try {
+        await stopClient();
+    }
+    catch { /* best effort */ }
+    closeDb();
+    // Spawn a detached replacement process with the same args (include execArgv for tsx/loaders)
+    const child = spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
+        detached: true,
+        stdio: "inherit",
+        env: { ...process.env, CHAPTERHOUSE_RESTARTED: "1" },
+    });
+    child.unref();
+    console.log("[chapterhouse] New process spawned. Exiting old process.");
+    process.exit(0);
+}
+registerShutdownSignals(process, shutdown);
+// Prevent unhandled errors from crashing the daemon
+process.on("unhandledRejection", (reason) => {
+    console.error("[chapterhouse] Unhandled rejection (kept alive):", reason);
+});
+process.on("uncaughtException", (err) => {
+    console.error("[chapterhouse] Uncaught exception — shutting down:", err);
+    process.exit(1);
+});
+main().catch((err) => {
+    console.error("[chapterhouse] Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map

package/dist/home-path.js

@@ -0,0 +1,12 @@
+import { homedir } from "os";
+import { join } from "path";
+export function getChapterhouseHomeDisplayPath() {
+    return join(homedir(), ".chapterhouse");
+}
+export function getChapterhouseEnvDisplayPath() {
+    return join(getChapterhouseHomeDisplayPath(), ".env");
+}
+export function getExampleProjectPath() {
+    return join(homedir(), "dev", "myapp");
+}
+//# sourceMappingURL=home-path.js.map

package/dist/home-path.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert/strict";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { getChapterhouseHomeDisplayPath, getChapterhouseEnvDisplayPath, getExampleProjectPath, } from "./home-path.js";
+test("home-path helpers build cross-platform display paths", () => {
+    assert.equal(getChapterhouseHomeDisplayPath(), join(homedir(), ".chapterhouse"));
+    assert.equal(getChapterhouseEnvDisplayPath(), join(homedir(), ".chapterhouse", ".env"));
+    assert.equal(getExampleProjectPath(), join(homedir(), "dev", "myapp"));
+});
+//# sourceMappingURL=home-path.test.js.map