chapterhouse 0.9.1 → 0.10.0

package/dist/memory/housekeeping.js

@@ -3,16 +3,17 @@ import { config } from "../config.js";
 import { getDb } from "../store/db.js";
 import { childLogger } from "../util/logger.js";
 import { getActiveScope } from "./active-scope.js";
+import { releaseScopeWriteLocks, tryAcquireScopeWriteLocks } from "./scope-lock.js";
 import { listScopes } from "./scopes.js";
 import { tieringPass } from "./tiering.js";
 export { tieringPass };
 const log = childLogger("memory.housekeeping");
-const SIMILARITY_THRESHOLD = 0.8;
 const GLOBAL_PASS_SCOPE = Symbol("global-housekeeping-pass-scope");
 const inFlightScopesByPass = new Map();
 const PASS_ORDER = [
     "dedup_observations",
     "dedup_decisions",
+    "compact_supersede_chains",
     "orphan_cleanup",
     "decay",
     "compact_inbox",
@@ -48,7 +49,7 @@ function isSimilar(left, right) {
     if (left.trim().toLowerCase() === right.trim().toLowerCase()) {
         return true;
     }
-    return jaccard(left, right) >= SIMILARITY_THRESHOLD;
+    return jaccard(left, right) >= config.memoryHousekeepingSimilarityThreshold;
 }
 function compareObservationKeeper(left, right) {
     if (right.confidence !== left.confidence) {
@@ -79,6 +80,11 @@ function normalizePassName(pass) {
         dedupdecisions: "dedup_decisions",
         dedupdecisionspass: "dedup_decisions",
         decisions: "dedup_decisions",
+        compact_supersede_chains: "compact_supersede_chains",
+        compactsupersedechains: "compact_supersede_chains",
+        compactsupersedechainspass: "compact_supersede_chains",
+        supersede: "compact_supersede_chains",
+        supersedechains: "compact_supersede_chains",
         orphan_cleanup: "orphan_cleanup",
         orphancleanup: "orphan_cleanup",
         orphancleanuppass: "orphan_cleanup",
@@ -189,6 +195,83 @@ export function dedupDecisionsPass(scopeId) {
         return passSummary("dedupDecisionsPass", 0, 0, [error instanceof Error ? error.message : String(error)]);
     }
 }
+function resolveSupersedeTerminal(startId, firstTargetId, supersededBy) {
+    const seen = new Set([startId]);
+    let current = firstTargetId;
+    while (true) {
+        if (seen.has(current)) {
+            return null;
+        }
+        seen.add(current);
+        const next = supersededBy.get(current);
+        if (next === undefined) {
+            return firstTargetId;
+        }
+        if (next === null) {
+            return current;
+        }
+        current = next;
+    }
+}
+export function compactSupersedeChainsPass(scopeId) {
+    try {
+        const db = getDb();
+        const observationRows = db.prepare(`
+      SELECT id, superseded_by
+      FROM mem_observations
+      WHERE scope_id = ?
+        AND superseded_by IS NOT NULL
+      ORDER BY id ASC
+    `).all(scopeId);
+        const decisionRows = db.prepare(`
+      SELECT id, superseded_by
+      FROM mem_decisions
+      WHERE scope_id = ?
+        AND superseded_by IS NOT NULL
+      ORDER BY id ASC
+    `).all(scopeId);
+        let modified = 0;
+        const tx = db.transaction(() => {
+            for (const { table, rows } of [
+                { table: "mem_observations", rows: observationRows },
+                { table: "mem_decisions", rows: decisionRows },
+            ]) {
+                const targetIds = [...new Set(rows.map((row) => row.superseded_by))];
+                const activeTargets = targetIds.length === 0
+                    ? undefined
+                    : db.prepare(`
+              SELECT id, superseded_by
+              FROM ${table}
+              WHERE scope_id = ?
+                AND id IN (${targetIds.map(() => "?").join(",")})
+            `);
+                const targets = targetIds.length === 0
+                    ? []
+                    : activeTargets.all(scopeId, ...targetIds);
+                const supersededBy = new Map();
+                for (const row of rows) {
+                    supersededBy.set(row.id, row.superseded_by);
+                }
+                for (const target of targets) {
+                    supersededBy.set(target.id, target.superseded_by);
+                }
+                const update = db.prepare(`UPDATE ${table} SET superseded_by = ? WHERE id = ? AND scope_id = ?`);
+                for (const row of rows) {
+                    const terminal = resolveSupersedeTerminal(row.id, row.superseded_by, supersededBy);
+                    if (terminal !== null && terminal !== row.superseded_by) {
+                        modified += update.run(terminal, row.id, scopeId).changes;
+                        supersededBy.set(row.id, terminal);
+                    }
+                }
+            }
+        });
+        tx();
+        return passSummary("compactSupersedeChainsPass", observationRows.length + decisionRows.length, modified);
+    }
+    catch (error) {
+        return passSummary("compactSupersedeChainsPass", 0, 0, [error instanceof Error ? error.message : String(error)]);
+    }
+}
 export function orphanCleanupPass(scopeId) {
     try {
         const db = getDb();
@@ -326,6 +409,8 @@ async function runPass(pass, scopeId) {
             return await Promise.resolve(dedupObservationsPass(scopeId));
         case "dedup_decisions":
             return await Promise.resolve(dedupDecisionsPass(scopeId));
+        case "compact_supersede_chains":
+            return await Promise.resolve(compactSupersedeChainsPass(scopeId));
         case "orphan_cleanup":
             return await Promise.resolve(orphanCleanupPass(scopeId));
         case "decay":
@@ -374,8 +459,19 @@ export async function runHousekeeping(opts = {}) {
             durationMs: 0,
         };
     }
+    const scopedPasses = passes.filter((pass) => pass !== "compact_inbox");
+    const lockedScopeIds = scopedPasses.length > 0 ? scopeIds : [];
+    if (lockedScopeIds.length > 0 && !tryAcquireScopeWriteLocks(lockedScopeIds)) {
+        releasePassScopes(reservedPassScopes);
+        return {
+            scopeIds,
+            summaries: [passSummary("runHousekeeping", 0, 0, ["Memory writes are already in flight for this scope."])],
+            totalExamined: 0,
+            totalModified: 0,
+            durationMs: 0,
+        };
+    }
     try {
-        const scopedPasses = passes.filter((pass) => pass !== "compact_inbox");
         const hasCompactInbox = passes.includes("compact_inbox");
         const summaries = (await Promise.all(scopeIds.map((scopeId) => runScopePasses(scopeId, scopedPasses)))).flat();
         if (hasCompactInbox) {
@@ -394,6 +490,7 @@ export async function runHousekeeping(opts = {}) {
         return { scopeIds, summaries, totalExamined, totalModified, durationMs };
     }
     finally {
+        releaseScopeWriteLocks(lockedScopeIds);
         releasePassScopes(reservedPassScopes);
     }
 }

package/dist/memory/housekeeping.test.js

@@ -25,6 +25,7 @@ async function loadMockedHousekeepingModule(t, options = {}) {
             config: {
                 memoryDecayDays: 30,
                 memoryInboxRetentionDays: 7,
+                memoryHousekeepingSimilarityThreshold: 0.8,
             },
         },
     });
@@ -136,7 +137,6 @@ test("dedupObservationsPass supersedes similar observations in scope determinist
 test("dedupDecisionsPass supersedes similar active decisions within scope and keeps the latest decision", async () => {
     const { dbModule, memoryModule, housekeepingModule } = await loadModules();
     const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordDecision = getFunction(memoryModule, "recordDecision");
     const team = createTestScope(memoryModule, "team");
@@ -182,6 +182,38 @@ test("dedupDecisionsPass supersedes similar active decisions within scope and ke
     const second = housekeepingModule.dedupDecisionsPass(team.id);
     assert.equal(second.modified, 0);
 });
+test("compactSupersedeChainsPass collapses long supersede chains without looping on cycles", async () => {
+    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
+    const db = dbModule.getDb();
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const recordDecision = getFunction(memoryModule, "recordDecision");
+    const team = createTestScope(memoryModule, "team");
+    const firstObservation = recordObservation({ scope_id: team.id, content: "First observation", source: "test" });
+    const middleObservation = recordObservation({ scope_id: team.id, content: "Middle observation", source: "test" });
+    const keeperObservation = recordObservation({ scope_id: team.id, content: "Keeper observation", source: "test" });
+    const cycleLeft = recordObservation({ scope_id: team.id, content: "Cycle left", source: "test" });
+    const cycleRight = recordObservation({ scope_id: team.id, content: "Cycle right", source: "test" });
+    db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ?`).run(middleObservation.id, firstObservation.id);
+    db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ?`).run(keeperObservation.id, middleObservation.id);
+    db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ?`).run(cycleRight.id, cycleLeft.id);
+    db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ?`).run(cycleLeft.id, cycleRight.id);
+    const firstDecision = recordDecision({ scope_id: team.id, title: "Use local memory", rationale: "Initial.", decided_at: "2026-05-10" });
+    const middleDecision = recordDecision({ scope_id: team.id, title: "Use scoped memory", rationale: "Refined.", decided_at: "2026-05-11" });
+    const keeperDecision = recordDecision({ scope_id: team.id, title: "Use tiered scoped memory", rationale: "Final.", decided_at: "2026-05-12" });
+    db.prepare(`UPDATE mem_decisions SET superseded_by = ? WHERE id = ?`).run(middleDecision.id, firstDecision.id);
+    db.prepare(`UPDATE mem_decisions SET superseded_by = ? WHERE id = ?`).run(keeperDecision.id, middleDecision.id);
+    const summary = housekeepingModule.compactSupersedeChainsPass(team.id);
+    assert.equal(summary.pass, "compactSupersedeChainsPass");
+    assert.equal(summary.modified, 2);
+    assert.deepEqual(summary.errors, []);
+    assert.equal(db.prepare(`SELECT superseded_by FROM mem_observations WHERE id = ?`).get(firstObservation.id).superseded_by, keeperObservation.id);
+    assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(firstDecision.id).superseded_by, keeperDecision.id);
+    assert.deepEqual(db.prepare(`SELECT id, superseded_by FROM mem_observations WHERE id IN (?, ?) ORDER BY id`).all(cycleLeft.id, cycleRight.id), [
+        { id: cycleLeft.id, superseded_by: cycleRight.id },
+        { id: cycleRight.id, superseded_by: cycleLeft.id },
+    ]);
+    assert.equal(housekeepingModule.compactSupersedeChainsPass(team.id).modified, 0);
+});
 test("orphanCleanupPass clears missing observation entity references without touching valid or out-of-scope rows", async () => {
     const { dbModule, memoryModule, housekeepingModule } = await loadModules();
     const db = dbModule.getDb();
@@ -321,7 +353,6 @@ test("runHousekeeping rejects overlapping runs that share an in-flight scope", a
 test("tieringPass promotes and demotes rows from lifecycle signals and is idempotent", async () => {
     const { dbModule, memoryModule, housekeepingModule } = await loadModules();
     const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const recordDecision = getFunction(memoryModule, "recordDecision");

package/dist/memory/reflect.test.js

@@ -29,6 +29,7 @@ async function loadReflectModule(t, llmResponse) {
     });
     t.mock.module("../util/logger.js", {
         namedExports: {
+            logger: { info: () => { }, warn: () => { }, error: () => { } },
             childLogger: () => ({ info: () => { }, warn: () => { }, error: () => { } }),
         },
     });
@@ -61,6 +62,7 @@ async function loadToolsModule(t) {
     });
     t.mock.module("../util/logger.js", {
         namedExports: {
+            logger: { info: () => { }, warn: () => { }, error: () => { } },
             childLogger: () => ({ info: () => { }, warn: () => { }, error: () => { } }),
         },
     });

package/dist/memory/scope-lock.js

@@ -0,0 +1,26 @@
+const inFlightScopeWrites = new Set();
+function uniqueScopeIds(scopeIds) {
+    return [...new Set(scopeIds)].sort((left, right) => left - right);
+}
+export function tryAcquireScopeWriteLocks(scopeIds) {
+    const uniqueScopeIdsToAcquire = uniqueScopeIds(scopeIds);
+    if (uniqueScopeIdsToAcquire.some((scopeId) => inFlightScopeWrites.has(scopeId))) {
+        return false;
+    }
+    for (const scopeId of uniqueScopeIdsToAcquire) {
+        inFlightScopeWrites.add(scopeId);
+    }
+    return true;
+}
+export function releaseScopeWriteLocks(scopeIds) {
+    for (const scopeId of uniqueScopeIds(scopeIds)) {
+        inFlightScopeWrites.delete(scopeId);
+    }
+}
+export function isScopeWriteLocked(scopeIds) {
+    if (!scopeIds || scopeIds.length === 0) {
+        return inFlightScopeWrites.size > 0;
+    }
+    return uniqueScopeIds(scopeIds).some((scopeId) => inFlightScopeWrites.has(scopeId));
+}
+//# sourceMappingURL=scope-lock.js.map

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

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+const sharedScope = {
+    id: 11,
+    slug: "shared",
+    title: "Shared",
+    description: "Shared scope for lock tests.",
+    keywords: ["shared"],
+    active: true,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+};
+async function loadModules(t, tieringPass) {
+    t.mock.module("../config.js", {
+        namedExports: {
+            config: {
+                copilotModel: "test-model",
+                memoryDecayDays: 30,
+                memoryInboxRetentionDays: 7,
+                memoryCheckpointTurns: 5,
+                memoryCheckpointEnabled: true,
+            },
+        },
+    });
+    t.mock.module("../copilot/oneshot.js", {
+        namedExports: {
+            runOneShotPrompt: async () => ({ content: JSON.stringify({ proposals: [] }) }),
+        },
+    });
+    t.mock.module("../store/db.js", {
+        namedExports: {
+            getDb: () => {
+                throw new Error("getDb should not be called in this test");
+            },
+        },
+    });
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: () => { },
+                error: () => { },
+            }),
+        },
+    });
+    t.mock.module("./active-scope.js", {
+        namedExports: {
+            getActiveScope: () => sharedScope,
+        },
+    });
+    t.mock.module("./scopes.js", {
+        namedExports: {
+            getScope: (slug) => (slug === sharedScope.slug ? sharedScope : null),
+            listScopes: () => [{ id: sharedScope.id, active: true }],
+        },
+    });
+    t.mock.module("./entities.js", {
+        namedExports: {
+            listEntities: () => [],
+        },
+    });
+    t.mock.module("./decisions.js", {
+        namedExports: {
+            listDecisions: () => [],
+            recordDecision: () => ({ id: 1 }),
+        },
+    });
+    t.mock.module("./observations.js", {
+        namedExports: {
+            listObservations: () => [],
+            recordObservation: () => ({ id: 1 }),
+        },
+    });
+    t.mock.module("./checkpoint-prompt.js", {
+        namedExports: {
+            buildCheckpointSystemPrompt: () => "system",
+            buildCheckpointUserPrompt: () => "user",
+        },
+    });
+    t.mock.module("./tiering.js", {
+        namedExports: {
+            tieringPass,
+        },
+    });
+    const checkpointModule = await import(new URL(`./checkpoint.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    const housekeepingModule = await import(new URL(`./housekeeping.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    return { checkpointModule, housekeepingModule };
+}
+test("runCheckpointExtraction skips writes while housekeeping holds the same scope lock", async (t) => {
+    let releaseHousekeeping;
+    const { checkpointModule, housekeepingModule } = await loadModules(t, async (scopeId) => {
+        assert.equal(scopeId, sharedScope.id);
+        await new Promise((resolve) => {
+            releaseHousekeeping = resolve;
+        });
+        return { pass: `tieringPass:${scopeId}`, examined: 1, modified: 1, errors: [] };
+    });
+    const housekeepingRun = housekeepingModule.runHousekeeping({ scopeIds: [sharedScope.id], passes: ["tiering"] });
+    await Promise.resolve();
+    const checkpointResult = await checkpointModule.runCheckpointExtraction({
+        turns: [{ user: "Remember this.", assistant: "Okay." }],
+        activeScope: sharedScope,
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            proposals: [
+                {
+                    kind: "observation",
+                    content: "Shared scope writes should not overlap housekeeping.",
+                    confidence: 0.95,
+                },
+            ],
+        }),
+    });
+    assert.deepEqual(checkpointResult, { written: 0, skipped: 0, errors: [] });
+    releaseHousekeeping?.();
+    await housekeepingRun;
+});
+//# sourceMappingURL=scope-lock.test.js.map

package/dist/memory/scopes.test.js

@@ -5,7 +5,6 @@ import test from "node:test";
 const repoRoot = process.cwd();
 const sandboxRoot = join(repoRoot, ".test-work", `memory-scopes-${process.pid}`);
 const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
-const dbPath = join(chapterhouseHome, "chapterhouse.db");
 process.env.CHAPTERHOUSE_HOME = sandboxRoot;
 async function loadModules() {
     const dbModule = await import(new URL("../store/db.js", import.meta.url).href);

package/dist/mode-context.js

@@ -1,3 +1,15 @@
+const CAPABILITY_MATRIX = {
+    personal: {
+        deploymentMode: "personal",
+        writePolicy: "personal",
+        integrationPolicy: "personal",
+    },
+    team: {
+        deploymentMode: "team",
+        writePolicy: "team-lead",
+        integrationPolicy: "team",
+    },
+};
 export class ModeContext {
     config;
     constructor(config) {
@@ -10,19 +22,60 @@ export class ModeContext {
         return this.config.chapterhouseMode === "team";
     }
     canSyncTeamWiki() {
-        return !this.config.standaloneMode && this.config.teamChapterhouseUrl.length > 0;
+        return this.getCapabilities().wikiSyncMode === "local+team";
     }
     canLogToAdo() {
-        return this.isPersonal();
+        return this.getCapabilities().integrationPolicy === "personal";
     }
     canSyncToTeams() {
-        return this.config.teamsNotificationsEnabled && this.config.teamsWebhookUrl.length > 0;
+        return (this.getCapabilities().integrationPolicy === "team" &&
+            this.config.teamsNotificationsEnabled &&
+            this.config.teamsWebhookUrl.length > 0);
     }
     getMemorySyncCapability() {
-        return this.canSyncTeamWiki() ? "local+team" : "local";
+        return this.getCapabilities().wikiSyncMode;
     }
     requiresEntraAuth() {
-        return this.isTeam() || this.config.entraAuthEnabled;
+        return this.getCapabilities().authMode === "entra";
+    }
+    getCapabilities() {
+        const modeCapabilities = CAPABILITY_MATRIX[this.config.chapterhouseMode];
+        if (!modeCapabilities) {
+            throw new Error(`Unknown CHAPTERHOUSE_MODE: "${this.config.chapterhouseMode}"`);
+        }
+        const authMode = this.getAuthMode();
+        return {
+            ...modeCapabilities,
+            authMode,
+            wikiSyncMode: this.getWikiSyncMode(authMode),
+        };
+    }
+    getStartupCapabilitySummary() {
+        const capabilities = this.getCapabilities();
+        return [
+            `deployment=${capabilities.deploymentMode}`,
+            `auth=${capabilities.authMode}`,
+            `wiki=${capabilities.wikiSyncMode}`,
+            `writes=${capabilities.writePolicy}`,
+            `integrations=${capabilities.integrationPolicy}`,
+        ].join(" ");
+    }
+    getAuthMode() {
+        if (this.config.standaloneMode) {
+            return "standalone";
+        }
+        if (this.config.entraAuthEnabled) {
+            return "entra";
+        }
+        return "api-token";
+    }
+    getWikiSyncMode(authMode) {
+        if (this.config.chapterhouseMode === "team" &&
+            authMode !== "standalone" &&
+            this.config.teamChapterhouseUrl.length > 0) {
+            return "local+team";
+        }
+        return "local";
     }
 }
 //# sourceMappingURL=mode-context.js.map

package/dist/mode-context.test.js

@@ -39,4 +39,72 @@ test("ModeContext exposes the expected team-mode capabilities", async () => {
     assert.equal(context.getMemorySyncCapability(), "local+team");
     assert.equal(context.requiresEntraAuth(), true);
 });
+test("ModeContext uses an explicit personal/team capability matrix", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.ModeContext, "function", "ModeContext should be exported");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parseRuntimeConfig = configModule.parseRuntimeConfig;
+    const createContext = (runtimeConfig) => new configModule.ModeContext(runtimeConfig);
+    const parsedPersonalWithTeamSettings = parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "personal",
+        API_TOKEN: "personal-token",
+        TEAM_CHAPTERHOUSE_URL: "https://team.example.com",
+        TEAMS_WEBHOOK_URL: "https://teams.example.com/webhook",
+        TEAMS_NOTIFICATIONS_ENABLED: "true",
+        ADO_ORG: "https://dev.azure.com/example",
+        ADO_PROJECT: "Project",
+        ADO_PAT: "personal-pat",
+    });
+    const personalWithTeamSettings = createContext({
+        ...parsedPersonalWithTeamSettings,
+        teamsWebhookUrl: "https://teams.example.com/webhook",
+        teamsNotificationsEnabled: true,
+    });
+    assert.deepEqual(personalWithTeamSettings.getCapabilities(), {
+        authMode: "api-token",
+        deploymentMode: "personal",
+        wikiSyncMode: "local",
+        writePolicy: "personal",
+        integrationPolicy: "personal",
+    });
+    assert.equal(personalWithTeamSettings.canSyncTeamWiki(), false);
+    assert.equal(personalWithTeamSettings.canSyncToTeams(), false);
+    assert.equal(personalWithTeamSettings.canLogToAdo(), true);
+    assert.equal(personalWithTeamSettings.requiresEntraAuth(), false);
+    const teamWithApiToken = createContext(parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "team",
+        API_TOKEN: "team-token",
+        TEAM_CHAPTERHOUSE_URL: "https://team.example.com",
+        ADO_ORG: "https://dev.azure.com/example",
+        ADO_PROJECT: "Project",
+        ADO_PAT: "team-pat",
+    }));
+    assert.deepEqual(teamWithApiToken.getCapabilities(), {
+        authMode: "api-token",
+        deploymentMode: "team",
+        wikiSyncMode: "local+team",
+        writePolicy: "team-lead",
+        integrationPolicy: "team",
+    });
+    assert.equal(teamWithApiToken.canSyncTeamWiki(), true);
+    assert.equal(teamWithApiToken.canLogToAdo(), false);
+    assert.equal(teamWithApiToken.requiresEntraAuth(), false);
+    assert.match(teamWithApiToken.getStartupCapabilitySummary(), /auth=api-token/);
+    assert.match(teamWithApiToken.getStartupCapabilitySummary(), /wiki=local\+team/);
+    const teamStandalone = createContext(parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "team",
+        TEAM_CHAPTERHOUSE_URL: "https://team.example.com",
+    }, {
+        apiTokenPath: ".test-work/missing-token",
+        exists: () => false,
+    }));
+    assert.deepEqual(teamStandalone.getCapabilities(), {
+        authMode: "standalone",
+        deploymentMode: "team",
+        wikiSyncMode: "local",
+        writePolicy: "team-lead",
+        integrationPolicy: "team",
+    });
+    assert.equal(teamStandalone.canSyncTeamWiki(), false);
+});
 //# sourceMappingURL=mode-context.test.js.map

package/dist/paths.js

@@ -4,6 +4,7 @@ import { mkdirSync } from "fs";
 import { normalizeWikiPath } from "./wiki/path-utils.js";
 /** Base directory for all Chapterhouse user data: ~/.chapterhouse */
 function resolveChapterhouseHome() {
+    // Bootstrap exception: config.ts depends on paths.ts to find ~/.chapterhouse/.env.
     const configuredHome = process.env.CHAPTERHOUSE_HOME?.trim();
     if (!configuredHome) {
         return join(homedir(), ".chapterhouse");

package/dist/setup.js

@@ -4,6 +4,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { CopilotClient } from "@github/copilot-sdk";
 import { CHAPTERHOUSE_HOME, ensureChapterhouseHome, ENV_PATH, WIKI_DIR } from "./paths.js";
 import { getExampleProjectPath } from "./home-path.js";
+import { config } from "./config.js";
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
 const GREEN = "\x1b[32m";
@@ -76,7 +77,7 @@ function readExistingEnv() {
     return { lines, values };
 }
 function resolveSetupMode(existing) {
-    const configured = process.env.CHAPTERHOUSE_MODE?.trim() || existing.CHAPTERHOUSE_MODE?.trim() || "personal";
+    const configured = config.explicitChapterhouseMode || existing.CHAPTERHOUSE_MODE?.trim() || "personal";
     return configured === "team" ? "team" : "personal";
 }
 function upsertEnvLines(lines, updates) {
@@ -101,7 +102,7 @@ function upsertEnvLines(lines, updates) {
     return nextLines;
 }
 function hasTokenEnv() {
-    return Boolean(process.env.GITHUB_TOKEN?.trim() || process.env.COPILOT_TOKEN?.trim());
+    return Boolean(config.copilotAuthToken);
 }
 function getGhAuthStatus() {
     try {