chapterhouse 0.3.1 → 0.3.3

package/dist/copilot/session-manager.test.js

@@ -0,0 +1,358 @@
+// ---------------------------------------------------------------------------
+// Tests for SessionManager and SessionRegistry
+// ---------------------------------------------------------------------------
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionManager, SessionRegistry, } from "./session-manager.js";
+function makeFakeSession() {
+    const tracker = {
+        disconnectCalls: 0,
+        abortCalls: 0,
+        session: null,
+    };
+    tracker.session = {
+        sessionId: "fake-" + Math.random().toString(36).slice(2),
+        async disconnect() { tracker.disconnectCalls++; },
+        async abort() { tracker.abortCalls++; },
+        on() { return () => { }; },
+        async sendAndWait() { return { data: { content: "ok" } }; },
+        async setModel() { },
+        getState() { return "connected"; },
+    };
+    return tracker;
+}
+function factory(session) {
+    return async () => session;
+}
+function makeDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+    const item = {
+        prompt: "test prompt",
+        callback: () => { },
+        sessionKey: "default",
+        resolve,
+        reject,
+    };
+    return { item, promise, resolve, reject };
+}
+// ---------------------------------------------------------------------------
+// SessionManager tests
+// ---------------------------------------------------------------------------
+test("SessionManager: canEvict is true when idle with empty queue", () => {
+    const { session } = makeFakeSession();
+    const manager = new SessionManager("default", async () => "ok", factory(session));
+    assert.equal(manager.isProcessing, false);
+    assert.equal(manager.queueDepth, 0);
+    assert.equal(manager.canEvict, true);
+});
+test("SessionManager: canEvict is false while processing, true after", async () => {
+    const { session } = makeFakeSession();
+    let unblock;
+    const worker = () => new Promise((r) => { unblock = () => r("done"); });
+    const manager = new SessionManager("default", worker, factory(session));
+    const { item } = makeDeferred();
+    manager.enqueue(item);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.isProcessing, true, "should be processing after enqueue");
+    assert.equal(manager.canEvict, false, "must not evict while processing");
+    unblock();
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.isProcessing, false, "should be idle after worker completes");
+    assert.equal(manager.canEvict, true, "can evict once idle");
+});
+test("SessionManager: canEvict is false when queue has pending items", async () => {
+    const { session } = makeFakeSession();
+    let unblock;
+    const worker = () => new Promise((r) => { unblock = () => r("done"); });
+    const manager = new SessionManager("default", worker, factory(session));
+    const { item: i1 } = makeDeferred();
+    const { item: i2 } = makeDeferred();
+    manager.enqueue(i1);
+    manager.enqueue(i2);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.queueDepth, 1, "second item still queued");
+    assert.equal(manager.canEvict, false, "must not evict with queued items");
+    unblock();
+    await new Promise((r) => setTimeout(r, 5));
+    assert.equal(manager.queueDepth, 0, "queue should drain");
+    // Clean up: unblock second (which completes instantly via the same worker closure)
+});
+test("SessionManager: cancelQueued drains pending queue items and rejects them", async () => {
+    const { session } = makeFakeSession();
+    let unblock;
+    const worker = () => new Promise((r) => { unblock = () => r("first"); });
+    const manager = new SessionManager("default", worker, factory(session));
+    const { item: i1 } = makeDeferred();
+    const { item: i2, promise: p2 } = makeDeferred();
+    const { item: i3, promise: p3 } = makeDeferred();
+    manager.enqueue(i1);
+    manager.enqueue(i2);
+    manager.enqueue(i3);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.queueDepth, 2, "two items queued while first processes");
+    const drained = manager.cancelQueued();
+    assert.equal(drained, 2, "two queued items should be cancelled");
+    await assert.rejects(p2, /Cancelled/, "item2 should reject with Cancelled");
+    await assert.rejects(p3, /Cancelled/, "item3 should reject with Cancelled");
+    unblock();
+    await new Promise((r) => setTimeout(r, 0));
+});
+test("SessionManager: evict disconnects session and rejects queued items", async () => {
+    const t1 = makeFakeSession();
+    let unblock;
+    const worker = () => new Promise((r) => { unblock = () => r("ok"); });
+    const manager = new SessionManager("default", worker, factory(t1.session));
+    const { item: i1 } = makeDeferred();
+    const { item: i2, promise: p2 } = makeDeferred();
+    manager.enqueue(i1);
+    manager.enqueue(i2);
+    await new Promise((r) => setTimeout(r, 0));
+    // Evict: rejects queued items and disconnects session
+    const evictDone = manager.evict("explicit-close");
+    await assert.rejects(p2, /evicted/, "queued item should be rejected with evicted");
+    await evictDone;
+    assert.equal(t1.disconnectCalls, 0, "session not yet created — no disconnect needed");
+    // Now with a primed session
+    const t2 = makeFakeSession();
+    const manager2 = new SessionManager("s2", async () => "ok", factory(t2.session));
+    await manager2.ensureSession();
+    await manager2.evict("explicit-close");
+    assert.equal(t2.disconnectCalls, 1, "session should be disconnected on evict");
+    unblock();
+    await new Promise((r) => setTimeout(r, 0));
+});
+test("SessionManager: abortCurrentTurn returns false when not processing", async () => {
+    const { session } = makeFakeSession();
+    const manager = new SessionManager("default", async () => "ok", factory(session));
+    await manager.ensureSession();
+    const aborted = await manager.abortCurrentTurn();
+    assert.equal(aborted, false);
+});
+test("SessionManager: abortCurrentTurn calls session.abort() when processing", async () => {
+    const t = makeFakeSession();
+    const worker = async (_item, mgr) => {
+        await mgr.ensureSession();
+        return new Promise(() => { }); // park forever
+    };
+    const manager = new SessionManager("default", worker, factory(t.session));
+    const { item } = makeDeferred();
+    manager.enqueue(item);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.isProcessing, true, "manager must be processing");
+    const aborted = await manager.abortCurrentTurn();
+    assert.equal(aborted, true, "abortCurrentTurn should return true");
+    assert.equal(t.abortCalls, 1, "session.abort() must be called once");
+});
+test("SessionManager: addRecentTier caps at 5 entries", () => {
+    const { session } = makeFakeSession();
+    const manager = new SessionManager("default", async () => "ok", factory(session));
+    for (let i = 0; i < 8; i++)
+        manager.addRecentTier("fast");
+    assert.equal(manager.recentTiers.length, 5, "should cap at 5 recent tiers");
+});
+// ---------------------------------------------------------------------------
+// SessionRegistry tests
+// ---------------------------------------------------------------------------
+function makeRegistry(opts = {}) {
+    const { idleTtlMs = 60_000, maxActive = 10 } = opts;
+    const disconnectLog = [];
+    const registry = new SessionRegistry({ idleTtlMs, maxActive }, (sk) => {
+        const t = makeFakeSession();
+        // Instrument disconnect to capture key
+        const orig = t.session.disconnect.bind(t.session);
+        t.session.disconnect = async () => {
+            disconnectLog.push(sk);
+            await orig();
+        };
+        return new SessionManager(sk, async () => "ok", factory(t.session));
+    });
+    return { registry, disconnectLog };
+}
+test("SessionRegistry: getOrCreate returns same manager for same key", () => {
+    const { registry } = makeRegistry();
+    const m1 = registry.getOrCreate("default");
+    const m2 = registry.getOrCreate("default");
+    assert.ok(m1 instanceof SessionManager);
+    assert.equal(m1, m2, "same key returns same manager");
+    assert.equal(registry.size(), 1);
+});
+test("SessionRegistry: LRU eviction fires when at maxActive capacity", async () => {
+    const { registry, disconnectLog } = makeRegistry({ maxActive: 3, idleTtlMs: 60_000 });
+    // Create 3 sessions with staggered timestamps so LRU is deterministic
+    const m1 = registry.getOrCreate("s1");
+    await new Promise((r) => setTimeout(r, 2));
+    registry.getOrCreate("s2");
+    await new Promise((r) => setTimeout(r, 2));
+    registry.getOrCreate("s3");
+    // Prime s1's session so it gets disconnected
+    await m1.ensureSession();
+    assert.equal(registry.size(), 3);
+    // Adding a 4th should evict s1 (oldest lastActivityAt)
+    registry.getOrCreate("s4");
+    await new Promise((r) => setTimeout(r, 5));
+    assert.equal(registry.size(), 3, "size should remain at max");
+    assert.ok(disconnectLog.includes("s1"), "s1 (oldest) should be LRU-evicted");
+    assert.ok(!registry.get("s1"), "s1 should be removed from registry");
+});
+test("SessionRegistry: explicit close evicts an idle session", async () => {
+    const { registry, disconnectLog } = makeRegistry();
+    const m = registry.getOrCreate("my-session");
+    await m.ensureSession();
+    assert.equal(registry.size(), 1);
+    registry.close("my-session", "explicit-close");
+    await new Promise((r) => setTimeout(r, 5));
+    assert.equal(registry.size(), 0, "session should be removed");
+    assert.ok(disconnectLog.includes("my-session"), "session should be disconnected");
+});
+test("SessionRegistry: close is deferred when session is processing", async () => {
+    const { registry, disconnectLog } = makeRegistry();
+    let unblock;
+    // Replace the factory with a blocking one
+    const { registry: reg2, disconnectLog: dl2 } = (() => {
+        const log = [];
+        const r = new SessionRegistry({ idleTtlMs: 60_000, maxActive: 10 }, (sk) => {
+            const t = makeFakeSession();
+            t.session.disconnect = async () => { log.push(sk); };
+            const worker = () => new Promise((res) => { unblock = () => res("done"); });
+            return new SessionManager(sk, worker, factory(t.session));
+        });
+        return { registry: r, disconnectLog: log };
+    })();
+    const m = reg2.getOrCreate("busy");
+    const { item } = makeDeferred();
+    m.enqueue(item);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(m.isProcessing, true);
+    // close() should be deferred (session is busy)
+    reg2.close("busy", "explicit-close");
+    await new Promise((r) => setTimeout(r, 5));
+    assert.ok(reg2.get("busy"), "busy session must remain in registry");
+    assert.equal(dl2.length, 0, "disconnect must not fire while processing");
+    unblock();
+    await new Promise((r) => setTimeout(r, 5));
+});
+test("SessionRegistry: pendingClose evicts session within ms of turn completion", async () => {
+    let unblock;
+    const disconnectLog = [];
+    const registry = new SessionRegistry({ idleTtlMs: 60_000, maxActive: 10 }, (sk) => {
+        const t = makeFakeSession();
+        t.session.disconnect = async () => { disconnectLog.push(sk); };
+        const worker = () => new Promise((res) => { unblock = () => res("done"); });
+        return new SessionManager(sk, worker, factory(t.session));
+    });
+    const m = registry.getOrCreate("session-a");
+    await m.ensureSession();
+    const { item } = makeDeferred();
+    m.enqueue(item);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(m.isProcessing, true, "should be processing");
+    // Close while busy — should set pendingClose, not evict yet
+    registry.close("session-a", "explicit-close");
+    assert.equal(m.pendingClose, true, "pendingClose must be set");
+    assert.ok(registry.get("session-a"), "session must remain in registry until turn finishes");
+    assert.equal(disconnectLog.length, 0, "must not disconnect mid-turn");
+    // Unblock the turn — session should be evicted within ms
+    unblock();
+    await new Promise((r) => setTimeout(r, 10));
+    assert.ok(!registry.get("session-a"), "session must be evicted after turn completes");
+    assert.ok(disconnectLog.includes("session-a"), "SDK session must be disconnected");
+});
+test("SessionRegistry: pendingClose waits for full queue drain before evicting", async () => {
+    let unblock1;
+    let unblock2;
+    const disconnectLog = [];
+    let callCount = 0;
+    const registry = new SessionRegistry({ idleTtlMs: 60_000, maxActive: 10 }, (sk) => {
+        const t = makeFakeSession();
+        t.session.disconnect = async () => { disconnectLog.push(sk); };
+        const worker = () => {
+            callCount++;
+            if (callCount === 1) {
+                return new Promise((res) => { unblock1 = () => res("turn1"); });
+            }
+            return new Promise((res) => { unblock2 = () => res("turn2"); });
+        };
+        return new SessionManager(sk, worker, factory(t.session));
+    });
+    const m = registry.getOrCreate("session-a");
+    await m.ensureSession();
+    const { item: item1 } = makeDeferred();
+    const { item: item2 } = makeDeferred();
+    m.enqueue(item1); // starts turn 1 immediately
+    await new Promise((r) => setTimeout(r, 0));
+    m.enqueue(item2); // queued while turn 1 runs
+    assert.equal(m.isProcessing, true, "should be processing turn 1");
+    assert.equal(m.queueDepth, 1, "turn 2 should be queued");
+    // Close while busy — should set pendingClose
+    registry.close("session-a", "explicit-close");
+    assert.equal(m.pendingClose, true, "pendingClose must be set");
+    // Unblock turn 1 — turn 2 is still queued, session must NOT evict yet
+    unblock1();
+    await new Promise((r) => setTimeout(r, 10));
+    assert.ok(registry.get("session-a"), "session must remain while turn 2 is still queued");
+    assert.equal(disconnectLog.length, 0, "must not disconnect until queue fully drains");
+    // Unblock turn 2 — queue is now empty, session must evict
+    unblock2();
+    await new Promise((r) => setTimeout(r, 10));
+    assert.ok(!registry.get("session-a"), "session must be evicted after queue fully drains");
+    assert.ok(disconnectLog.includes("session-a"), "SDK session must be disconnected after drain");
+});
+test("SessionRegistry: TTL eviction removes sessions idle beyond the TTL", async () => {
+    const SHORT_TTL = 40;
+    const { registry, disconnectLog } = makeRegistry({ idleTtlMs: SHORT_TTL });
+    const m = registry.getOrCreate("idle-session");
+    await m.ensureSession();
+    registry.startEvictionTimer();
+    // Wait past 3 × TTL — the eviction scan interval is min(TTL/2, 60s) = 20ms
+    await new Promise((r) => setTimeout(r, SHORT_TTL * 5));
+    registry.stopEvictionTimer();
+    assert.ok(disconnectLog.includes("idle-session"), "idle session must be evicted after TTL");
+    assert.ok(!registry.get("idle-session"), "idle session must be removed");
+});
+test("SessionRegistry: shutdown disconnects all sessions", async () => {
+    const { registry, disconnectLog } = makeRegistry();
+    for (const sk of ["a", "b", "c"]) {
+        const m = registry.getOrCreate(sk);
+        await m.ensureSession();
+    }
+    assert.equal(registry.size(), 3);
+    await registry.shutdown();
+    assert.equal(registry.size(), 0, "registry must be empty after shutdown");
+    assert.equal(disconnectLog.length, 3, "all sessions must be disconnected");
+});
+test("SessionRegistry: concurrent sessions process independently", async () => {
+    const completionOrder = [];
+    let unblockA;
+    const registry = new SessionRegistry({ idleTtlMs: 60_000, maxActive: 10 }, (sk) => {
+        const t = makeFakeSession();
+        const worker = async (_item, _mgr) => {
+            if (sk === "session-a") {
+                await new Promise((r) => { unblockA = r; });
+            }
+            completionOrder.push(sk);
+            return `${sk} done`;
+        };
+        return new SessionManager(sk, worker, factory(t.session));
+    });
+    const mA = registry.getOrCreate("session-a");
+    const mB = registry.getOrCreate("session-b");
+    const { item: iA, promise: pA } = makeDeferred();
+    const { item: iB, promise: pB } = makeDeferred();
+    mA.enqueue(iA);
+    mB.enqueue(iB);
+    // Session B should complete before session A (A is parked)
+    const resultB = await Promise.race([
+        pB,
+        new Promise((_, reject) => setTimeout(() => reject(new Error("session B was blocked by session A")), 200)),
+    ]);
+    assert.equal(resultB, "session-b done", "session B must complete independently");
+    assert.equal(completionOrder[0], "session-b", "session B must finish first");
+    assert.ok(mA.isProcessing, "session A should still be processing");
+    unblockA();
+    const resultA = await pA;
+    assert.equal(resultA, "session-a done");
+    assert.deepEqual(completionOrder, ["session-b", "session-a"]);
+});
+//# sourceMappingURL=session-manager.test.js.map

package/dist/copilot/system-message.js

@@ -1,5 +1,6 @@
 import { getExampleProjectPath } from "../home-path.js";
 export function getOrchestratorSystemMessage(opts) {
+    const versionBanner = opts?.version ? `\nYou are running inside chapterhouse v${opts.version}.\n` : "";
     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";
@@ -25,7 +26,7 @@ This restriction does NOT apply to:
         : "";
     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.
-
+${versionBanner}
 ${userContextBlock}
 ## Your Architecture
 

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

@@ -14,4 +14,12 @@ test("orchestrator prompt expands shorthand paths with the current home director
     assert.match(message, new RegExp(join(homedir(), "dev", "myapp").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
     assert.doesNotMatch(message, /"~\/dev\/myapp"/);
 });
+test("orchestrator prompt includes chapterhouse version banner when version is provided", () => {
+    const message = getOrchestratorSystemMessage({ version: "1.2.3" });
+    assert.match(message, /chapterhouse v1\.2\.3/);
+});
+test("orchestrator prompt omits version banner when version is not provided", () => {
+    const message = getOrchestratorSystemMessage();
+    assert.doesNotMatch(message, /chapterhouse v\d/);
+});
 //# sourceMappingURL=system-message.test.js.map

package/dist/copilot/workiq-installer.js

@@ -0,0 +1,91 @@
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync as fsMkdirSync, readFileSync as fsReadFileSync, writeFileSync as fsWriteFileSync } from "fs";
+import { childLogger } from "../util/logger.js";
+const log = childLogger("workiq-installer");
+export const WORKIQ_SERVER_KEY = "workiq";
+export const WORKIQ_PACKAGE = "@microsoft/workiq";
+export const MCP_CONFIG_PATH = join(homedir(), ".copilot", "mcp-config.json");
+/** Return true if the auto-install feature is active for the given config. */
+export function isWorkiqAutoInstallEnabled(opts) {
+    return opts.workiqAutoInstall && opts.entraAuthEnabled && Boolean(opts.entraTenantId);
+}
+/** Parse the raw JSON of a mcp-config.json file. Returns an empty object on any error. */
+export function parseMcpConfigFile(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Return true if the workiq entry already exists in the config. */
+export function workiqEntryExists(config) {
+    return Boolean(config.mcpServers &&
+        typeof config.mcpServers === "object" &&
+        WORKIQ_SERVER_KEY in config.mcpServers);
+}
+/** Build the workiq MCPStdioServerConfig entry. */
+export function buildWorkiqEntry() {
+    return {
+        command: "npx",
+        args: ["-y", WORKIQ_PACKAGE],
+        tools: ["*"],
+    };
+}
+/**
+ * Ensure the workiq MCP server entry is present in ~/.copilot/mcp-config.json.
+ *
+ * - Idempotent: if the entry already exists, returns early without writing.
+ * - Failure-safe: any I/O error is caught; a structured warn is emitted and
+ *   the function returns without throwing, so callers (daemon startup) continue.
+ *
+ * Returns "installed" | "already-present" | "skipped" for test assertions.
+ */
+export function ensureWorkiqMcpEntry(options = {}) {
+    const configPath = options.configPath ?? MCP_CONFIG_PATH;
+    const readFileFn = options.readFile ?? ((p, enc) => fsReadFileSync(p, enc));
+    const writeFileFn = options.writeFile ?? ((p, data, enc) => fsWriteFileSync(p, data, enc));
+    const mkdirFn = options.mkdirSync ?? ((p, opts) => fsMkdirSync(p, opts));
+    try {
+        let existingConfig = {};
+        try {
+            const raw = readFileFn(configPath, "utf-8");
+            existingConfig = parseMcpConfigFile(raw);
+        }
+        catch {
+            // File doesn't exist yet — start with empty config.
+        }
+        if (workiqEntryExists(existingConfig)) {
+            log.debug({ configPath }, "workiq MCP entry already present — skipping");
+            return "already-present";
+        }
+        // Ensure the parent directory exists
+        const parentDir = join(configPath, "..");
+        try {
+            mkdirFn(parentDir, { recursive: true });
+        }
+        catch {
+            // Best effort — directory may already exist; writeFile will fail loudly if not.
+        }
+        const updated = {
+            ...existingConfig,
+            mcpServers: {
+                ...(existingConfig.mcpServers ?? {}),
+                [WORKIQ_SERVER_KEY]: buildWorkiqEntry(),
+            },
+        };
+        writeFileFn(configPath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+        log.info({ configPath, package: WORKIQ_PACKAGE }, "workiq MCP server auto-installed");
+        return "installed";
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : String(err), configPath }, "workiq MCP auto-install failed — continuing without it");
+        return "skipped";
+    }
+}
+//# sourceMappingURL=workiq-installer.js.map

package/dist/copilot/workiq-installer.test.js

@@ -0,0 +1,148 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { isWorkiqAutoInstallEnabled, parseMcpConfigFile, workiqEntryExists, buildWorkiqEntry, ensureWorkiqMcpEntry, WORKIQ_SERVER_KEY, WORKIQ_PACKAGE, } from "./workiq-installer.js";
+// ---------------------------------------------------------------------------
+// isWorkiqAutoInstallEnabled
+// ---------------------------------------------------------------------------
+test("isWorkiqAutoInstallEnabled: true when all conditions met", () => {
+    assert.equal(isWorkiqAutoInstallEnabled({ entraAuthEnabled: true, entraTenantId: "tenant-id", workiqAutoInstall: true }), true);
+});
+test("isWorkiqAutoInstallEnabled: false when workiqAutoInstall disabled", () => {
+    assert.equal(isWorkiqAutoInstallEnabled({ entraAuthEnabled: true, entraTenantId: "tenant-id", workiqAutoInstall: false }), false);
+});
+test("isWorkiqAutoInstallEnabled: false when entraAuthEnabled is false", () => {
+    assert.equal(isWorkiqAutoInstallEnabled({ entraAuthEnabled: false, entraTenantId: "tenant-id", workiqAutoInstall: true }), false);
+});
+test("isWorkiqAutoInstallEnabled: false when entraTenantId is empty", () => {
+    assert.equal(isWorkiqAutoInstallEnabled({ entraAuthEnabled: true, entraTenantId: "", workiqAutoInstall: true }), false);
+});
+// ---------------------------------------------------------------------------
+// parseMcpConfigFile
+// ---------------------------------------------------------------------------
+test("parseMcpConfigFile: parses valid JSON with mcpServers", () => {
+    const raw = JSON.stringify({ mcpServers: { existing: {} } });
+    const result = parseMcpConfigFile(raw);
+    assert.deepEqual(result, { mcpServers: { existing: {} } });
+});
+test("parseMcpConfigFile: returns empty object for invalid JSON", () => {
+    const result = parseMcpConfigFile("not-json");
+    assert.deepEqual(result, {});
+});
+test("parseMcpConfigFile: returns empty object for null", () => {
+    const result = parseMcpConfigFile("null");
+    assert.deepEqual(result, {});
+});
+test("parseMcpConfigFile: returns empty object for array", () => {
+    const result = parseMcpConfigFile("[]");
+    assert.deepEqual(result, {});
+});
+test("parseMcpConfigFile: parses JSON without mcpServers key", () => {
+    const result = parseMcpConfigFile('{"other":"value"}');
+    assert.deepEqual(result, { other: "value" });
+});
+// ---------------------------------------------------------------------------
+// workiqEntryExists
+// ---------------------------------------------------------------------------
+test("workiqEntryExists: true when workiq key present", () => {
+    assert.equal(workiqEntryExists({ mcpServers: { workiq: {} } }), true);
+});
+test("workiqEntryExists: false when workiq key absent", () => {
+    assert.equal(workiqEntryExists({ mcpServers: { other: {} } }), false);
+});
+test("workiqEntryExists: false when mcpServers missing", () => {
+    assert.equal(workiqEntryExists({}), false);
+});
+// ---------------------------------------------------------------------------
+// buildWorkiqEntry
+// ---------------------------------------------------------------------------
+test("buildWorkiqEntry: returns correct npx entry shape", () => {
+    const entry = buildWorkiqEntry();
+    assert.equal(entry.command, "npx");
+    assert.deepEqual(entry.args, ["-y", WORKIQ_PACKAGE]);
+    assert.deepEqual(entry.tools, ["*"]);
+});
+// ---------------------------------------------------------------------------
+// ensureWorkiqMcpEntry
+// ---------------------------------------------------------------------------
+function makeFs(initialJson) {
+    let stored = initialJson ?? null;
+    const written = [];
+    return {
+        readFile: (path, _enc) => {
+            if (stored === null)
+                throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+            return stored;
+        },
+        writeFile: (path, data, _enc) => {
+            stored = data;
+            written.push(data);
+        },
+        mkdirSync: (_path, _opts) => { },
+        written,
+        getStored: () => stored,
+    };
+}
+test("ensureWorkiqMcpEntry: installs when file does not exist", () => {
+    const fs = makeFs();
+    const result = ensureWorkiqMcpEntry({ configPath: "/fake/mcp-config.json", ...fs });
+    assert.equal(result, "installed");
+    const written = JSON.parse(fs.getStored());
+    assert.ok(written.mcpServers?.[WORKIQ_SERVER_KEY]);
+    assert.equal(written.mcpServers[WORKIQ_SERVER_KEY].command, "npx");
+});
+test("ensureWorkiqMcpEntry: installs when file exists without workiq entry", () => {
+    const initial = JSON.stringify({ mcpServers: { other: { command: "node", args: [], tools: ["*"] } } });
+    const fs = makeFs(initial);
+    const result = ensureWorkiqMcpEntry({ configPath: "/fake/mcp-config.json", ...fs });
+    assert.equal(result, "installed");
+    const written = JSON.parse(fs.getStored());
+    assert.ok(written.mcpServers?.other, "existing entry preserved");
+    assert.ok(written.mcpServers?.[WORKIQ_SERVER_KEY], "workiq entry added");
+});
+test("ensureWorkiqMcpEntry: already-present when workiq entry exists", () => {
+    const initial = JSON.stringify({ mcpServers: { workiq: { command: "npx", args: ["-y", "@microsoft/workiq"], tools: ["*"] } } });
+    const fs = makeFs(initial);
+    const result = ensureWorkiqMcpEntry({ configPath: "/fake/mcp-config.json", ...fs });
+    assert.equal(result, "already-present");
+    assert.equal(fs.written.length, 0, "no write performed");
+});
+test("ensureWorkiqMcpEntry: idempotent on second call", () => {
+    const fs = makeFs();
+    ensureWorkiqMcpEntry({ configPath: "/fake/mcp-config.json", ...fs });
+    const result2 = ensureWorkiqMcpEntry({ configPath: "/fake/mcp-config.json", ...fs });
+    assert.equal(result2, "already-present");
+    assert.equal(fs.written.length, 1, "only one write total");
+});
+test("ensureWorkiqMcpEntry: returns skipped on write failure", () => {
+    const failingWrite = (_p, _d, _e) => {
+        throw new Error("EROFS: read-only file system");
+    };
+    const result = ensureWorkiqMcpEntry({
+        configPath: "/fake/mcp-config.json",
+        readFile: (_p, _e) => { throw Object.assign(new Error("ENOENT"), { code: "ENOENT" }); },
+        writeFile: failingWrite,
+        mkdirSync: () => { },
+    });
+    assert.equal(result, "skipped");
+});
+test("ensureWorkiqMcpEntry: preserves other mcpServers entries on install", () => {
+    const initial = JSON.stringify({
+        mcpServers: {
+            custom: { command: "node", args: ["server.js"], tools: ["myTool"] },
+        },
+        someOtherKey: true,
+    });
+    const fs = makeFs(initial);
+    ensureWorkiqMcpEntry({ configPath: "/fake/mcp-config.json", ...fs });
+    const written = JSON.parse(fs.getStored());
+    assert.ok(written.mcpServers?.custom, "existing server preserved");
+    assert.equal(written.someOtherKey, true, "unrelated keys preserved");
+});
+test("ensureWorkiqMcpEntry: creates well-formed JSON ending in newline", () => {
+    const fs = makeFs();
+    ensureWorkiqMcpEntry({ configPath: "/fake/mcp-config.json", ...fs });
+    assert.ok(fs.getStored().endsWith("\n"), "file ends with newline");
+    // Verify it's valid JSON
+    assert.doesNotThrow(() => JSON.parse(fs.getStored()));
+});
+//# sourceMappingURL=workiq-installer.test.js.map

package/dist/daemon.js

@@ -17,6 +17,8 @@ import { StandupScheduler } from "./copilot/standup.js";
 import { DecisionsSyncScheduler } from "./squad/mirror.scheduler.js";
 import { registerShutdownSignals } from "./shutdown-signals.js";
 import { logger } from "./util/logger.js";
+import { CHAPTERHOUSE_VERSION } from "./version.js";
+import { isWorkiqAutoInstallEnabled, ensureWorkiqMcpEntry } from "./copilot/workiq-installer.js";
 const log = logger.child({ module: "daemon" });
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 /**
@@ -78,7 +80,7 @@ function truncate(text, max = 200) {
     return oneLine.length > max ? oneLine.slice(0, max) + "…" : oneLine;
 }
 async function main() {
-    log.info("Starting Chapterhouse daemon");
+    log.info({ version: CHAPTERHOUSE_VERSION }, "Starting Chapterhouse daemon");
     if (config.selfEditEnabled) {
         log.warn("Self-edit mode enabled — Chapterhouse can modify his own source code");
     }
@@ -118,6 +120,15 @@ async function main() {
     if (process.env.TELEGRAM_BOT_TOKEN) {
         log.warn("TELEGRAM_BOT_TOKEN found in env — Telegram support was removed in v2. The web UI is now the only client.");
     }
+    // Auto-install workiq MCP server when Entra is configured
+    if (isWorkiqAutoInstallEnabled({
+        entraAuthEnabled: config.entraAuthEnabled,
+        entraTenantId: config.entraTenantId,
+        workiqAutoInstall: config.workiqAutoInstall,
+    })) {
+        log.info("Entra auth detected — ensuring workiq MCP server is configured");
+        ensureWorkiqMcpEntry();
+    }
     // Start Copilot SDK client
     log.info("Starting Copilot SDK client");
     const client = await getClient();