chapterhouse 0.1.1

package/dist/copilot/router.test.js

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function loadRouterModule(t, options = {}) {
+    const state = new Map();
+    if (options.storedConfig !== undefined) {
+        state.set("router_config", options.storedConfig);
+    }
+    t.mock.module("../store/db.js", {
+        namedExports: {
+            getState: (key) => state.get(key),
+            setState: (key, value) => {
+                state.set(key, value);
+            },
+        },
+    });
+    t.mock.module("./classifier.js", {
+        namedExports: {
+            classifyWithLLM: async (_client, prompt) => await (options.classify?.(prompt) ?? null),
+        },
+    });
+    const router = await import(new URL(`./router.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    return { router, state };
+}
+test("router config falls back safely and deep-merges tier model updates", async (t) => {
+    const { router, state } = await loadRouterModule(t, {
+        storedConfig: "{not-json}",
+    });
+    assert.deepEqual(router.getRouterConfig(), {
+        enabled: false,
+        tierModels: {
+            fast: "gpt-4.1",
+            standard: "claude-sonnet-4.6",
+            premium: "claude-opus-4.6",
+        },
+        overrides: [
+            {
+                name: "design",
+                keywords: [
+                    "design", "ui", "ux", "css", "layout", "styling", "visual",
+                    "mockup", "wireframe", "frontend design", "tailwind", "responsive",
+                ],
+                model: "claude-opus-4.6",
+            },
+        ],
+        cooldownMessages: 2,
+    });
+    const updated = router.updateRouterConfig({
+        enabled: true,
+        tierModels: {
+            ...router.getRouterConfig().tierModels,
+            premium: "gpt-5.5",
+        },
+    });
+    assert.equal(updated.enabled, true);
+    assert.deepEqual(updated.tierModels, {
+        fast: "gpt-4.1",
+        standard: "claude-sonnet-4.6",
+        premium: "gpt-5.5",
+    });
+    assert.equal(JSON.parse(state.get("router_config") || "{}").tierModels.premium, "gpt-5.5");
+});
+test("resolveModel stays in manual mode when the router is disabled", async (t) => {
+    const { router } = await loadRouterModule(t);
+    const result = await router.resolveModel("Ship it", "claude-sonnet-4.6", []);
+    assert.deepEqual(result, {
+        model: "claude-sonnet-4.6",
+        tier: null,
+        switched: false,
+        routerMode: "manual",
+    });
+});
+test("resolveModel applies overrides by whole word and ignores partial-word matches", async (t) => {
+    const { router } = await loadRouterModule(t, {
+        classify: async () => "fast",
+    });
+    router.updateRouterConfig({ enabled: true });
+    const override = await router.resolveModel("Need a UI refresh", "gpt-4.1", [], {});
+    const noOverride = await router.resolveModel("Fruit salad", "gpt-4.1", [], {});
+    assert.equal(override.overrideName, "design");
+    assert.equal(override.model, "claude-opus-4.6");
+    assert.equal(override.switched, true);
+    assert.equal(noOverride.overrideName, undefined);
+    assert.equal(noOverride.model, "gpt-4.1");
+    assert.equal(noOverride.tier, "fast");
+});
+test("short follow-ups inherit the previous tier", async (t) => {
+    const { router } = await loadRouterModule(t);
+    router.updateRouterConfig({ enabled: true });
+    const result = await router.resolveModel("yes", "claude-sonnet-4.6", ["premium"]);
+    assert.deepEqual(result, {
+        model: "claude-opus-4.6",
+        tier: "premium",
+        switched: true,
+        routerMode: "auto",
+    });
+});
+test("cooldown prevents rapid model flapping until enough messages pass", async (t) => {
+    const responses = ["premium", "fast", "fast", "fast"];
+    const { router } = await loadRouterModule(t, {
+        classify: async () => responses.shift() || "standard",
+    });
+    router.updateRouterConfig({
+        enabled: true,
+        cooldownMessages: 2,
+    });
+    const first = await router.resolveModel("Deep architecture review", "gpt-4.1", [], {});
+    const second = await router.resolveModel("thanks", "claude-opus-4.6", [], {});
+    const third = await router.resolveModel("thanks again", "claude-opus-4.6", [], {});
+    const fourth = await router.resolveModel("one more follow-up", "claude-opus-4.6", [], {});
+    assert.equal(first.model, "claude-opus-4.6");
+    assert.equal(first.switched, true);
+    assert.equal(second.model, "claude-opus-4.6");
+    assert.equal(second.switched, false);
+    assert.equal(third.model, "claude-opus-4.6");
+    assert.equal(third.switched, false);
+    assert.equal(fourth.model, "gpt-4.1");
+    assert.equal(fourth.switched, true);
+});
+//# sourceMappingURL=router.test.js.map

package/dist/copilot/skills.js

@@ -0,0 +1,125 @@
+import { readdirSync, readFileSync, mkdirSync, writeFileSync, existsSync, rmSync } from "fs";
+import { join, dirname, sep } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { SKILLS_DIR } from "../paths.js";
+/** User-local skills directory (~/.chapterhouse/skills/) */
+const LOCAL_SKILLS_DIR = SKILLS_DIR;
+/** Global shared skills directory */
+const GLOBAL_SKILLS_DIR = join(homedir(), ".agents", "skills");
+/** Skills bundled with the Chapterhouse package (e.g. find-skills) */
+const BUNDLED_SKILLS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "skills");
+/** Returns all skill directories that exist on disk. */
+export function getSkillDirectories() {
+    const dirs = [];
+    if (existsSync(BUNDLED_SKILLS_DIR))
+        dirs.push(BUNDLED_SKILLS_DIR);
+    if (existsSync(LOCAL_SKILLS_DIR))
+        dirs.push(LOCAL_SKILLS_DIR);
+    if (existsSync(GLOBAL_SKILLS_DIR))
+        dirs.push(GLOBAL_SKILLS_DIR);
+    return dirs;
+}
+/** Scan all skill directories and return metadata for each skill found. */
+export function listSkills() {
+    const skills = [];
+    for (const [dir, source] of [
+        [BUNDLED_SKILLS_DIR, "bundled"],
+        [LOCAL_SKILLS_DIR, "local"],
+        [GLOBAL_SKILLS_DIR, "global"],
+    ]) {
+        if (!existsSync(dir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const skillDir = join(dir, entry);
+            const skillMd = join(skillDir, "SKILL.md");
+            if (!existsSync(skillMd))
+                continue;
+            try {
+                const content = readFileSync(skillMd, "utf-8");
+                const { name, description } = parseFrontmatter(content);
+                skills.push({
+                    slug: entry,
+                    name: name || entry,
+                    description: description || "(no description)",
+                    directory: skillDir,
+                    source,
+                });
+            }
+            catch {
+                skills.push({
+                    slug: entry,
+                    name: entry,
+                    description: "(could not read SKILL.md)",
+                    directory: skillDir,
+                    source,
+                });
+            }
+        }
+    }
+    return skills;
+}
+/** Create a new skill in the local skills directory. */
+export function createSkill(slug, name, description, instructions) {
+    const skillDir = join(LOCAL_SKILLS_DIR, slug);
+    // Guard against path traversal
+    if (!skillDir.startsWith(LOCAL_SKILLS_DIR + sep)) {
+        return `Invalid slug '${slug}': must be a simple kebab-case name without path separators.`;
+    }
+    if (existsSync(skillDir)) {
+        return `Skill '${slug}' already exists at ${skillDir}. Edit it directly or delete it first.`;
+    }
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "_meta.json"), JSON.stringify({ slug, version: "1.0.0" }, null, 2) + "\n");
+    const skillMd = `---
+name: ${name}
+description: ${description}
+---
+
+${instructions}
+`;
+    writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+    return `Skill '${name}' created at ${skillDir}. It will be available on your next message.`;
+}
+/** Remove a skill from the local skills directory (~/.chapterhouse/skills/). */
+export function removeSkill(slug) {
+    const skillDir = join(LOCAL_SKILLS_DIR, slug);
+    // Guard against path traversal
+    if (!skillDir.startsWith(LOCAL_SKILLS_DIR + sep)) {
+        return { ok: false, message: `Invalid slug '${slug}': must be a simple kebab-case name without path separators.` };
+    }
+    if (!existsSync(skillDir)) {
+        return { ok: false, message: `Skill '${slug}' not found in ${LOCAL_SKILLS_DIR}.` };
+    }
+    rmSync(skillDir, { recursive: true, force: true });
+    return { ok: true, message: `Skill '${slug}' removed from ${skillDir}. It will no longer be available on your next message.` };
+}
+/** Parse YAML frontmatter from a SKILL.md file. */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return { name: "", description: "" };
+    const frontmatter = match[1];
+    let name = "";
+    let description = "";
+    for (const line of frontmatter.split("\n")) {
+        const idx = line.indexOf(": ");
+        if (idx <= 0)
+            continue;
+        const key = line.slice(0, idx).trim();
+        const value = line.slice(idx + 2).trim();
+        if (key === "name")
+            name = value;
+        if (key === "description")
+            description = value;
+    }
+    return { name, description };
+}
+//# sourceMappingURL=skills.js.map

package/dist/copilot/standup.js

@@ -0,0 +1,138 @@
+import { config } from "../config.js";
+import { sendToOrchestrator, getCurrentAuthorizationHeader, getCurrentAuthenticatedUser, getLastAuthenticatedUser, } from "./orchestrator.js";
+import { TeamPushClient } from "../integrations/team-push.js";
+import { getMyOkrsSummary } from "./tools.js";
+import { readPage, writePage } from "../wiki/fs.js";
+const DAY_MS = 24 * 60 * 60 * 1000;
+export class StandupScheduler {
+    getMyOkrs;
+    sendSystemMessage;
+    readStandupPage;
+    writeStandupPage;
+    now;
+    standupTime;
+    setTimeoutImpl;
+    setIntervalImpl;
+    timeoutHandle;
+    intervalHandle;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => new Date());
+        this.standupTime = options.standupTime ?? config.standupTime;
+        this.getMyOkrs = options.getMyOkrs ?? defaultGetMyOkrs;
+        this.sendSystemMessage = options.sendSystemMessage ?? defaultSendSystemMessage;
+        this.readStandupPage = options.readStandupPage ?? readPage;
+        this.writeStandupPage = options.writeStandupPage ?? writePage;
+        this.setTimeoutImpl = options.setTimeoutImpl ?? setTimeout;
+        this.setIntervalImpl = options.setIntervalImpl ?? setInterval;
+    }
+    schedule() {
+        const now = this.now();
+        if (shouldFireMissedStandup(now, this.standupTime, this.readStandupPage)) {
+            void this.sendStandupPrompt();
+        }
+        const delayMs = getDelayUntilNextStandup(now, this.standupTime);
+        this.timeoutHandle = this.setTimeoutImpl(() => {
+            void this.sendStandupPrompt();
+            this.intervalHandle = this.setIntervalImpl(() => {
+                if (!isWeekday(this.now())) {
+                    return;
+                }
+                void this.sendStandupPrompt();
+            }, DAY_MS);
+            this.intervalHandle?.unref?.();
+        }, delayMs);
+        this.timeoutHandle?.unref?.();
+    }
+    async sendStandupPrompt() {
+        const now = this.now();
+        if (!isWeekday(now)) {
+            return;
+        }
+        const period = getQuarter(now);
+        const okrSummary = await this.getMyOkrs(period);
+        const prompt = [
+            `Good morning! Here's your OKR ownership for ${period}:`,
+            okrSummary,
+            "",
+            "What did you work on yesterday? What are you focusing on today?",
+            "(I'll help you log any progress against your key results)",
+        ].join("\n");
+        this.writeStandupPage(`pages/standups/${formatDate(now)}.md`, `${prompt}\n`);
+        await this.sendSystemMessage(prompt);
+    }
+}
+function getDelayUntilNextStandup(now, standupTime) {
+    const target = getNextStandupDate(now, standupTime);
+    return Math.max(0, target.getTime() - now.getTime());
+}
+function shouldFireMissedStandup(now, standupTime, readStandupPage) {
+    if (!isWeekday(now) || !isPastStandupTime(now, standupTime)) {
+        return false;
+    }
+    const standupPage = readStandupPage(`pages/standups/${formatDate(now)}.md`);
+    return !standupPage?.trim();
+}
+function getNextStandupDate(now, standupTime) {
+    const [hoursText, minutesText] = standupTime.split(":");
+    const hours = Number(hoursText);
+    const minutes = Number(minutesText);
+    const next = new Date(now);
+    next.setHours(hours, minutes, 0, 0);
+    while (!isWeekday(next) || next.getTime() <= now.getTime()) {
+        next.setDate(next.getDate() + 1);
+        next.setHours(hours, minutes, 0, 0);
+    }
+    return next;
+}
+function isPastStandupTime(now, standupTime) {
+    const [hoursText, minutesText] = standupTime.split(":");
+    const hours = Number(hoursText);
+    const minutes = Number(minutesText);
+    const standupDate = new Date(now);
+    standupDate.setHours(hours, minutes, 0, 0);
+    return now.getTime() > standupDate.getTime();
+}
+function isWeekday(now) {
+    const day = now.getDay();
+    return day !== 0 && day !== 6;
+}
+function getQuarter(now) {
+    return `${now.getFullYear()}-Q${Math.floor(now.getMonth() / 3) + 1}`;
+}
+function formatDate(now) {
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+async function defaultGetMyOkrs(period) {
+    const getCurrentUser = () => getCurrentAuthenticatedUser() ?? getLastAuthenticatedUser();
+    return await getMyOkrsSummary({
+        createTeamPushClient: () => new TeamPushClient({
+            getAuthorizationHeader: getCurrentAuthorizationHeader,
+            getCurrentUser,
+        }),
+        getCurrentUser,
+        period,
+    });
+}
+async function defaultSendSystemMessage(prompt) {
+    await new Promise((resolve, reject) => {
+        void sendToOrchestrator([
+            "Send the following standup prompt to the user exactly as written.",
+            "Do not add commentary, explanation, or markdown fences.",
+            "",
+            prompt,
+        ].join("\n"), { type: "background" }, (text, done) => {
+            if (!done) {
+                return;
+            }
+            if (text.startsWith("Error: ")) {
+                reject(new Error(text.slice("Error: ".length).trim() || text));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+//# sourceMappingURL=standup.js.map

package/dist/copilot/standup.test.js

@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function loadStandupModule() {
+    try {
+        return await import(new URL(`./standup.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    }
+    catch {
+        return null;
+    }
+}
+test("sendStandupPrompt builds the morning prompt with owned KR progress", async () => {
+    const standupModule = await loadStandupModule();
+    assert.ok(standupModule, "standup module should exist");
+    let sentPrompt = "";
+    const scheduler = new standupModule.StandupScheduler({
+        now: () => new Date("2026-05-06T08:45:00"),
+        getMyOkrs: async () => [
+            "Current OKRs for Ada Lovelace:",
+            "• O1-KR1: Reduce auth service latency (Improve auth platform reliability) — 40/100 %",
+            "• O2-KR2: Cut flaky builds (Build confidence) — 3/5 runs",
+        ].join("\n"),
+        sendSystemMessage: async (prompt) => {
+            sentPrompt = prompt;
+        },
+        writeStandupPage: () => { },
+    });
+    await scheduler.sendStandupPrompt();
+    assert.match(sentPrompt, /Good morning! Here's your OKR ownership for 2026-Q2:/);
+    assert.match(sentPrompt, /O1-KR1: Reduce auth service latency/);
+    assert.match(sentPrompt, /O2-KR2: Cut flaky builds/);
+    assert.match(sentPrompt, /What did you work on yesterday\? What are you focusing on today\?/);
+    assert.match(sentPrompt, /I'll help you log any progress against your key results/);
+});
+test("schedule does not fire on weekends and waits until the next weekday standup time", async () => {
+    const standupModule = await loadStandupModule();
+    assert.ok(standupModule, "standup module should exist");
+    const saturdayMorning = new Date("2026-05-09T08:30:00");
+    let timeoutDelay = -1;
+    let prompted = 0;
+    const scheduler = new standupModule.StandupScheduler({
+        now: () => saturdayMorning,
+        standupTime: "09:00",
+        getMyOkrs: async () => "Current OKRs for Ada Lovelace:\n• O1-KR1: Reduce auth service latency",
+        sendSystemMessage: async () => {
+            prompted += 1;
+        },
+        writeStandupPage: () => { },
+        setTimeoutImpl: (_callback, delayMs) => {
+            timeoutDelay = delayMs;
+            return { kind: "timeout" };
+        },
+        setIntervalImpl: () => ({ kind: "interval" }),
+    });
+    scheduler.schedule();
+    const expectedDelay = new Date("2026-05-11T09:00:00").getTime() - saturdayMorning.getTime();
+    assert.equal(prompted, 0);
+    assert.equal(timeoutDelay, expectedDelay);
+});
+test("schedule fires immediately on startup after standup time when today's standup page is missing", async () => {
+    const standupModule = await loadStandupModule();
+    assert.ok(standupModule, "standup module should exist");
+    const tuesdayLateMorning = new Date("2026-05-05T10:30:00");
+    let timeoutDelay = -1;
+    let prompted = 0;
+    const scheduler = new standupModule.StandupScheduler({
+        now: () => tuesdayLateMorning,
+        standupTime: "09:00",
+        getMyOkrs: async () => "Current OKRs for Ada Lovelace:\n• O1-KR1: Reduce auth service latency",
+        sendSystemMessage: async () => {
+            prompted += 1;
+        },
+        readStandupPage: () => undefined,
+        writeStandupPage: () => { },
+        setTimeoutImpl: (_callback, delayMs) => {
+            timeoutDelay = delayMs;
+            return { kind: "timeout" };
+        },
+        setIntervalImpl: () => ({ kind: "interval" }),
+    });
+    scheduler.schedule();
+    await Promise.resolve();
+    const expectedDelay = new Date("2026-05-06T09:00:00").getTime() - tuesdayLateMorning.getTime();
+    assert.equal(prompted, 1);
+    assert.equal(timeoutDelay, expectedDelay);
+});
+test("schedule does not fire immediately on startup after standup time when today's standup page already exists", async () => {
+    const standupModule = await loadStandupModule();
+    assert.ok(standupModule, "standup module should exist");
+    const tuesdayLateMorning = new Date("2026-05-05T10:30:00");
+    let timeoutDelay = -1;
+    let prompted = 0;
+    const scheduler = new standupModule.StandupScheduler({
+        now: () => tuesdayLateMorning,
+        standupTime: "09:00",
+        getMyOkrs: async () => "Current OKRs for Ada Lovelace:\n• O1-KR1: Reduce auth service latency",
+        sendSystemMessage: async () => {
+            prompted += 1;
+        },
+        readStandupPage: () => "# Existing standup\n",
+        writeStandupPage: () => { },
+        setTimeoutImpl: (_callback, delayMs) => {
+            timeoutDelay = delayMs;
+            return { kind: "timeout" };
+        },
+        setIntervalImpl: () => ({ kind: "interval" }),
+    });
+    scheduler.schedule();
+    await Promise.resolve();
+    const expectedDelay = new Date("2026-05-06T09:00:00").getTime() - tuesdayLateMorning.getTime();
+    assert.equal(prompted, 0);
+    assert.equal(timeoutDelay, expectedDelay);
+});
+test("sendStandupPrompt writes the standup page to the expected daily path", async () => {
+    const standupModule = await loadStandupModule();
+    assert.ok(standupModule, "standup module should exist");
+    let writtenPath = "";
+    let writtenContent = "";
+    const scheduler = new standupModule.StandupScheduler({
+        now: () => new Date("2026-05-06T09:00:00"),
+        getMyOkrs: async () => "Current OKRs for Ada Lovelace:\n• O1-KR1: Reduce auth service latency",
+        sendSystemMessage: async () => { },
+        writeStandupPage: (path, content) => {
+            writtenPath = path;
+            writtenContent = content;
+        },
+    });
+    await scheduler.sendStandupPrompt();
+    assert.equal(writtenPath, "pages/standups/2026-05-06.md");
+    assert.match(writtenContent, /Good morning!/);
+    assert.match(writtenContent, /O1-KR1: Reduce auth service latency/);
+});
+//# sourceMappingURL=standup.test.js.map

package/dist/copilot/system-message.js

@@ -0,0 +1,143 @@
+import { getExampleProjectPath } from "../home-path.js";
+export function getOrchestratorSystemMessage(opts) {
+    const memoryBlock = opts?.memorySummary
+        ? `\n## Memory\nYou have a persistent memory store. Here's what you currently remember:\n\n${opts.memorySummary}\n`
+        : "\n## Memory\nYou have a persistent memory store. It's currently empty — use `remember` to start building it!\n";
+    const selfEditBlock = opts?.selfEditEnabled
+        ? ""
+        : `\n## Self-Edit Protection
+
+**You must NEVER modify your own source code.** This includes the Chapterhouse codebase, configuration files in the project repo, your own system message, skill definitions that ship with you, or any file that is part of the Chapterhouse application itself.
+
+If you break yourself, you cannot repair yourself. If the user asks you to modify your own code, politely decline and explain that self-editing is disabled for safety. Suggest they make the changes manually or start Chapterhouse with \`--self-edit\` to temporarily allow it.
+
+This restriction does NOT apply to:
+- User project files (code the user asks you to work on)
+- Learned skills in ~/.chapterhouse/skills/ (these are user data, not Chapterhouse source)
+- The ~/.chapterhouse/.env config file (model switching, etc.)
+- Any files outside the Chapterhouse installation directory
+`;
+    const agentRosterBlock = opts?.agentRoster
+        ? `\n### Your Team\n${opts.agentRoster}\n`
+        : "";
+    const userContextBlock = opts?.userContext
+        ? `\n## Current User\nYou are talking to ${opts.userContext.name} (${opts.userContext.role}).\n`
+        : "";
+    const osName = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : "Linux";
+    return `You are Chapterhouse, a team-level AI assistant for engineering teams running 24/7 on the user's machine (${osName}). You are the engineering team's always-on assistant.
+
+${userContextBlock}
+## Your Architecture
+
+You are a Node.js daemon process built with the Copilot SDK. Here's how you work:
+
+- **Web UI**: Your primary interface. The team talks to you in a browser tab at http://localhost:7788. Messages arrive tagged with \`[via web]\`. Markdown rendering and code blocks are fully supported, so feel free to be detailed when it helps — but stay focused.
+- **Background tasks**: Messages tagged \`[via background]\` are results from agent tasks you delegated. Summarize and relay these to the team.
+
+When no source tag is present, assume web.
+
+## Your Capabilities
+
+1. **Direct conversation**: You can answer questions, have discussions, and help think through problems — no tools needed.
+2. **Specialist agents**: You lead a team of specialist agents that handle domain-specific work. Delegate coding to @coder, design to @designer, and other tasks to @general-purpose.
+3. **@mention routing**: Users can talk directly to agents using @mentions (e.g., \`@designer build a dark mode toggle\`). Say \`@chapterhouse\` to come back to you.
+4. **Machine awareness**: You can see ALL Copilot sessions running on this machine (VS Code, terminal, etc.) and attach to them.
+5. **Skills**: You have a modular skill system. Skills teach you how to use external tools (gmail, browser, etc.). You can learn new skills on the fly.
+6. **MCP servers**: You connect to MCP tool servers for extended capabilities.
+
+## Your Role
+
+You receive messages and decide how to handle them:
+
+- **Direct answer**: For simple questions, general knowledge, status checks, math, quick lookups — answer directly with plain text. No tool calls needed.
+- **Delegate to an agent**: For ANY task that requires running commands, reading/writing files, coding, debugging, or interacting with the filesystem — you MUST delegate to a specialist agent. You do not have access to bash, file editing, or any execution tools. Only agents can perform these operations.
+- **Use a skill**: If you have a skill for what the user is asking (email, browser, etc.), use it.
+- **Learn a new skill**: If the user asks you to do something you don't have a skill for, delegate research to an agent, then use \`learn_skill\` to save what they find.
+${agentRosterBlock}
+## Agent Delegation — How It Works
+
+The \`delegate_to_agent\` tool is **non-blocking**. It dispatches the task and returns immediately. This means:
+
+1. When you delegate a task, acknowledge it right away. Be natural and brief: "On it — I've asked @coder to handle that." or "Sending this to @designer."
+2. You do NOT wait for the agent to finish. The tool returns immediately.
+3. After delegating, do NOT poll \`get_agent_result\` in a loop. Wait silently for the \`[Agent task completed]\` message to arrive automatically.
+4. When that completion message arrives, call \`get_agent_result\` exactly once for that task, then summarize the result and relay it to the user in a clear, concise way.
+
+You can delegate **multiple tasks simultaneously**. Different agents can work in parallel.
+
+### Speed & Concurrency
+
+**You are single-threaded and have no execution tools.** You cannot run bash, edit files, read files, or execute code — those tools are only available to agents. While you process a message, incoming messages queue up. Your turns must be FAST:
+
+- **For delegation: ONE tool call, ONE brief response.** Call \`delegate_to_agent\`, respond with a short acknowledgment, then wait for the completion notification. Do not poll \`get_agent_result\`.
+- **You are the dispatcher, not the laborer.** If a task requires any tool beyond your management tools, it goes to an agent.
+- **Pick the right agent**: Design/UI → @designer. Code/debug → @coder. Research/general → @general-purpose.
+- **For @general-purpose, choose the model wisely**: Simple tasks → model_override "gpt-4.1". Moderate → "claude-sonnet-4.6". Complex → "claude-opus-4.6".
+
+## Tool Usage
+
+**You only have the management tools listed below.** You do NOT have bash, shell, file editing, file reading, grep, or any other execution tools.
+
+### Agent Management
+- \`delegate_to_agent\`: Send a task to a specialist agent. Runs in the background — you'll get results via a completion message.
+- \`check_agent_status\`: Check on an agent or specific task. Use when the user asks about status.
+- \`get_agent_result\`: Retrieve the result of a completed task after its completion notification arrives, or when the user explicitly asks for it.
+- \`show_agent_roster\`: Show all registered agents with their model, status, and current tasks.
+- \`hire_agent\`: Create a new custom agent by writing an .agent.md file.
+- \`fire_agent\`: Remove a custom agent (cannot remove built-in agents).
+
+### Machine Session Discovery
+- \`list_machine_sessions\`: List ALL Copilot CLI sessions on this machine — including ones started from VS Code, the terminal, or elsewhere.
+- \`attach_machine_session\`: Attach to an existing session by its ID.
+
+### Skills
+- \`list_skills\`: Show all skills Chapterhouse knows.
+- \`learn_skill\`: Teach Chapterhouse a new skill by writing a SKILL.md file.
+
+### Model Management & Auto-Routing
+- \`list_models\`: List all available Copilot models with their billing tier.
+- \`switch_model\`: Manually switch to a specific model. **This disables auto mode.**
+- \`toggle_auto\`: Enable or disable automatic model routing.
+
+**Auto Mode**: Chapterhouse has built-in automatic model routing that selects the best model for each message:
+- **Fast tier** (gpt-4.1): Greetings, acknowledgments, simple factual questions
+- **Standard tier** (claude-sonnet-4.6): Coding tasks, tool usage, moderate reasoning
+- **Premium tier** (claude-opus-4.6): Complex architecture, deep analysis, multi-step reasoning
+
+### Self-Management
+- \`restart_chapterhouse\`: Restart the Chapterhouse daemon.
+
+### Memory
+- \`remember\`: Save something to memory.
+- \`recall\`: Search your memory for stored facts, preferences, or information.
+- \`forget\`: Remove content from the wiki.
+
+**Past conversations**: Daily conversation summaries are auto-written to \`pages/conversations/YYYY-MM-DD.md\`. When the user references something from earlier ("what did we decide about X", "remember when we…", "the thing we discussed yesterday"), call \`wiki_search\` (or \`recall\`) — don't guess from your own context, since older turns may have been compacted out.
+
+**Learning workflow**: When the user asks you to do something you don't have a skill for:
+1. **Search skills.sh first**: Use the find-skills skill to search for existing community skills.
+2. **Present what you found**: Tell the user the skill name, what it does, and its security status.
+3. **ALWAYS ask before installing**: Never install a skill without explicit permission.
+4. **Install locally only**: Use \`learn_skill\` to save to \`~/.chapterhouse/skills/\`. Never install globally.
+5. **Flag security risks**: Warn about skills that request broad system access.
+6. **Build your own only as last resort**: If no community skill exists, delegate research to an agent, then use \`learn_skill\`.
+
+## Guidelines
+
+1. **Match the medium**: The web UI renders rich markdown — use code blocks, lists, and tables when they help. Avoid walls of unstructured text.
+2. **Skill-first mindset**: Search skills.sh for existing skills before building from scratch.
+3. For execution tasks, **always** delegate to a specialist agent. You cannot write code, run commands, or read files directly.
+4. **Announce your delegations**: Tell the user which agent you're sending work to and what the task is.
+5. When you receive background results, summarize the key points. Don't relay the entire output verbatim.
+6. If asked about status, check agent status and give a consolidated update.
+7. You can delegate to multiple agents simultaneously — use this for parallel work.
+8. When a task is complete, relay the results clearly.
+9. If an agent fails, report the error and suggest next steps.
+10. Expand shorthand paths: "${getExampleProjectPath()}" is the expanded form of the user's home-directory project path.
+11. Be conversational and human. You're Chapterhouse.
+12. When using skills, follow the skill's instructions precisely.
+13. **Proactive knowledge building**: When the user shares preferences, project details, etc., proactively use \`remember\` to save them.
+14. When a user mentions completing work or shipping something, proactively suggest logging it as OKR progress with \`log_okr_progress\`.
+${selfEditBlock}${memoryBlock}`;
+}
+//# sourceMappingURL=system-message.js.map

package/dist/copilot/system-message.test.js

@@ -0,0 +1,17 @@
+import assert from "node:assert/strict";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { getOrchestratorSystemMessage } from "./system-message.js";
+test("orchestrator prompt tells Chapterhouse to wait for agent completion notifications instead of polling", () => {
+    const message = getOrchestratorSystemMessage();
+    assert.match(message, /do NOT poll `get_agent_result` in a loop/i);
+    assert.match(message, /wait silently for the `\[Agent task completed\]` message/i);
+    assert.match(message, /call `get_agent_result` exactly once/i);
+});
+test("orchestrator prompt expands shorthand paths with the current home directory", () => {
+    const message = getOrchestratorSystemMessage();
+    assert.match(message, new RegExp(join(homedir(), "dev", "myapp").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+    assert.doesNotMatch(message, /"~\/dev\/myapp"/);
+});
+//# sourceMappingURL=system-message.test.js.map