chapterhouse 0.1.1

package/dist/integrations/team-push.test.js

@@ -0,0 +1,178 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function loadTeamPushModule() {
+    try {
+        return await import(new URL(`./team-push.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    }
+    catch {
+        return null;
+    }
+}
+test("pushUpdate sends the expected payload to the team update endpoint", async () => {
+    const teamPushModule = await loadTeamPushModule();
+    assert.ok(teamPushModule, "team push module should exist");
+    const requests = [];
+    const client = new teamPushModule.TeamPushClient({
+        teamChapterhouseUrl: "https://team.example.com/",
+        standaloneMode: false,
+        getAuthorizationHeader: () => "Bearer entra-token",
+        getCurrentUser: () => ({
+            id: "11111111-2222-3333-4444-555555555555",
+            name: "Ada Lovelace",
+            email: "ada@example.com",
+        }),
+        fetchImpl: async (input, init) => {
+            requests.push({ input: String(input), init });
+            return new Response(JSON.stringify({
+                ok: true,
+                entry: {
+                    engineerId: "11111111-2222-3333-4444-555555555555",
+                    activity: "merged auth refactor PR",
+                    krId: "O1-KR2",
+                    delta: 10,
+                    notes: "Latency benchmark improved",
+                },
+            }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        },
+    });
+    const result = await client.pushUpdate({
+        activity: "merged auth refactor PR",
+        krId: "O1-KR2",
+        delta: 10,
+        notes: "Latency benchmark improved",
+    });
+    assert.equal(result.ok, true);
+    assert.equal(requests.length, 1);
+    assert.equal(requests[0]?.input, "https://team.example.com/api/team/update");
+    assert.equal(requests[0]?.init?.method, "POST");
+    assert.equal((requests[0]?.init?.headers).authorization, "Bearer entra-token");
+    assert.deepEqual(JSON.parse(String(requests[0]?.init?.body)), {
+        engineerId: "11111111-2222-3333-4444-555555555555",
+        activity: "merged auth refactor PR",
+        krId: "O1-KR2",
+        delta: 10,
+        notes: "Latency benchmark improved",
+    });
+});
+test("pushUpdate throws descriptive errors for auth and network failures", async () => {
+    const teamPushModule = await loadTeamPushModule();
+    assert.ok(teamPushModule, "team push module should exist");
+    const unauthorizedClient = new teamPushModule.TeamPushClient({
+        teamChapterhouseUrl: "https://team.example.com",
+        teamChapterhouseToken: "fallback-token",
+        standaloneMode: false,
+        getCurrentUser: () => ({
+            id: "eng-1",
+            name: "Ada Lovelace",
+            email: "ada@example.com",
+        }),
+        fetchImpl: async () => new Response("forbidden", { status: 401 }),
+    });
+    await assert.rejects(unauthorizedClient.pushUpdate({ activity: "shipped auth refactor", krId: "O1-KR2", delta: 5 }), /Failed to push OKR update: unauthorized \(HTTP 401\)/i);
+    const networkClient = new teamPushModule.TeamPushClient({
+        teamChapterhouseUrl: "https://team.example.com",
+        standaloneMode: false,
+        getAuthorizationHeader: () => "Bearer entra-token",
+        getCurrentUser: () => ({
+            id: "eng-1",
+            name: "Ada Lovelace",
+            email: "ada@example.com",
+        }),
+        fetchImpl: async () => {
+            throw new Error("socket hang up");
+        },
+    });
+    await assert.rejects(networkClient.pushUpdate({ activity: "shipped auth refactor", krId: "O1-KR2", delta: 5 }), /Failed to push OKR update: network request failed: socket hang up/i);
+});
+test("fetchOKRs returns raw OKR page content for the requested period", async () => {
+    const teamPushModule = await loadTeamPushModule();
+    assert.ok(teamPushModule, "team push module should exist");
+    const requests = [];
+    const client = new teamPushModule.TeamPushClient({
+        teamChapterhouseUrl: "https://team.example.com",
+        standaloneMode: false,
+        getAuthorizationHeader: () => "Bearer entra-token",
+        fetchImpl: async (input) => {
+            requests.push(String(input));
+            return new Response(JSON.stringify({
+                pages: [
+                    {
+                        path: "pages/okrs/2026-Q2.md",
+                        content: "# OKRs — 2026 Q2\n\n### O1-KR2: Reduce auth service latency\n",
+                        updatedAt: "2026-05-01T12:00:00.000Z",
+                    },
+                ],
+            }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        },
+    });
+    const content = await client.fetchOKRs("2026-Q2");
+    assert.equal(requests[0], "https://team.example.com/api/team/okrs?period=2026-Q2");
+    assert.match(content, /O1-KR2: Reduce auth service latency/);
+});
+test("writePage PUTs shared wiki content to the team wiki endpoint", async () => {
+    const teamPushModule = await loadTeamPushModule();
+    assert.ok(teamPushModule, "team push module should exist");
+    const requests = [];
+    const client = new teamPushModule.TeamPushClient({
+        teamChapterhouseUrl: "https://team.example.com/",
+        standaloneMode: false,
+        getAuthorizationHeader: () => "Bearer entra-token",
+        fetchImpl: async (input, init) => {
+            requests.push({ input: String(input), init });
+            return new Response(JSON.stringify({
+                ok: true,
+                path: "pages/shared/runbooks/deploy.md",
+            }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        },
+    });
+    const result = await client.writePage("pages/shared/runbooks/deploy.md", "# Deploy Runbook\n");
+    assert.deepEqual(result, {
+        ok: true,
+        path: "pages/shared/runbooks/deploy.md",
+    });
+    assert.equal(requests.length, 1);
+    assert.equal(requests[0]?.input, "https://team.example.com/api/team/wiki/pages%2Fshared%2Frunbooks%2Fdeploy.md");
+    assert.equal(requests[0]?.init?.method, "PUT");
+    assert.equal((requests[0]?.init?.headers).authorization, "Bearer entra-token");
+    assert.deepEqual(JSON.parse(String(requests[0]?.init?.body)), {
+        content: "# Deploy Runbook\n",
+    });
+});
+test("team push silently no-ops when team integration is disabled", async () => {
+    const teamPushModule = await loadTeamPushModule();
+    assert.ok(teamPushModule, "team push module should exist");
+    let called = false;
+    const client = new teamPushModule.TeamPushClient({
+        teamChapterhouseUrl: "",
+        standaloneMode: false,
+        fetchImpl: async () => {
+            called = true;
+            throw new Error("fetch should not run");
+        },
+    });
+    assert.deepEqual(await client.pushUpdate({ activity: "shipped standalone mode", krId: "O1-KR2", delta: 5 }), {
+        ok: false,
+        entry: {
+            disabled: true,
+            activity: "shipped standalone mode",
+            krId: "O1-KR2",
+            delta: 5,
+        },
+    });
+    assert.equal(await client.fetchOKRs("2026-Q2"), "");
+    assert.deepEqual(await client.writePage("pages/shared/runbooks/deploy.md", "# Deploy\n"), {
+        ok: false,
+        path: "pages/shared/runbooks/deploy.md",
+    });
+    assert.equal(called, false);
+});
+//# sourceMappingURL=team-push.test.js.map

package/dist/integrations/teams-notify.js

@@ -0,0 +1,108 @@
+import { config } from "../config.js";
+export const TEAMS_MILESTONE_THRESHOLDS = [25, 50, 75, 100];
+const DEFAULT_COLOR = "0076D7";
+export class TeamsNotifier {
+    webhookUrl;
+    enabled;
+    fetchImpl;
+    warn;
+    constructor(options = {}) {
+        this.webhookUrl = (options.webhookUrl ?? config.teamsWebhookUrl).trim();
+        this.enabled = options.enabled ?? config.teamsNotificationsEnabled;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.warn = options.warn ?? ((message) => console.warn(message));
+    }
+    async sendMessage(title, body, color = DEFAULT_COLOR) {
+        return await this.postCard({
+            summary: title,
+            activityTitle: title,
+            text: body,
+            themeColor: color,
+        });
+    }
+    async notifyKRMilestone(kr) {
+        const milestone = getReachedMilestone(kr.currentValue, kr.targetValue);
+        if (milestone === null) {
+            return false;
+        }
+        return await this.postCard({
+            summary: "KR Milestone",
+            activityTitle: `🎯 KR Milestone: ${kr.title}`,
+            text: `${kr.owner} moved **${kr.title}** to **${formatValue(kr.currentValue, kr.unit)}** out of **${formatValue(kr.targetValue, kr.unit)}**.`,
+            facts: [
+                { name: "KR", value: kr.id },
+                { name: "Owner", value: kr.owner },
+                { name: "Milestone", value: `${milestone}%` },
+                { name: "Progress", value: `${formatValue(kr.currentValue, kr.unit)} / ${formatValue(kr.targetValue, kr.unit)}` },
+            ],
+            themeColor: DEFAULT_COLOR,
+        });
+    }
+    async notifyWeeklyHealthCheck(summary) {
+        const body = summary.objectives
+            .map((objective) => `- ${objective.title}: ${objective.percentComplete}%`)
+            .join("\n");
+        return await this.postCard({
+            summary: "Weekly OKR Health Check",
+            activityTitle: `📈 Weekly OKR Health Check: ${summary.quarter}`,
+            text: body,
+            themeColor: DEFAULT_COLOR,
+        });
+    }
+    async notifyStandup(member, updates) {
+        const body = updates.map((update) => `- ${update}`).join("\n");
+        return await this.postCard({
+            summary: "Daily Standup",
+            activityTitle: `🗣️ Standup: ${member}`,
+            text: body,
+            themeColor: DEFAULT_COLOR,
+        });
+    }
+    async postCard(card) {
+        if (!this.enabled || this.webhookUrl.length === 0) {
+            this.warn("[teams] Teams notifications are disabled or TEAMS_WEBHOOK_URL is empty.");
+            return false;
+        }
+        const payload = {
+            "@type": "MessageCard",
+            "@context": "http://schema.org/extensions",
+            themeColor: card.themeColor,
+            summary: card.summary,
+            sections: [
+                {
+                    activityTitle: card.activityTitle,
+                    text: card.text,
+                    facts: card.facts,
+                    markdown: true,
+                },
+            ],
+        };
+        const response = await this.fetchImpl(this.webhookUrl, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`Teams webhook request failed: HTTP ${response.status}`);
+        }
+        return true;
+    }
+}
+function getReachedMilestone(currentValue, targetValue) {
+    if (!Number.isFinite(currentValue) || !Number.isFinite(targetValue) || targetValue <= 0) {
+        return null;
+    }
+    let reached = null;
+    for (const threshold of TEAMS_MILESTONE_THRESHOLDS) {
+        if (currentValue >= (targetValue * threshold) / 100) {
+            reached = threshold;
+        }
+    }
+    return reached;
+}
+function formatValue(value, unit) {
+    return unit === "%" ? `${value}%` : `${value} ${unit}`.trim();
+}
+//# sourceMappingURL=teams-notify.js.map

package/dist/integrations/teams-notify.test.js

@@ -0,0 +1,135 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function loadTeamsNotifyModule() {
+    try {
+        return await import(new URL(`./teams-notify.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    }
+    catch {
+        return null;
+    }
+}
+test("sendMessage formats a Teams MessageCard payload", async () => {
+    const teamsNotify = await loadTeamsNotifyModule();
+    assert.ok(teamsNotify, "teams notifier module should exist");
+    const calls = [];
+    const notifier = new teamsNotify.TeamsNotifier({
+        webhookUrl: "https://teams.example.test/webhook",
+        enabled: true,
+        fetchImpl: async (input, init) => {
+            calls.push({ input, init });
+            return new Response(null, { status: 200 });
+        },
+    });
+    const sent = await notifier.sendMessage("Release ready", "Everything is green.", "00FF00");
+    assert.equal(sent, true);
+    assert.equal(calls.length, 1);
+    assert.equal(String(calls[0]?.input), "https://teams.example.test/webhook");
+    assert.equal(calls[0]?.init?.method, "POST");
+    const payload = JSON.parse(String(calls[0]?.init?.body));
+    assert.equal(payload["@type"], "MessageCard");
+    assert.equal(payload["@context"], "http://schema.org/extensions");
+    assert.equal(payload.themeColor, "00FF00");
+    assert.equal(payload.summary, "Release ready");
+    assert.equal(payload.sections[0]?.activityTitle, "Release ready");
+    assert.equal(payload.sections[0]?.text, "Everything is green.");
+});
+for (const milestone of [25, 50, 75, 100]) {
+    test(`notifyKRMilestone sends the ${milestone}% milestone payload`, async () => {
+        const teamsNotify = await loadTeamsNotifyModule();
+        assert.ok(teamsNotify, "teams notifier module should exist");
+        const calls = [];
+        const notifier = new teamsNotify.TeamsNotifier({
+            webhookUrl: "https://teams.example.test/webhook",
+            enabled: true,
+            fetchImpl: async (input, init) => {
+                calls.push({ input, init });
+                return new Response(null, { status: 200 });
+            },
+        });
+        const sent = await notifier.notifyKRMilestone({
+            id: "KR-7",
+            title: "Reduce incident volume",
+            owner: "Ada",
+            currentValue: milestone,
+            targetValue: 100,
+            unit: "%",
+        });
+        assert.equal(sent, true);
+        assert.equal(calls.length, 1);
+        const payload = JSON.parse(String(calls[0]?.init?.body));
+        assert.equal(payload.summary, "KR Milestone");
+        assert.equal(payload.themeColor, "0076D7");
+        assert.equal(payload.sections[0]?.activityTitle, "🎯 KR Milestone: Reduce incident volume");
+        assert.ok(payload.sections[0]?.facts?.some((fact) => fact.name === "Milestone" && fact.value === `${milestone}%`));
+        assert.ok(payload.sections[0]?.facts?.some((fact) => fact.name === "Owner" && fact.value === "Ada"));
+    });
+}
+test("sendMessage does not call Teams when notifications are disabled", async () => {
+    const teamsNotify = await loadTeamsNotifyModule();
+    assert.ok(teamsNotify, "teams notifier module should exist");
+    let fetchCalls = 0;
+    const warnings = [];
+    const notifier = new teamsNotify.TeamsNotifier({
+        webhookUrl: "https://teams.example.test/webhook",
+        enabled: false,
+        fetchImpl: async () => {
+            fetchCalls += 1;
+            return new Response(null, { status: 200 });
+        },
+        warn: (message) => warnings.push(message),
+    });
+    const sent = await notifier.sendMessage("Ignored", "This should not send.");
+    assert.equal(sent, false);
+    assert.equal(fetchCalls, 0);
+    assert.equal(warnings.length, 1);
+    assert.match(warnings[0] ?? "", /teams notifications/i);
+});
+test("notifyWeeklyHealthCheck sends an OKR summary card", async () => {
+    const teamsNotify = await loadTeamsNotifyModule();
+    assert.ok(teamsNotify, "teams notifier module should exist");
+    const calls = [];
+    const notifier = new teamsNotify.TeamsNotifier({
+        webhookUrl: "https://teams.example.test/webhook",
+        enabled: true,
+        fetchImpl: async (input, init) => {
+            calls.push({ input, init });
+            return new Response(null, { status: 200 });
+        },
+    });
+    const sent = await notifier.notifyWeeklyHealthCheck({
+        quarter: "2026-Q2",
+        objectives: [
+            { title: "Ship SSO", percentComplete: 80 },
+            { title: "Reduce incidents", percentComplete: 55 },
+        ],
+    });
+    assert.equal(sent, true);
+    const payload = JSON.parse(String(calls[0]?.init?.body));
+    assert.equal(payload.summary, "Weekly OKR Health Check");
+    assert.match(payload.sections[0]?.text ?? "", /Ship SSO: 80%/);
+    assert.match(payload.sections[0]?.text ?? "", /Reduce incidents: 55%/);
+});
+test("notifyStandup sends the member update summary", async () => {
+    const teamsNotify = await loadTeamsNotifyModule();
+    assert.ok(teamsNotify, "teams notifier module should exist");
+    const calls = [];
+    const notifier = new teamsNotify.TeamsNotifier({
+        webhookUrl: "https://teams.example.test/webhook",
+        enabled: true,
+        fetchImpl: async (input, init) => {
+            calls.push({ input, init });
+            return new Response(null, { status: 200 });
+        },
+    });
+    const sent = await notifier.notifyStandup("Grace", [
+        "Closed the migration backlog",
+        "Unblocked the SSO rollout",
+    ]);
+    assert.equal(sent, true);
+    const payload = JSON.parse(String(calls[0]?.init?.body));
+    assert.equal(payload.summary, "Daily Standup");
+    assert.equal(payload.sections[0]?.activityTitle, "🗣️ Standup: Grace");
+    assert.match(payload.sections[0]?.text ?? "", /Closed the migration backlog/);
+    assert.match(payload.sections[0]?.text ?? "", /Unblocked the SSO rollout/);
+});
+//# sourceMappingURL=teams-notify.test.js.map

package/dist/paths.js

@@ -0,0 +1,41 @@
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+import { normalizeWikiPath } from "./wiki/path-utils.js";
+/** Base directory for all Chapterhouse user data: ~/.chapterhouse */
+function resolveChapterhouseHome() {
+    const configuredHome = process.env.CHAPTERHOUSE_HOME?.trim();
+    if (!configuredHome) {
+        return join(homedir(), ".chapterhouse");
+    }
+    return configuredHome.endsWith(".chapterhouse")
+        ? configuredHome
+        : join(configuredHome, ".chapterhouse");
+}
+export const CHAPTERHOUSE_HOME = resolveChapterhouseHome();
+/** Path to the SQLite database */
+export const DB_PATH = join(CHAPTERHOUSE_HOME, "chapterhouse.db");
+/** Path to the user .env file */
+export const ENV_PATH = join(CHAPTERHOUSE_HOME, ".env");
+/** Path to user-local skills */
+export const SKILLS_DIR = join(CHAPTERHOUSE_HOME, "skills");
+/** Path to Chapterhouse's isolated session state (keeps CLI history clean) */
+export const SESSIONS_DIR = join(CHAPTERHOUSE_HOME, "sessions");
+/** Path to the API bearer token file */
+export const API_TOKEN_PATH = join(CHAPTERHOUSE_HOME, "api-token");
+/** Agent definition files (~/.chapterhouse/agents/) */
+export const AGENTS_DIR = join(CHAPTERHOUSE_HOME, "agents");
+/** Root of the LLM-maintained wiki knowledge base */
+export const WIKI_DIR = join(CHAPTERHOUSE_HOME, "wiki");
+/** Wiki pages (entity, concept, summary files) */
+export const WIKI_PAGES_DIR = join(WIKI_DIR, "pages");
+/** Raw ingested source documents (immutable) */
+export const WIKI_SOURCES_DIR = join(WIKI_DIR, "sources");
+export function resolveWikiRelativePath(relativePath) {
+    return join(WIKI_DIR, ...normalizeWikiPath(relativePath).split("/"));
+}
+/** Ensure ~/.chapterhouse/ exists */
+export function ensureChapterhouseHome() {
+    mkdirSync(CHAPTERHOUSE_HOME, { recursive: true });
+}
+//# sourceMappingURL=paths.js.map

package/dist/setup.js

@@ -0,0 +1,149 @@
+import * as readline from "readline";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { CopilotClient } from "@github/copilot-sdk";
+import { ensureChapterhouseHome, ENV_PATH, CHAPTERHOUSE_HOME } from "./paths.js";
+import { getExampleProjectPath } from "./home-path.js";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const RESET = "\x1b[0m";
+const FALLBACK_MODELS = [
+    { id: "claude-sonnet-4.6", label: "Claude Sonnet 4.6", desc: "Fast, great for most tasks" },
+    { id: "gpt-5.1", label: "GPT-5.1", desc: "OpenAI's fast model" },
+    { id: "gpt-4.1", label: "GPT-4.1", desc: "Free included model" },
+];
+async function fetchModels() {
+    let client;
+    try {
+        client = new CopilotClient({ autoStart: true });
+        await client.start();
+        const models = await client.listModels();
+        return models
+            .filter((m) => m.policy?.state === "enabled" && !m.name.includes("(Internal only)"))
+            .map((m) => {
+            const mult = m.billing?.multiplier;
+            const desc = mult === 0 || mult === undefined ? "Included with Copilot" : `Premium (${mult}x)`;
+            return { id: m.id, label: m.name, desc };
+        });
+    }
+    catch {
+        return [];
+    }
+    finally {
+        try {
+            await client?.stop();
+        }
+        catch { /* best-effort */ }
+    }
+}
+function ask(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+async function askPicker(rl, label, options, defaultId) {
+    console.log(`${BOLD}${label}${RESET}\n`);
+    const defaultIdx = Math.max(0, options.findIndex((o) => o.id === defaultId));
+    for (let i = 0; i < options.length; i++) {
+        const marker = i === defaultIdx ? `${GREEN}▸${RESET}` : " ";
+        const tag = i === defaultIdx ? ` ${DIM}(default)${RESET}` : "";
+        console.log(`  ${marker} ${CYAN}${i + 1}${RESET}  ${options[i].label}${tag}`);
+        console.log(`       ${DIM}${options[i].desc}${RESET}`);
+    }
+    console.log();
+    const input = await ask(rl, `  Pick a number ${DIM}(1-${options.length}, Enter for default)${RESET}: `);
+    const num = parseInt(input.trim(), 10);
+    if (num >= 1 && num <= options.length)
+        return options[num - 1].id;
+    return options[defaultIdx].id;
+}
+async function main() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log(`
+${BOLD}╔══════════════════════════════════════════╗
+║           🤖  Chapterhouse Setup                  ║
+╚══════════════════════════════════════════╝${RESET}
+`);
+    console.log(`${DIM}Config directory: ${CHAPTERHOUSE_HOME}${RESET}\n`);
+    ensureChapterhouseHome();
+    // Load existing values if any
+    const existing = {};
+    if (existsSync(ENV_PATH)) {
+        for (const line of readFileSync(ENV_PATH, "utf-8").split("\n")) {
+            const match = line.match(/^([A-Z_]+)=(.*)$/);
+            if (match)
+                existing[match[1]] = match[2];
+        }
+    }
+    // ── What is Chapterhouse ──────────────────────────────────────────
+    console.log(`${BOLD}Meet Chapterhouse${RESET}`);
+    console.log(`Chapterhouse is your team-level AI assistant — an always-on daemon that runs on`);
+    console.log(`your machine. Open the web UI in your browser and talk in plain English;`);
+    console.log(`Chapterhouse handles the rest.`);
+    console.log();
+    console.log(`${CYAN}What Chapterhouse can do out of the box:${RESET}`);
+    console.log(`  • Have conversations and answer questions`);
+    console.log(`  • Spin up Copilot CLI sessions to code, debug, and run commands`);
+    console.log(`  • Manage multiple background tasks simultaneously`);
+    console.log(`  • Maintain a shared engineering wiki of everything it learns about your team`);
+    console.log();
+    console.log(`${CYAN}Skills — teach Chapterhouse anything:${RESET}`);
+    console.log(`  Chapterhouse has a skill system that lets it learn new capabilities. There's`);
+    console.log(`  an open source library of community skills it can install, or it can`);
+    console.log(`  write its own from scratch.`);
+    console.log();
+    await ask(rl, `${DIM}Press Enter to continue...${RESET}`);
+    console.log();
+    // ── Model picker ─────────────────────────────────────────
+    console.log(`\n${BOLD}━━━ Default Model ━━━${RESET}\n`);
+    console.log(`${DIM}Fetching available models from Copilot...${RESET}`);
+    let models = await fetchModels();
+    if (models.length === 0) {
+        console.log(`${YELLOW}  Could not fetch models (Copilot CLI may not be authenticated yet).${RESET}`);
+        console.log(`${DIM}  Showing a curated list — you can switch anytime after setup.${RESET}\n`);
+        models = FALLBACK_MODELS;
+    }
+    else {
+        console.log(`${GREEN}  ✓ Found ${models.length} models${RESET}\n`);
+    }
+    console.log(`${DIM}You can switch models anytime in the web UI's Settings page.${RESET}\n`);
+    const currentModel = existing.COPILOT_MODEL || "claude-sonnet-4.6";
+    const model = await askPicker(rl, "Choose a default model:", models, currentModel);
+    const modelLabel = models.find((m) => m.id === model)?.label || model;
+    console.log(`\n${GREEN}  ✓ Using ${modelLabel}${RESET}\n`);
+    // ── Write config ─────────────────────────────────────────
+    const apiPort = existing.API_PORT || "7788";
+    const lines = [];
+    lines.push(`API_PORT=${apiPort}`);
+    lines.push(`COPILOT_MODEL=${model}`);
+    writeFileSync(ENV_PATH, lines.join("\n") + "\n");
+    // ── Done ─────────────────────────────────────────────────
+    console.log(`
+${GREEN}${BOLD}✅ Chapterhouse is ready!${RESET}
+${DIM}Config saved to ${ENV_PATH}${RESET}
+
+${BOLD}Get started:${RESET}
+
+  ${CYAN}1.${RESET} Make sure Copilot CLI is authenticated:
+     ${BOLD}copilot login${RESET}
+
+  ${CYAN}2.${RESET} Start Chapterhouse:
+     ${BOLD}chapterhouse start${RESET}
+
+  ${CYAN}3.${RESET} Open the web UI:
+     ${BOLD}http://localhost:${apiPort}${RESET}
+
+${BOLD}Things to try:${RESET}
+
+  ${DIM}"Start working on the auth bug in ${getExampleProjectPath()}"${RESET}
+  ${DIM}"What sessions are running?"${RESET}
+  ${DIM}"Find me a skill for checking Gmail"${RESET}
+  ${DIM}"Switch to gpt-4.1"${RESET}
+`);
+    rl.close();
+}
+main().catch((err) => {
+    console.error("Setup failed:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=setup.js.map

package/dist/shutdown-signals.js

@@ -0,0 +1,13 @@
+export function registerShutdownSignals(target, handler) {
+    target.on("SIGINT", handler);
+    target.on("SIGTERM", handler);
+    if (target.platform === "win32") {
+        try {
+            target.on("SIGBREAK", handler);
+        }
+        catch {
+            // Some runtimes do not support SIGBREAK registration even on Windows.
+        }
+    }
+}
+//# sourceMappingURL=shutdown-signals.js.map

package/dist/shutdown-signals.test.js

@@ -0,0 +1,33 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerShutdownSignals } from "./shutdown-signals.js";
+test("registerShutdownSignals adds SIGBREAK on Windows", () => {
+    const seen = [];
+    registerShutdownSignals({
+        platform: "win32",
+        on(signal, listener) {
+            void listener;
+            seen.push(signal);
+            return this;
+        },
+    }, async () => { });
+    assert.deepEqual(seen, ["SIGINT", "SIGTERM", "SIGBREAK"]);
+});
+test("registerShutdownSignals ignores unsupported SIGBREAK registration errors", () => {
+    const seen = [];
+    assert.doesNotThrow(() => {
+        registerShutdownSignals({
+            platform: "win32",
+            on(signal, listener) {
+                void listener;
+                seen.push(signal);
+                if (signal === "SIGBREAK") {
+                    throw new Error("unsupported");
+                }
+                return this;
+            },
+        }, async () => { });
+    });
+    assert.deepEqual(seen, ["SIGINT", "SIGTERM", "SIGBREAK"]);
+});
+//# sourceMappingURL=shutdown-signals.test.js.map