chapterhouse 0.9.2 → 0.11.0

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

@@ -33,6 +33,37 @@ test("createTools registers OKR progress tools", async () => {
     assert.ok(tools.some((tool) => tool.name === "get_my_okrs"));
     assert.ok(tools.some((tool) => tool.name === "write_team_wiki"));
 });
+test("get_my_okrs does not fall back to the last authenticated user outside a turn", async () => {
+    const toolsModule = await loadToolsModule();
+    assert.ok(toolsModule, "tools module should exist");
+    const dbModule = await import("../store/db.js");
+    dbModule.setState("last_authenticated_user", JSON.stringify({
+        id: "u-ada",
+        name: "Ada Lovelace",
+        email: "ada@example.com",
+        role: "engineer",
+    }));
+    let fetchAttempts = 0;
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+        createTeamPushClient: () => ({
+            async pushUpdate() {
+                throw new Error("not used in this test");
+            },
+            async fetchOKRs() {
+                fetchAttempts += 1;
+                return "";
+            },
+            async writePage(path) {
+                return { ok: true, path };
+            },
+        }),
+    });
+    const result = await tools.find((tool) => tool.name === "get_my_okrs")?.handler({});
+    assert.match(result, /current user identity/i);
+    assert.equal(fetchAttempts, 0, "tool must not use persisted last-user identity");
+});
 test("log_okr_progress suggests a KR when the user did not specify one", async () => {
     const toolsModule = await loadToolsModule();
     assert.ok(toolsModule, "tools module should exist");

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

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
+import { withWikiWrite } from "../wiki/lock.js";
 async function loadToolsModule() {
     return await import(new URL(`./tools.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
 }
@@ -513,9 +514,11 @@ updated: 2026-05-12
 
 # Rust
 `);
-    for (const entry of indexManager.parseIndex()) {
-        indexManager.removeFromIndex(entry.path);
-    }
+    await withWikiWrite(() => {
+        for (const entry of indexManager.parseIndex()) {
+            indexManager.removeFromIndex(entry.path);
+        }
+    });
     assert.equal(indexManager.parseIndex().length, 0, "Precondition: wiki_pages should start empty");
     const result = await wikiReindex.handler({});
     assert.match(result, /^Reindexed \d+ wiki page\(s\) from disk\.$/);

package/dist/copilot/turn-event-log.js

@@ -44,12 +44,37 @@ const turnBuffers = new Map();
 const turnListeners = new Map();
 /** Per-session ring buffer for SSE reconnect replay (sliding window across turns). */
 const sessionBuffers = new Map();
-/** Per-session live listeners (SSE connections). */
+/** Warn when one session accumulates an unusual number of SSE listeners. */
+export const SESSION_LISTENER_WARN_THRESHOLD = 50;
+/** Hard cap to evict oldest leaked SSE listeners for one session. */
+export const SESSION_LISTENER_MAX = 100;
+/** Per-session live listeners (SSE connections), insertion-ordered for oldest-first eviction. */
 const sessionListeners = new Map();
 /** Pending clear-buffer timers keyed by turnId. */
 const clearTimers = new Map();
 /** Monotonic global sequence counter — used as SSE `id:` for Last-Event-ID replay. */
 let globalSeq = 0;
+function warnHighSessionListenerCount(sessionKey, listenerCount) {
+    if (listenerCount !== SESSION_LISTENER_WARN_THRESHOLD + 1)
+        return;
+    log.warn({ sessionKey, listenerCount, threshold: SESSION_LISTENER_WARN_THRESHOLD }, "turn-event-log: high session listener count may indicate leaked SSE subscribers");
+}
+function evictOverflowSessionListeners(sessionKey, listeners) {
+    const overflow = listeners.size - SESSION_LISTENER_MAX;
+    if (overflow <= 0)
+        return;
+    let evicted = 0;
+    for (const [listener] of listeners) {
+        listeners.delete(listener);
+        evicted += 1;
+        if (evicted >= overflow)
+            break;
+    }
+    if (listeners.size === 0) {
+        sessionListeners.delete(sessionKey);
+    }
+    log.warn({ sessionKey, evicted, listenerCount: listeners.size, maxListeners: SESSION_LISTENER_MAX }, "turn-event-log: evicted oldest session listeners after exceeding the max listener cap");
+}
 // ---------------------------------------------------------------------------
 // Emit
 // ---------------------------------------------------------------------------
@@ -90,7 +115,7 @@ export function emitTurnEvent(sessionKey, event) {
     // Notify per-session listeners (SSE connections) -------------------------
     const sListeners = sessionListeners.get(sessionKey);
     if (sListeners) {
-        for (const fn of sListeners) {
+        for (const fn of sListeners.keys()) {
             try {
                 fn(indexed);
             }
@@ -169,10 +194,12 @@ export function subscribeSession(sessionKey, listener, afterSeq) {
     // Register live listener
     let ls = sessionListeners.get(sessionKey);
     if (!ls) {
-        ls = new Set();
+        ls = new Map();
         sessionListeners.set(sessionKey, ls);
     }
-    ls.add(listener);
+    ls.set(listener, true);
+    warnHighSessionListenerCount(sessionKey, ls.size);
+    evictOverflowSessionListeners(sessionKey, ls);
     return () => {
         const set = sessionListeners.get(sessionKey);
         if (set) {

package/dist/copilot/turn-event-log.test.js

@@ -22,17 +22,24 @@
  * SQLite-dependent functions (persistTurnEvents, getSessionEventsFromDb) are
  * tested in the integration suite to avoid needing a real DB here.
  */
-import { describe, it, afterEach } from "node:test";
+import { describe, it, afterEach, after } from "node:test";
 import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
 import { setTimeout as setTimeoutPromise } from "node:timers/promises";
-import { emitTurnEvent, subscribeTurn, subscribeSession, clearTurnLog, scheduleClearTurnLog, turnLogSize, oldestSessionSeq, persistTurnEvents, getSessionEventsFromDb, TURN_BUFFER_CAPACITY, SESSION_BUFFER_CAPACITY, } from "./turn-event-log.js";
+import { emitTurnEvent, subscribeTurn, subscribeSession, clearTurnLog, scheduleClearTurnLog, turnLogSize, oldestSessionSeq, persistTurnEvents, getSessionEventsFromDb, TURN_BUFFER_CAPACITY, SESSION_BUFFER_CAPACITY, SESSION_LISTENER_MAX, } from "./turn-event-log.js";
 import { getDb } from "../store/db.js";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 let turnCounter = 0;
 let sessionCounter = 0;
 const usedSessionKeys = [];
+const sandboxRoot = join(process.cwd(), ".test-work", `turn-event-log-${process.pid}`);
+mkdirSync(sandboxRoot, { recursive: true });
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+resetSingletons();
 function freshTurnId() {
     return `turn-test-${++turnCounter}-${Date.now()}`;
 }
@@ -76,6 +83,10 @@ afterEach(() => {
         }
     }
 });
+after(() => {
+    resetSingletons();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
 function trackTurn(turnId) {
     usedTurnIds.push(turnId);
     return turnId;
@@ -260,6 +271,17 @@ describe("turn-event-log", () => {
             emitTurnEvent(session, makeComplete(turnId, session));
             assert.equal(received.length, 1);
         });
+        it("evicts the oldest session listeners when one session exceeds the max listener cap", () => {
+            const session = freshSessionKey();
+            const turnId = trackTurn(freshTurnId());
+            const deliveries = Array.from({ length: SESSION_LISTENER_MAX + 1 }, () => []);
+            for (const received of deliveries) {
+                trackUnsub(subscribeSession(session, (event) => received.push(event)));
+            }
+            emitTurnEvent(session, makeStarted(turnId, session));
+            assert.equal(deliveries[0]?.length, 0, "oldest listener should be evicted once the cap is exceeded");
+            assert.equal(deliveries.at(-1)?.length, 1, "most recent listener should still receive events");
+        });
         it("two sessions are isolated from each other", () => {
             const session1 = freshSessionKey();
             const session2 = freshSessionKey();

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

@@ -68,12 +68,12 @@ function makeFs(initialJson) {
     let stored = initialJson ?? null;
     const written = [];
     return {
-        readFile: (path, _enc) => {
+        readFile: (_path, _enc) => {
             if (stored === null)
                 throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
             return stored;
         },
-        writeFile: (path, data, _enc) => {
+        writeFile: (_path, data, _enc) => {
             stored = data;
             written.push(data);
         },

package/dist/daemon-install.js

@@ -7,6 +7,7 @@ import { execSync, execFileSync } from "child_process";
 import { existsSync, mkdirSync, writeFileSync, rmSync } from "fs";
 import { join, dirname } from "path";
 import { homedir, platform } from "os";
+import { config } from "./config.js";
 /** The launchd label / systemd unit name. */
 export const DAEMON_LABEL = "com.bketelsen.chapterhouse";
 export const DAEMON_UNIT_NAME = "chapterhouse";
@@ -80,7 +81,7 @@ function composeMacOSPath(binDir, shellPath) {
 /** Generate the launchd plist XML string. */
 export function generatePlist(options) {
     const label = options.label ?? DAEMON_LABEL;
-    const shellPath = options.shellPath ?? process.env.PATH ?? "";
+    const shellPath = options.shellPath ?? config.shellPath;
     const richPath = composeMacOSPath(dirname(options.binPath), shellPath);
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -135,7 +136,7 @@ function composeSystemdPath(binDir, shellPath) {
 /** Generate the systemd user unit file string. */
 export function generateSystemdUnit(options) {
     const description = options.description ?? "Chapterhouse AI assistant daemon";
-    const shellPath = options.shellPath ?? process.env.PATH ?? "";
+    const shellPath = options.shellPath ?? config.shellPath;
     const richPath = composeSystemdPath(dirname(options.binPath), shellPath);
     return `[Unit]
 Description=${description}

package/dist/daemon.js

@@ -12,6 +12,7 @@ import { checkForUpdate } from "./update.js";
 import { ensureWikiStructure } from "./wiki/fs.js";
 import { seedTeamWiki } from "./wiki/seed-team-wiki.js";
 import { shouldMigrate, migrateMemoriesToWiki, shouldReorganize, reorganizeWiki } from "./wiki/migrate.js";
+import { withWikiWrite } from "./wiki/lock.js";
 import { shouldEnforceTopics, enforceTopicStructure } from "./wiki/migrate-topics.js";
 import { SESSIONS_DIR } from "./paths.js";
 import { getDisplayHost } from "./api/server-runtime.js";
@@ -37,15 +38,7 @@ const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
  *   Layer 3 — systemd kill:      TimeoutStopSec=90 s (must exceed layer 2)
  * Allows in-flight LLM streams to complete before the process is torn down.
  */
-const SHUTDOWN_TIMEOUT_MS = (() => {
-    const env = process.env.CHAPTERHOUSE_SHUTDOWN_TIMEOUT_MS;
-    if (env) {
-        const parsed = parseInt(env, 10);
-        if (!isNaN(parsed) && parsed > 0)
-            return parsed;
-    }
-    return 60_000;
-})();
+const SHUTDOWN_TIMEOUT_MS = config.shutdownTimeoutMs;
 /** Remove orphaned session folders older than 7 days, preserving the current session. */
 function pruneOldSessions() {
     try {
@@ -95,10 +88,9 @@ async function main() {
     for (const warning of config.modeCompatibilityWarnings) {
         log.warn({ mode: config.chapterhouseMode }, warning);
     }
+    log.info({ capabilities: modeContext.getCapabilities() }, modeContext.getStartupCapabilitySummary());
     // Set up message logging to daemon console
     setMessageLogger((direction, source, text) => {
-        const arrow = direction === "in" ? "⟶" : "⟵";
-        const tag = source.padEnd(8);
         log.debug({ direction, source, text: truncate(text) }, "chat");
     });
     // Initialize SQLite
@@ -110,19 +102,19 @@ async function main() {
         log.info("Created wiki");
     }
     if (modeContext.isTeam()) {
-        const seed = seedTeamWiki();
+        const seed = await withWikiWrite(() => seedTeamWiki());
         if (seed.created.length > 0) {
             log.info({ pages: seed.created }, "Seeded team wiki pages");
         }
     }
     if (shouldMigrate()) {
         log.info("Migrating SQLite memories to wiki");
-        const count = migrateMemoriesToWiki();
+        const count = await withWikiWrite(() => migrateMemoriesToWiki());
         log.info({ count }, "Migrated memories to wiki");
     }
     if (shouldReorganize()) {
         log.info("Reorganizing wiki pages into entity structure");
-        const count = reorganizeWiki();
+        const count = await withWikiWrite(() => reorganizeWiki());
         log.info({ count }, "Created entity pages during reorganization");
     }
     if (shouldEnforceTopics()) {
@@ -144,7 +136,7 @@ async function main() {
     // Prune orphaned session folders older than 7 days
     pruneOldSessions();
     // One-time deprecation note for legacy Telegram users (v1 → v2)
-    if (process.env.TELEGRAM_BOT_TOKEN) {
+    if (config.telegramBotTokenConfigured) {
         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
@@ -180,7 +172,7 @@ async function main() {
     }
     const url = `http://${getDisplayHost(config.apiHost)}:${config.apiPort}`;
     log.info({ url }, "Chapterhouse is fully operational");
-    if (process.env.CHAPTERHOUSE_OPEN_BROWSER === "1") {
+    if (config.openBrowserOnStart) {
         const opener = process.platform === "darwin" ? "open" :
             process.platform === "win32" ? "explorer.exe" : "xdg-open";
         try {
@@ -198,7 +190,7 @@ async function main() {
         }
     })
         .catch(() => { }); // silent — network may be unavailable
-    if (process.env.CHAPTERHOUSE_RESTARTED === "1") {
+    if (config.restarted) {
         delete process.env.CHAPTERHOUSE_RESTARTED;
     }
 }

package/dist/integrations/ado-client.js

@@ -4,6 +4,85 @@ import { ADO_ORG, ADO_PROJECT, FIELDS, STD_FIELDS, UNIT_FIELD, WIT } from "./ado
 function escapeWiqlLiteral(value) {
     return value.replace(/'/g, "''");
 }
+const ALLOWED_WIQL_FIELDS = new Set([
+    "System.Id",
+    "System.TeamProject",
+    "System.WorkItemType",
+    STD_FIELDS.TITLE,
+    STD_FIELDS.STATE,
+    STD_FIELDS.PARENT,
+    STD_FIELDS.ASSIGNED_TO,
+    STD_FIELDS.TAGS,
+    FIELDS.CURRENT_VALUE,
+    FIELDS.TARGET_VALUE,
+    FIELDS.OKR_PERIOD,
+    FIELDS.OKR_OWNER,
+    UNIT_FIELD,
+]);
+const ALLOWED_WIQL_OPERATORS = new Set(["=", "<>", "IN", "CONTAINS"]);
+const ALLOWED_WIQL_MACROS = new Set(["@project"]);
+function quoteWiqlField(field) {
+    if (!ALLOWED_WIQL_FIELDS.has(field)) {
+        throw new Error(`Unsupported WIQL field: ${field}`);
+    }
+    return `[${field}]`;
+}
+function normalizeWiqlOperator(operator) {
+    if (ALLOWED_WIQL_OPERATORS.has(operator)) {
+        return operator;
+    }
+    throw new Error(`Unsupported WIQL operator: ${operator}`);
+}
+function formatWiqlScalar(value) {
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error(`Unsupported WIQL number: ${value}`);
+        }
+        return String(value);
+    }
+    return `'${escapeWiqlLiteral(value)}'`;
+}
+function formatWiqlValue(value, operator) {
+    if (Array.isArray(value)) {
+        if (operator !== "IN") {
+            throw new Error(`WIQL operator ${operator} does not accept a list value.`);
+        }
+        if (value.length === 0) {
+            throw new Error("WIQL IN clauses require at least one value.");
+        }
+        return `(${value.map((item) => formatWiqlScalar(item)).join(", ")})`;
+    }
+    if (typeof value === "object" && value !== null && "macro" in value) {
+        if (!ALLOWED_WIQL_MACROS.has(value.macro)) {
+            throw new Error(`Unsupported WIQL macro: ${value.macro}`);
+        }
+        return value.macro;
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        return formatWiqlScalar(value);
+    }
+    throw new Error("Unsupported WIQL value.");
+}
+function formatWiqlCondition(condition) {
+    const field = quoteWiqlField(condition.field);
+    const operator = normalizeWiqlOperator(condition.operator);
+    return `${field} ${operator} ${formatWiqlValue(condition.value, operator)}`;
+}
+export function buildWiqlQuery(query) {
+    if (query.select.length === 0) {
+        throw new Error("WIQL queries must select at least one field.");
+    }
+    if (query.where.length === 0) {
+        throw new Error("WIQL queries must include at least one filter.");
+    }
+    const selectClause = query.select.map((field) => quoteWiqlField(field)).join(", ");
+    const whereClause = query.where.map((condition) => formatWiqlCondition(condition)).join(" AND ");
+    return [
+        `SELECT ${selectClause}`,
+        "FROM WorkItems",
+        `WHERE ${whereClause}`,
+    ].join(" ");
+}
 function getStringField(fields, fieldName) {
     const value = fields?.[fieldName];
     if (typeof value === "string") {
@@ -47,15 +126,17 @@ function toPercentComplete(currentValue, targetValue) {
     return Math.max(0, Math.min(100, Math.round((currentValue / targetValue) * 100)));
 }
 function buildWiql(workItemType, period) {
-    const periodClause = period
-        ? ` AND [${FIELDS.OKR_PERIOD}] = '${escapeWiqlLiteral(period)}'`
-        : "";
-    return [
-        "SELECT [System.Id]",
-        "FROM WorkItems",
-        "WHERE [System.TeamProject] = @project",
-        `AND [System.WorkItemType] = '${workItemType}'${periodClause}`,
-    ].join(" ");
+    const where = [
+        { field: "System.TeamProject", operator: "=", value: { macro: "@project" } },
+        { field: "System.WorkItemType", operator: "=", value: workItemType },
+    ];
+    if (period) {
+        where.push({ field: FIELDS.OKR_PERIOD, operator: "=", value: period });
+    }
+    return buildWiqlQuery({
+        select: ["System.Id"],
+        where,
+    });
 }
 function getWorkItemIds(result) {
     return (result.workItems ?? [])

package/dist/integrations/ado-client.test.js

@@ -173,4 +173,60 @@ test("getOKRSummary computes percent complete from KR progress", async () => {
     assert.equal(summary.objectives[0]?.keyResults[0]?.percentComplete, 75);
     assert.equal(summary.objectives[0]?.keyResults[1]?.percentComplete, 50);
 });
+test("buildWiqlQuery rejects non-whitelisted field names", async () => {
+    const ado = await loadAdoClientModule();
+    assert.ok(ado, "ado client module should exist");
+    assert.throws(() => ado.buildWiqlQuery({
+        select: ["System.Id"],
+        where: [
+            {
+                field: "System.Title] OR [System.Id",
+                operator: "=",
+                value: "Ship SSO to all tenants",
+            },
+        ],
+    }), /Unsupported WIQL field/);
+});
+test("buildWiqlQuery rejects non-whitelisted operators", async () => {
+    const ado = await loadAdoClientModule();
+    assert.ok(ado, "ado client module should exist");
+    assert.throws(() => ado.buildWiqlQuery({
+        select: ["System.Id"],
+        where: [
+            {
+                field: "System.Title",
+                operator: "= '' OR [System.Id] > 0",
+                value: "Ship SSO to all tenants",
+            },
+        ],
+    }), /Unsupported WIQL operator/);
+});
+test("getKeyResults escapes WIQL literal values before querying", async () => {
+    const ado = await loadAdoClientModule();
+    assert.ok(ado, "ado client module should exist");
+    const queries = [];
+    const client = new ado.AdoClient({
+        org: "https://dev.azure.com/example-org",
+        project: "example-project",
+        pat: "test-pat",
+        workItemTrackingApi: {
+            async queryByWiql(wiql) {
+                queries.push(wiql.query ?? "");
+                return { workItems: [] };
+            },
+            async getWorkItems() {
+                throw new Error("not used in this test");
+            },
+            async updateWorkItem() {
+                throw new Error("not used in this test");
+            },
+            async addComment() {
+                throw new Error("not used in this test");
+            },
+        },
+    });
+    await client.getKeyResults("2026-Q2' OR [System.Id] > 0 OR 'x'='x");
+    assert.equal(queries.length, 1);
+    assert.match(queries[0] ?? "", /\[Custom\.OKRPeriod\] = '2026-Q2'' OR \[System\.Id\] > 0 OR ''x''=''x'/);
+});
 //# sourceMappingURL=ado-client.test.js.map

package/dist/integrations/team-push.js

@@ -17,6 +17,7 @@ export class TeamPushClient {
         this.getCurrentUser = options.getCurrentUser;
         this.modeContext = new ModeContext({
             ...config,
+            chapterhouseMode: options.chapterhouseMode ?? config.chapterhouseMode,
             teamChapterhouseUrl: this.teamChapterhouseUrl,
             standaloneMode: this.standaloneMode,
         });

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

@@ -13,6 +13,7 @@ test("pushUpdate sends the expected payload to the team update endpoint", async
     assert.ok(teamPushModule, "team push module should exist");
     const requests = [];
     const client = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com/",
         standaloneMode: false,
         getAuthorizationHeader: () => "Bearer entra-token",
@@ -61,6 +62,7 @@ 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({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com",
         teamChapterhouseToken: "fallback-token",
         standaloneMode: false,
@@ -73,6 +75,7 @@ test("pushUpdate throws descriptive errors for auth and network failures", async
     });
     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({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com",
         standaloneMode: false,
         getAuthorizationHeader: () => "Bearer entra-token",
@@ -92,6 +95,7 @@ test("fetchOKRs returns raw OKR page content for the requested period", async ()
     assert.ok(teamPushModule, "team push module should exist");
     const requests = [];
     const client = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com",
         standaloneMode: false,
         getAuthorizationHeader: () => "Bearer entra-token",
@@ -120,6 +124,7 @@ test("writePage PUTs shared wiki content to the team wiki endpoint", async () =>
     assert.ok(teamPushModule, "team push module should exist");
     const requests = [];
     const client = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com/",
         standaloneMode: false,
         getAuthorizationHeader: () => "Bearer entra-token",
@@ -152,6 +157,7 @@ test("team push silently no-ops when team integration is disabled", async () =>
     assert.ok(teamPushModule, "team push module should exist");
     let called = false;
     const client = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "",
         standaloneMode: false,
         fetchImpl: async () => {

package/dist/integrations/teams-notify.js

@@ -17,6 +17,7 @@ export class TeamsNotifier {
         this.warn = options.warn ?? ((message) => log.warn(message));
         this.modeContext = new ModeContext({
             ...config,
+            chapterhouseMode: options.chapterhouseMode ?? config.chapterhouseMode,
             teamsWebhookUrl: this.webhookUrl,
             teamsNotificationsEnabled: this.enabled,
         });

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

@@ -13,6 +13,7 @@ test("sendMessage formats a Teams MessageCard payload", async () => {
     assert.ok(teamsNotify, "teams notifier module should exist");
     const calls = [];
     const notifier = new teamsNotify.TeamsNotifier({
+        chapterhouseMode: "team",
         webhookUrl: "https://teams.example.test/webhook",
         enabled: true,
         fetchImpl: async (input, init) => {
@@ -39,6 +40,7 @@ for (const milestone of [25, 50, 75, 100]) {
         assert.ok(teamsNotify, "teams notifier module should exist");
         const calls = [];
         const notifier = new teamsNotify.TeamsNotifier({
+            chapterhouseMode: "team",
             webhookUrl: "https://teams.example.test/webhook",
             enabled: true,
             fetchImpl: async (input, init) => {
@@ -70,6 +72,7 @@ test("sendMessage does not call Teams when notifications are disabled", async ()
     let fetchCalls = 0;
     const warnings = [];
     const notifier = new teamsNotify.TeamsNotifier({
+        chapterhouseMode: "team",
         webhookUrl: "https://teams.example.test/webhook",
         enabled: false,
         fetchImpl: async () => {
@@ -89,6 +92,7 @@ test("notifyWeeklyHealthCheck sends an OKR summary card", async () => {
     assert.ok(teamsNotify, "teams notifier module should exist");
     const calls = [];
     const notifier = new teamsNotify.TeamsNotifier({
+        chapterhouseMode: "team",
         webhookUrl: "https://teams.example.test/webhook",
         enabled: true,
         fetchImpl: async (input, init) => {
@@ -114,6 +118,7 @@ test("notifyStandup sends the member update summary", async () => {
     assert.ok(teamsNotify, "teams notifier module should exist");
     const calls = [];
     const notifier = new teamsNotify.TeamsNotifier({
+        chapterhouseMode: "team",
         webhookUrl: "https://teams.example.test/webhook",
         enabled: true,
         fetchImpl: async (input, init) => {

package/dist/memory/active-scope.test.js

@@ -34,7 +34,6 @@ test.after(async () => {
 test("active scope can be set, read, and cleared without changing scope activation status", async () => {
     const { dbModule, memoryModule } = await loadModules();
     dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
     const getActiveScope = getFunction(memoryModule, "getActiveScope");
     const setActiveScope = getFunction(memoryModule, "setActiveScope");
     const deactivateScope = getFunction(memoryModule, "deactivateScope");