chapterhouse 0.1.1

package/dist/copilot/agents.js

@@ -0,0 +1,447 @@
+import { readdirSync, readFileSync, mkdirSync, writeFileSync, existsSync, rmSync, copyFileSync } from "fs";
+import { createHash } from "crypto";
+import { join, dirname, sep } from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+import { approveAll } from "@github/copilot-sdk";
+import { AGENTS_DIR, SESSIONS_DIR } from "../paths.js";
+import { getState, setState } from "../store/db.js";
+import { loadMcpConfig } from "./mcp-config.js";
+import { getSkillDirectories } from "./skills.js";
+import { findSquadAgent, renderProjectAgentRoster } from "../squad/registry.js";
+// Frontmatter schema
+const agentFrontmatterSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().min(1),
+    model: z.string().min(1),
+    skills: z.array(z.string()).optional(),
+    tools: z.array(z.string()).optional(),
+    mcpServers: z.array(z.string()).optional(),
+});
+// ---------------------------------------------------------------------------
+// Agent Registry
+// ---------------------------------------------------------------------------
+let agentRegistry = [];
+/** Bundled agents shipped with the package */
+const BUNDLED_AGENTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "agents");
+const RESERVED_SLUGS = new Set(["chapterhouse", "designer", "coder", "general-purpose"]);
+const SLUG_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+/** Parse YAML frontmatter and markdown body from an .agent.md file. */
+export function parseAgentMd(content, slug) {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---\s*([\s\S]*)$/);
+    if (!fmMatch)
+        return null;
+    const frontmatterRaw = fmMatch[1];
+    const body = fmMatch[2].trim();
+    // Simple YAML parser for flat + array values
+    const parsed = {};
+    for (const line of frontmatterRaw.split("\n")) {
+        const idx = line.indexOf(": ");
+        if (idx <= 0)
+            continue;
+        const key = line.slice(0, idx).trim();
+        let value = line.slice(idx + 2).trim();
+        // Handle YAML quoted strings
+        if (typeof value === "string" && value.startsWith('"') && value.endsWith('"')) {
+            value = value.slice(1, -1);
+        }
+        parsed[key] = value;
+    }
+    // Parse arrays from YAML inline syntax: [a, b, c]
+    for (const key of ["skills", "tools", "mcpServers"]) {
+        const raw = parsed[key];
+        if (typeof raw === "string") {
+            const arrMatch = raw.match(/^\[(.*)\]$/);
+            if (arrMatch) {
+                parsed[key] = arrMatch[1]
+                    .split(",")
+                    .map((s) => s.trim().replace(/^['"]|['"]$/g, ""))
+                    .filter(Boolean);
+            }
+        }
+    }
+    const result = agentFrontmatterSchema.safeParse(parsed);
+    if (!result.success) {
+        console.warn(`[agents] Invalid frontmatter in ${slug}.agent.md:`, result.error.format());
+        return null;
+    }
+    const fm = result.data;
+    return {
+        slug,
+        name: fm.name,
+        description: fm.description,
+        model: fm.model,
+        skills: fm.skills,
+        tools: fm.tools,
+        mcpServers: fm.mcpServers,
+        systemMessage: body,
+    };
+}
+/** Scan ~/.chapterhouse/agents/ for .agent.md files and load configs. */
+export function loadAgents() {
+    if (!existsSync(AGENTS_DIR)) {
+        mkdirSync(AGENTS_DIR, { recursive: true });
+        return [];
+    }
+    const configs = [];
+    let entries;
+    try {
+        entries = readdirSync(AGENTS_DIR);
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith(".agent.md"))
+            continue;
+        const slug = entry.replace(/\.agent\.md$/, "");
+        try {
+            const content = readFileSync(join(AGENTS_DIR, entry), "utf-8");
+            const config = parseAgentMd(content, slug);
+            if (config)
+                configs.push(config);
+        }
+        catch (err) {
+            console.warn(`[agents] Failed to read ${entry}:`, err instanceof Error ? err.message : err);
+        }
+    }
+    agentRegistry = configs;
+    return configs;
+}
+/** Get agent config by name or slug (case-insensitive). */
+export function getAgent(nameOrSlug) {
+    const lower = nameOrSlug.toLowerCase();
+    return agentRegistry.find((a) => a.slug === lower || a.name.toLowerCase() === lower);
+}
+/** Get all loaded agent configs. */
+export function getAgentRegistry() {
+    return [...agentRegistry];
+}
+/** Copy bundled agents to ~/.chapterhouse/agents/, updating stale copies when the bundled version changes.
+ *  Respects user customizations: if the user edited the deployed file after our last sync, we skip it. */
+export function ensureDefaultAgents() {
+    mkdirSync(AGENTS_DIR, { recursive: true });
+    if (!existsSync(BUNDLED_AGENTS_DIR))
+        return;
+    let bundled;
+    try {
+        bundled = readdirSync(BUNDLED_AGENTS_DIR).filter((f) => f.endsWith(".agent.md"));
+    }
+    catch {
+        return;
+    }
+    for (const file of bundled) {
+        const src = join(BUNDLED_AGENTS_DIR, file);
+        const dest = join(AGENTS_DIR, file);
+        const srcHash = createHash("sha256").update(readFileSync(src)).digest("hex");
+        const stateKey = `bundled_agent_hash:${file}`;
+        if (!existsSync(dest)) {
+            copyFileSync(src, dest);
+            setState(stateKey, srcHash);
+            console.log(`[agents] Installed bundled agent: ${file}`);
+            continue;
+        }
+        // Check if the bundled version actually changed since our last sync
+        const lastSyncedHash = getState(stateKey);
+        if (lastSyncedHash === srcHash)
+            continue; // bundled hasn't changed
+        // Bundled version changed — only overwrite if the user hasn't customized it.
+        // If we have a record of what we last deployed, check if the file still matches.
+        const destHash = createHash("sha256").update(readFileSync(dest)).digest("hex");
+        if (lastSyncedHash && destHash !== lastSyncedHash) {
+            // User modified the file after our last sync — don't clobber their changes
+            console.log(`[agents] Skipping ${file} — user has local customizations`);
+            continue;
+        }
+        // Safe to update: either first sync (no record) or file is unmodified from our last deploy
+        copyFileSync(src, dest);
+        setState(stateKey, srcHash);
+        console.log(`[agents] Updated bundled agent: ${file}`);
+    }
+}
+/** Create a new agent .md file. Returns error string or null on success. */
+export function createAgentFile(slug, name, description, model, systemPrompt, skills, tools) {
+    if (!SLUG_REGEX.test(slug)) {
+        return `Invalid slug '${slug}': must be kebab-case (a-z0-9 with hyphens).`;
+    }
+    const filePath = join(AGENTS_DIR, `${slug}.agent.md`);
+    if (!filePath.startsWith(AGENTS_DIR + sep)) {
+        return `Invalid slug '${slug}': path traversal detected.`;
+    }
+    if (existsSync(filePath)) {
+        return `Agent '${slug}' already exists. Edit it directly or remove it first.`;
+    }
+    // YAML value escaping for safe frontmatter
+    const escapedName = name.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+    const escapedDesc = description.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+    let frontmatter = `---\nname: "${escapedName}"\ndescription: "${escapedDesc}"\nmodel: ${model}`;
+    if (skills?.length)
+        frontmatter += `\nskills:\n${skills.map((s) => `  - ${s}`).join("\n")}`;
+    if (tools?.length)
+        frontmatter += `\ntools:\n${tools.map((t) => `  - ${t}`).join("\n")}`;
+    frontmatter += "\n---\n\n";
+    writeFileSync(filePath, frontmatter + systemPrompt + "\n");
+    return null;
+}
+/** Remove an agent .md file. Returns error string or null on success. */
+export function removeAgentFile(slug) {
+    if (!SLUG_REGEX.test(slug)) {
+        return `Invalid slug '${slug}'.`;
+    }
+    if (RESERVED_SLUGS.has(slug)) {
+        return `Cannot remove built-in agent '${slug}'. You can edit its file instead.`;
+    }
+    const filePath = join(AGENTS_DIR, `${slug}.agent.md`);
+    if (!filePath.startsWith(AGENTS_DIR + sep)) {
+        return `Invalid slug '${slug}': path traversal detected.`;
+    }
+    if (!existsSync(filePath)) {
+        return `Agent '${slug}' not found.`;
+    }
+    rmSync(filePath);
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Agent Session Management
+// ---------------------------------------------------------------------------
+// Per-agent task tracking (in-memory, backed by DB)
+const activeTasks = new Map();
+let taskCounter = 0;
+function nextTaskId() {
+    return `task-${++taskCounter}-${Date.now().toString(36)}`;
+}
+/** Shared base prompt injected into all agent sessions. */
+function getAgentBasePrompt() {
+    return `## Runtime Context
+
+You are an agent within Chapterhouse, a team-level AI assistant for engineering teams. You run on the user's local machine.
+
+### Shared Wiki
+All agents share a wiki knowledge base for persistent memory. Use \`wiki_read\` and \`wiki_search\` to find existing knowledge, and \`wiki_update\` to save important findings.
+
+### Communication
+- You receive tasks from @chapterhouse (the orchestrator) or directly from the user
+- Your results are relayed back to the user by @chapterhouse
+- To share knowledge with other agents, write to the wiki
+
+### Guidelines
+- Be thorough but concise in your responses
+- Use the wiki to check for existing context before starting work
+- Save important findings to the wiki for other agents to use
+`;
+}
+/** Build the full system message for an agent. */
+export function composeAgentSystemMessage(agent, rosterInfo) {
+    const base = getAgentBasePrompt();
+    const agentPrompt = agent.systemMessage;
+    // For @chapterhouse, inject the agent roster
+    if (agent.slug === "chapterhouse" && rosterInfo) {
+        return agentPrompt.replace("{agent_roster}", rosterInfo);
+    }
+    return `${agentPrompt}\n\n${base}`;
+}
+/** Build a roster description of all agents for @chapterhouse's system prompt. */
+export function buildAgentRoster(projectRoot) {
+    const agents = getAgentRegistry();
+    const chLines = agents
+        .filter((a) => a.slug !== "chapterhouse")
+        .map((a) => {
+        const model = a.model === "auto" ? "dynamic (you choose)" : a.model;
+        const skills = a.skills?.length ? ` | skills: ${a.skills.join(", ")}` : "";
+        return `- **@${a.slug}** — ${a.description} (model: ${model}${skills})`;
+    });
+    let squadLines = [];
+    if (projectRoot) {
+        try {
+            const squadRoster = renderProjectAgentRoster(projectRoot);
+            if (squadRoster) {
+                squadLines = squadRoster.split("\n").filter(Boolean);
+            }
+        }
+        catch {
+            // squad roster unavailable — skip
+        }
+    }
+    const allLines = [...chLines, ...squadLines];
+    if (allLines.length === 0)
+        return "No agents registered.";
+    return allLines.join("\n");
+}
+// The wiki tools that every agent gets regardless of tool config
+const WIKI_TOOL_NAMES = new Set([
+    "wiki_search", "wiki_read", "wiki_update", "remember", "recall", "forget",
+    "wiki_ingest", "wiki_lint", "wiki_rebuild_index",
+]);
+// Management tools that only @chapterhouse should have
+const MANAGEMENT_TOOL_NAMES = new Set([
+    "delegate_to_agent", "check_agent_status", "get_agent_result",
+    "show_agent_roster", "hire_agent", "fire_agent",
+    "switch_model", "toggle_auto", "list_models",
+    "restart_chapterhouse", "list_skills", "learn_skill", "uninstall_skill",
+    "list_machine_sessions", "attach_machine_session",
+]);
+/** Filter tools based on agent config. */
+export function filterToolsForAgent(agent, allTools) {
+    if (agent.tools && agent.tools.length > 0) {
+        // Agent specifies an explicit allowlist — give those + wiki tools
+        const allowed = new Set([...agent.tools, ...WIKI_TOOL_NAMES]);
+        return allTools.filter((t) => allowed.has(t.name));
+    }
+    // Default: all tools except management (only @chapterhouse gets those)
+    if (agent.slug === "chapterhouse") {
+        return allTools;
+    }
+    return allTools.filter((t) => !MANAGEMENT_TOOL_NAMES.has(t.name));
+}
+/** Create an ephemeral session for an agent. Always creates a fresh session — caller is responsible for destroying it. */
+export async function createEphemeralAgentSession(slug, client, allTools, modelOverride, systemMessagePrefix) {
+    const agent = getAgent(slug);
+    if (!agent)
+        throw new Error(`Agent '${slug}' not found in registry.`);
+    // Explicit override always wins. Otherwise use frontmatter model (with
+    // fallback to sonnet for "auto" agents that receive no override).
+    const model = (modelOverride && modelOverride.length > 0)
+        ? modelOverride
+        : (agent.model === "auto" ? "claude-sonnet-4.6" : agent.model);
+    const tools = filterToolsForAgent(agent, allTools);
+    const mcpServers = loadMcpConfig();
+    const skillDirectories = getSkillDirectories();
+    const baseSystemMessage = composeAgentSystemMessage(agent);
+    const systemMessageContent = systemMessagePrefix
+        ? `${systemMessagePrefix}\n\n${baseSystemMessage}`
+        : baseSystemMessage;
+    const session = await client.createSession({
+        model,
+        configDir: SESSIONS_DIR,
+        workingDirectory: process.cwd(),
+        streaming: true,
+        systemMessage: { content: systemMessageContent },
+        tools,
+        mcpServers,
+        skillDirectories,
+        onPermissionRequest: approveAll,
+        infiniteSessions: {
+            enabled: true,
+            backgroundCompactionThreshold: 0.80,
+            bufferExhaustionThreshold: 0.95,
+        },
+    });
+    console.log(`[agents] Created ephemeral session for @${agent.slug} (${model})`);
+    return session;
+}
+/** Create an ephemeral session for a squad virtual agent (not in CH registry). */
+export async function createSquadAgentSession(slug, client, allTools, systemMessagePrefix, modelOverride) {
+    const model = (modelOverride && modelOverride.length > 0)
+        ? modelOverride
+        : "claude-sonnet-4.6";
+    const squadTools = allTools.filter((t) => !MANAGEMENT_TOOL_NAMES.has(t.name));
+    const mcpServers = loadMcpConfig();
+    const skillDirectories = getSkillDirectories();
+    const session = await client.createSession({
+        model,
+        configDir: SESSIONS_DIR,
+        workingDirectory: process.cwd(),
+        streaming: true,
+        systemMessage: { content: systemMessagePrefix },
+        tools: squadTools,
+        mcpServers,
+        skillDirectories,
+        onPermissionRequest: approveAll,
+        infiniteSessions: {
+            enabled: true,
+            backgroundCompactionThreshold: 0.80,
+            bufferExhaustionThreshold: 0.95,
+        },
+    });
+    console.log(`[agents] Created squad virtual agent session for @${slug} (${model})`);
+    return session;
+}
+/** Clean up active task tracking (for shutdown/restart). */
+export async function clearActiveTasks() {
+    activeTasks.clear();
+}
+/** Get status info for an agent (task info only — no persistent sessions). */
+export function getAgentSessionStatus(slug) {
+    const tasks = Array.from(activeTasks.values()).filter((t) => t.agentSlug === slug);
+    return {
+        taskCount: tasks.length,
+        tasks,
+    };
+}
+/** Get all active tasks. */
+export function getActiveTasks() {
+    return Array.from(activeTasks.values());
+}
+/** Get a task by ID. */
+export function getTask(taskId) {
+    return activeTasks.get(taskId);
+}
+/** Register a new task. */
+export function registerTask(agentSlug, description, originChannel) {
+    const task = {
+        taskId: nextTaskId(),
+        agentSlug,
+        description,
+        status: "running",
+        startedAt: Date.now(),
+        originChannel,
+    };
+    activeTasks.set(task.taskId, task);
+    return task;
+}
+/** Mark a task as completed. */
+export function completeTask(taskId, result) {
+    const task = activeTasks.get(taskId);
+    if (task) {
+        task.status = "completed";
+        task.result = result;
+        task.completedAt = Date.now();
+    }
+}
+/** Mark a task as failed. */
+export function failTask(taskId, error) {
+    const task = activeTasks.get(taskId);
+    if (task) {
+        task.status = "error";
+        task.result = error;
+        task.completedAt = Date.now();
+    }
+}
+// ---------------------------------------------------------------------------
+// @mention routing
+// ---------------------------------------------------------------------------
+/** Active agent per conversation channel (sticky routing). */
+const activeAgentByChannel = new Map();
+/** Get the active agent for a channel. Returns "chapterhouse" if none set. */
+export function getActiveAgent(channel) {
+    return activeAgentByChannel.get(channel) || "chapterhouse";
+}
+/** Set the active agent for a channel. */
+export function setActiveAgent(channel, slug) {
+    activeAgentByChannel.set(channel, slug);
+}
+/** Parse @mention from message text. Returns agent slug and remaining message, or null. */
+export function parseAtMention(text, projectRoot) {
+    const match = text.match(/^@([a-zA-Z0-9-]+)\s*([\s\S]*)$/);
+    if (!match)
+        return null;
+    const mentionedName = match[1].toLowerCase();
+    const message = match[2].trim();
+    const agent = getAgent(mentionedName);
+    if (agent) {
+        return { agentSlug: agent.slug, message: message || "" };
+    }
+    if (projectRoot) {
+        try {
+            const squadAgent = findSquadAgent(projectRoot, mentionedName);
+            if (squadAgent) {
+                return { agentSlug: mentionedName, message: message || "" };
+            }
+        }
+        catch {
+            // squad lookup failed — fall through
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=agents.js.map

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

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const fixtureRoot = join(repoRoot, "src/test/fixtures/mock-squad-repo");
+const sandboxRoot = join(repoRoot, ".test-work", `agents-squad-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadAgentsModule() {
+    return await import(new URL(`./agents.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+test.before(() => {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+});
+test.beforeEach(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(join(sandboxRoot, ".chapterhouse"), { recursive: true });
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("buildAgentRoster includes squad agents when a project root is active", async () => {
+    const m = await loadAgentsModule();
+    m.ensureDefaultAgents();
+    m.loadAgents();
+    const roster = m.buildAgentRoster(fixtureRoot);
+    assert.match(roster, /@coder/);
+    assert.match(roster, /@ripley/);
+});
+test("parseAtMention resolves squad agents when project context is active", async () => {
+    const m = await loadAgentsModule();
+    m.ensureDefaultAgents();
+    m.loadAgents();
+    const result = m.parseAtMention("@ripley trace squad decisions", fixtureRoot);
+    assert.deepEqual(result, {
+        agentSlug: "ripley",
+        message: "trace squad decisions",
+    });
+});
+test("createEphemeralAgentSession prepends an optional system message prefix", async () => {
+    const m = await loadAgentsModule();
+    m.ensureDefaultAgents();
+    m.loadAgents();
+    let options;
+    const client = {
+        async createSession(nextOptions) {
+            options = nextOptions;
+            return { sessionId: "ephemeral-1" };
+        },
+    };
+    await m.createEphemeralAgentSession("coder", client, [{ name: "wiki_read" }], undefined, "PROJECT CONTEXT PREFIX");
+    assert.match(String(options?.systemMessage?.content || ""), /PROJECT CONTEXT PREFIX/);
+});
+test("createSquadAgentSession uses the provided system prefix and strips management tools", async () => {
+    const m = await loadAgentsModule();
+    assert.equal(typeof m.createSquadAgentSession, "function", "createSquadAgentSession should be exported");
+    let options;
+    const client = {
+        async createSession(nextOptions) {
+            options = nextOptions;
+            return { sessionId: "squad-1" };
+        },
+    };
+    await m.createSquadAgentSession("ripley", client, [
+        { name: "delegate_to_agent" },
+        { name: "wiki_read" },
+        { name: "bash" },
+    ], "SQUAD PREFIX");
+    assert.equal(options?.systemMessage?.content, "SQUAD PREFIX");
+    assert.deepEqual((options?.tools).map((tool) => tool.name).sort(), ["bash", "wiki_read"]);
+});
+//# sourceMappingURL=agents.squad.test.js.map

package/dist/copilot/classifier.js

@@ -0,0 +1,72 @@
+import { approveAll } from "@github/copilot-sdk";
+// ---------------------------------------------------------------------------
+// Persistent GPT-4.1 classifier session
+// ---------------------------------------------------------------------------
+const CLASSIFIER_MODEL = "gpt-4.1";
+const CLASSIFY_TIMEOUT_MS = 8_000;
+const SYSTEM_PROMPT = `You are a message complexity classifier for an AI assistant called Chapterhouse. Your ONLY job is to classify incoming user messages into one of three tiers. Respond with ONLY the tier name — nothing else.
+
+Tiers:
+- FAST: Greetings, thanks, acknowledgments, simple yes/no, trivial factual questions ("what time is it?", "hello", "thanks"), casual chat with no technical depth.
+- STANDARD: Coding tasks, file operations, tool usage requests, moderate reasoning, questions about technical topics, requests to create/check/manage things, anything involving code or development workflow.
+- PREMIUM: Complex architecture decisions, deep analysis, multi-step reasoning, comparing trade-offs, detailed explanations of complex topics, debugging intricate issues, designing systems, strategic planning.
+
+Rules:
+- If unsure, respond STANDARD (it's the safe default).
+- Respond with exactly one word: FAST, STANDARD, or PREMIUM.`;
+let classifierSession;
+let sessionClient;
+async function ensureSession(client) {
+    // Recreate if the client changed (e.g. after a reset)
+    if (classifierSession && sessionClient === client) {
+        return classifierSession;
+    }
+    // Destroy stale session
+    if (classifierSession) {
+        classifierSession.destroy().catch(() => { });
+        classifierSession = undefined;
+    }
+    classifierSession = await client.createSession({
+        model: CLASSIFIER_MODEL,
+        streaming: false,
+        systemMessage: { content: SYSTEM_PROMPT },
+        onPermissionRequest: approveAll,
+    });
+    sessionClient = client;
+    return classifierSession;
+}
+const TIER_MAP = {
+    FAST: "fast",
+    STANDARD: "standard",
+    PREMIUM: "premium",
+};
+/**
+ * Classify a message using GPT-4.1.
+ * Returns the tier, or null if the classifier is unavailable / times out.
+ */
+export async function classifyWithLLM(client, message) {
+    try {
+        const session = await ensureSession(client);
+        const result = await session.sendAndWait({ prompt: message }, CLASSIFY_TIMEOUT_MS);
+        const raw = (result?.data?.content || "").trim().toUpperCase();
+        return TIER_MAP[raw] ?? "standard";
+    }
+    catch (err) {
+        console.log(`[chapterhouse] Classifier error (falling back to heuristics): ${err instanceof Error ? err.message : err}`);
+        // Destroy broken session so it's recreated next time
+        if (classifierSession) {
+            classifierSession.destroy().catch(() => { });
+            classifierSession = undefined;
+        }
+        return null;
+    }
+}
+/** Tear down the classifier session (e.g. on shutdown). */
+export function stopClassifier() {
+    if (classifierSession) {
+        classifierSession.destroy().catch(() => { });
+        classifierSession = undefined;
+        sessionClient = undefined;
+    }
+}
+//# sourceMappingURL=classifier.js.map

package/dist/copilot/client.js

@@ -0,0 +1,32 @@
+import { CopilotClient } from "@github/copilot-sdk";
+import { config } from "../config.js";
+let client;
+export async function getClient() {
+    if (!client) {
+        client = new CopilotClient({
+            autoStart: true,
+            autoRestart: true,
+            gitHubToken: config.copilotAuthToken || undefined,
+        });
+        await client.start();
+    }
+    return client;
+}
+/** Tear down the existing client and create a fresh one. */
+export async function resetClient() {
+    if (client) {
+        try {
+            await client.stop();
+        }
+        catch { /* best-effort */ }
+        client = undefined;
+    }
+    return getClient();
+}
+export async function stopClient() {
+    if (client) {
+        await client.stop();
+        client = undefined;
+    }
+}
+//# sourceMappingURL=client.js.map