chapterhouse 0.13.1 → 0.14.1

package/dist/api/route-coverage.test.js

@@ -169,7 +169,7 @@ describe("route coverage — static analysis", () => {
         const routeFiles = readdirSync(ROUTES_DIR)
             .filter((name) => name.endsWith(".ts") && !name.endsWith(".test.ts"))
             .sort();
-        assert.deepEqual(routeFiles, ["agents.ts", "memory.ts", "projects.ts", "sessions.ts", "system.ts", "wiki.ts"]);
+        assert.deepEqual(routeFiles, ["agents.ts", "projects.ts", "sessions.ts", "system.ts", "wiki.ts"]);
     });
     test("server routes cover every unique normalised path (no obvious duplicates leaked)", () => {
         const serverPaths = extractServerPaths(readServerRouteSources());
@@ -191,8 +191,6 @@ describe("explicit auth route safeguards — static analysis", () => {
         assert.match(serverSrc, /\b(?:app|router)\.get\("\/api\/wiki\/korg\/sessions",\s*authMiddleware,/);
         assert.match(serverSrc, /\b(?:app|router)\.post\("\/api\/wiki\/ingest",\s*authMiddleware,\s*async \(req: Request, res: Response\) => \{/);
         assert.match(serverSrc, /\b(?:app|router)\.get\("\/api\/wiki\/search",\s*authMiddleware,\s*async \(req: Request, res: Response\) => \{/);
-        assert.match(serverSrc, /\b(?:app|router)\.post\("\/api\/memory\/hooks\/git-commit",\s*authMiddleware,/);
-        assert.match(serverSrc, /\b(?:app|router)\.post\("\/api\/memory\/hooks\/pr-merge",\s*authMiddleware,/);
     });
 });
 describe("SSE exhaustiveness — static analysis", () => {

package/dist/api/server.js

@@ -15,7 +15,6 @@ import { apiNotFoundHandler, createApiErrorHandler } from "./errors.js";
 import { childLogger } from "../util/logger.js";
 import { assertAuthenticationConfigured, getDisplayHost, shouldServeSpaPath } from "./server-runtime.js";
 import { createAgentsRouter } from "./routes/agents.js";
-import { createMemoryRouter } from "./routes/memory.js";
 import { createProjectsRouter } from "./routes/projects.js";
 import { createSessionsRouter } from "./routes/sessions.js";
 import { createSystemRouter } from "./routes/system.js";
@@ -136,7 +135,6 @@ setAgentSaveRuntimeHooks({
 });
 app.use(createSystemRouter({ apiToken }));
 app.use(createAgentsRouter({ modeContext }));
-app.use(createMemoryRouter({ authMiddleware }));
 app.use(createProjectsRouter({ modeContext }));
 app.use(createSessionsRouter());
 app.use(createWikiRouter({ authMiddleware, modeContext }));

package/dist/api/server.test.js

@@ -195,25 +195,6 @@ function markBundledAgent(testRoot, slug, hash = "bundled-hash") {
         db.close();
     }
 }
-function setMemoryActiveScope(testRoot, slug) {
-    const db = new Database(getProjectDbPath(testRoot));
-    try {
-        if (slug === null) {
-            db.prepare(`DELETE FROM mem_settings WHERE key = ?`).run("current_scope_slug");
-            return;
-        }
-        const scope = db.prepare(`SELECT slug FROM mem_scopes WHERE slug = ?`).get(slug);
-        assert.ok(scope, `expected seeded memory scope '${slug}' to exist`);
-        db.prepare(`
-      INSERT INTO mem_settings (key, value)
-      VALUES (?, ?)
-      ON CONFLICT(key) DO UPDATE SET value = excluded.value
-    `).run("current_scope_slug", slug);
-    }
-    finally {
-        db.close();
-    }
-}
 // Standalone mode triggers a full daemon init via the server→daemon circular import
 // (server.ts imports restartDaemon from daemon.ts, which has module-level main()).
 // The Copilot SDK's client.start() then blocks the event loop while authenticating,
@@ -705,74 +686,6 @@ test("server refuses standalone mode on non-loopback binds", async () => {
     assert.match(logs.join(""), /Set API_TOKEN or configure Entra auth/);
     rmSync(testRoot, { recursive: true, force: true });
 });
-test("server exposes the active memory scope API and requires auth", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
-        const unauthorized = await fetch(`${baseUrl}/api/memory/active-scope`);
-        assert.equal(unauthorized.status, 401);
-        const noScope = await fetch(`${baseUrl}/api/memory/active-scope`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(noScope.status, 200);
-        assert.equal(await noScope.json(), null);
-        setMemoryActiveScope(testRoot, "chapterhouse");
-        const activeScope = await fetch(`${baseUrl}/api/memory/active-scope`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(activeScope.status, 200);
-        assert.deepEqual(await activeScope.json(), {
-            slug: "chapterhouse",
-            title: "Chapterhouse",
-        });
-    });
-});
-test("server creates memory scopes with duplicate and slug validation", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const unauthorized = await fetch(`${baseUrl}/api/scopes`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ slug: "docs-site", title: "Docs Site" }),
-        });
-        assert.equal(unauthorized.status, 401);
-        const created = await fetch(`${baseUrl}/api/scopes`, {
-            method: "POST",
-            headers: {
-                authorization: authHeader,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify({
-                slug: "docs-site",
-                title: "Docs Site",
-                description: "Documentation publishing and content workflows",
-            }),
-        });
-        assert.equal(created.status, 201);
-        assert.deepEqual(await created.json(), {
-            slug: "docs-site",
-            title: "Docs Site",
-            description: "Documentation publishing and content workflows",
-            active: true,
-        });
-        const duplicate = await fetch(`${baseUrl}/api/scopes`, {
-            method: "POST",
-            headers: {
-                authorization: authHeader,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify({ slug: "docs-site", title: "Docs Site Again" }),
-        });
-        assert.equal(duplicate.status, 409);
-        assert.deepEqual(await duplicate.json(), { error: "Memory scope 'docs-site' already exists" });
-        const invalid = await fetch(`${baseUrl}/api/scopes`, {
-            method: "POST",
-            headers: {
-                authorization: authHeader,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify({ slug: "Docs Site", title: "Docs Site" }),
-        });
-        assert.equal(invalid.status, 400);
-    });
-});
 test("server bootstrap rejects non-loopback origins", async () => {
     await withStartedServer(async ({ baseUrl }) => {
         const response = await fetch(`${baseUrl}/api/bootstrap`, {
@@ -1634,200 +1547,6 @@ test("server caps concurrent SSE connections per IP", async () => {
         API_RATE_LIMIT_SSE_MAX_CONNECTIONS: "2",
     });
 });
-test("POST /api/memory/active-scope sets and clears the active scope", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const unauthorized = await fetch(`${baseUrl}/api/memory/active-scope`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ scope: "chapterhouse" }),
-        });
-        assert.equal(unauthorized.status, 401);
-        const set = await fetch(`${baseUrl}/api/memory/active-scope`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ scope: "chapterhouse" }),
-        });
-        assert.equal(set.status, 200);
-        assert.deepEqual(await set.json(), { ok: true, scope: "chapterhouse" });
-        const verify = await fetch(`${baseUrl}/api/memory/active-scope`, {
-            headers: { authorization: authHeader },
-        });
-        assert.deepEqual(await verify.json(), { slug: "chapterhouse", title: "Chapterhouse" });
-        const clear = await fetch(`${baseUrl}/api/memory/active-scope`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ scope: null }),
-        });
-        assert.equal(clear.status, 200);
-        assert.deepEqual(await clear.json(), { ok: true, scope: null });
-        const unknownScope = await fetch(`${baseUrl}/api/memory/active-scope`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ scope: "nonexistent-scope" }),
-        });
-        assert.equal(unknownScope.status, 404);
-    });
-});
-test("GET /api/memory/scopes lists all scopes with entry counts", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const unauthorized = await fetch(`${baseUrl}/api/memory/scopes`);
-        assert.equal(unauthorized.status, 401);
-        const res = await fetch(`${baseUrl}/api/memory/scopes`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(res.status, 200);
-        const body = await res.json();
-        assert.ok(Array.isArray(body.scopes));
-        assert.ok(body.scopes.length >= 2, "expected at least 2 seeded scopes");
-        const chapterhouse = body.scopes.find((s) => s.slug === "chapterhouse");
-        assert.ok(chapterhouse, "expected chapterhouse scope");
-        assert.ok(typeof chapterhouse.counts.observations === "number");
-        assert.ok(typeof chapterhouse.counts.decisions === "number");
-    });
-});
-test("GET /api/memory/:scope returns entries for a scope and 404 for unknown", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const unauthorized = await fetch(`${baseUrl}/api/memory/chapterhouse`);
-        assert.equal(unauthorized.status, 401);
-        const res = await fetch(`${baseUrl}/api/memory/chapterhouse`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(res.status, 200);
-        const body = await res.json();
-        assert.ok(Array.isArray(body.entries));
-        assert.ok(typeof body.total === "number");
-        const withStore = await fetch(`${baseUrl}/api/memory/chapterhouse?store=decisions`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(withStore.status, 200);
-        const withTier = await fetch(`${baseUrl}/api/memory/chapterhouse?store=observations&tier=hot`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(withTier.status, 200);
-        const notFound = await fetch(`${baseUrl}/api/memory/no-such-scope`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(notFound.status, 404);
-        assert.deepEqual(await notFound.json(), { error: "Memory scope 'no-such-scope' not found" });
-    });
-});
-test("GET /api/memory/:scope returns a cursor for additional pages", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
-        const db = new Database(getProjectDbPath(testRoot));
-        try {
-            const scope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = ?`).get("chapterhouse");
-            const insert = db.prepare(`
-        INSERT INTO mem_observations (scope_id, content, source, tier, created_at)
-        VALUES (?, ?, 'test', 'hot', ?)
-      `);
-            for (let i = 0; i < 105; i++) {
-                insert.run(scope.id, `Paginated observation ${i}`, `2026-05-15T00:${String(i).padStart(2, "0")}:00.000Z`);
-            }
-        }
-        finally {
-            db.close();
-        }
-        const first = await fetch(`${baseUrl}/api/memory/chapterhouse?store=observations&tier=hot`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(first.status, 200);
-        const firstBody = await first.json();
-        assert.equal(firstBody.entries.length, 100);
-        assert.ok(firstBody.total >= 105);
-        assert.ok(firstBody.nextCursor);
-        const second = await fetch(`${baseUrl}/api/memory/chapterhouse?store=observations&tier=hot&cursor=${encodeURIComponent(firstBody.nextCursor)}`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(second.status, 200);
-        const secondBody = await second.json();
-        assert.ok(secondBody.entries.length >= 5);
-        assert.equal(secondBody.total, firstBody.total);
-        assert.equal(secondBody.nextCursor, undefined);
-        assert.ok(Math.max(...secondBody.entries.map((entry) => entry.id)) < Math.min(...firstBody.entries.map((entry) => entry.id)));
-    });
-});
-test("POST /api/memory/:scope/remember writes an observation or decision", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const unauthorized = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ content: "Test observation" }),
-        });
-        assert.equal(unauthorized.status, 401);
-        const obs = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ content: "Chapterhouse uses SQLite for memory." }),
-        });
-        assert.equal(obs.status, 200);
-        const obsBody = await obs.json();
-        assert.equal(obsBody.ok, true);
-        assert.ok(typeof obsBody.id === "string");
-        const dec = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ kind: "decision", title: "Use SQLite", content: "SQLite chosen for persistence." }),
-        });
-        assert.equal(dec.status, 200);
-        const decBody = await dec.json();
-        assert.equal(decBody.ok, true);
-        const noTitle = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ kind: "decision", content: "Missing title." }),
-        });
-        assert.equal(noTitle.status, 400);
-        const notFound = await fetch(`${baseUrl}/api/memory/missing-scope/remember`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ content: "Will not land." }),
-        });
-        assert.equal(notFound.status, 404);
-    });
-});
-test("GET /api/memory/inbox lists pending proposals", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const unauthorized = await fetch(`${baseUrl}/api/memory/inbox`);
-        assert.equal(unauthorized.status, 401);
-        const empty = await fetch(`${baseUrl}/api/memory/inbox`, {
-            headers: { authorization: authHeader },
-        });
-        assert.equal(empty.status, 200);
-        const body = await empty.json();
-        assert.ok(Array.isArray(body.items));
-        assert.ok(typeof body.total === "number");
-        assert.equal(body.items.length, body.total);
-    });
-});
-test("POST /api/memory/inbox/:id/route accepts and rejects proposals", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        // First queue a proposal via the remember endpoint so we have something to route
-        const rememberRes = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ content: "Proposal for inbox routing test." }),
-        });
-        assert.equal(rememberRes.status, 200);
-        const notFound = await fetch(`${baseUrl}/api/memory/inbox/99999/route`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ action: "accept" }),
-        });
-        assert.equal(notFound.status, 404);
-        const badId = await fetch(`${baseUrl}/api/memory/inbox/not-a-number/route`, {
-            method: "POST",
-            headers: { authorization: authHeader, "content-type": "application/json" },
-            body: JSON.stringify({ action: "accept" }),
-        });
-        assert.equal(badId.status, 400);
-        const unauthorized = await fetch(`${baseUrl}/api/memory/inbox/1/route`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ action: "accept" }),
-        });
-        assert.equal(unauthorized.status, 401);
-    });
-});
 test("GET /api/wiki/korg/sessions returns grouped active research sessions", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
         const db = new Database(getProjectDbPath(testRoot));

package/dist/config.js

@@ -68,24 +68,7 @@ const configSchema = z.object({
     CHAPTERHOUSE_SESSION_MAX_ACTIVE: z.string().optional(),
     CHAPTERHOUSE_ORCHESTRATOR_TIMEOUT_MS: z.string().optional(),
     CHAPTERHOUSE_JSON_LIMIT: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_CHECKPOINT_TURNS: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_CHECKPOINT_ON_SCOPE_CHANGE: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_CHECKPOINT_MIN_TURNS_FOR_SCOPE_FIRE: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_INJECT: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_AUTO_ACCEPT: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_HOOKS_ENABLED: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_HOUSEKEEPING_ENABLED: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_HOUSEKEEPING_TURNS: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_HOUSEKEEPING_SIMILARITY_THRESHOLD: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_CHECKPOINT_DUPLICATE_THRESHOLD: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_DECAY_DAYS: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_TIERING_ENABLED: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_HOT_RECALL_BOOST: z.string().optional(),
-    CHAPTERHOUSE_MEMORY_HOT_AGE_DAYS: z.string().optional(),
+    CHAPTERHOUSE_MEMORY_ENABLED: z.string().optional(),
     CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED: z.string().optional(),
     CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR: z.string().optional(),
     CHAPTERHOUSE_PKB_TRUTH_REWRITE_BUDGET: z.string().optional(),
@@ -158,28 +141,6 @@ function parsePositiveIntegerEnv(name, rawValue, defaultValue) {
     }
     return parsed;
 }
-function parsePositiveNumberEnv(name, rawValue, defaultValue) {
-    const normalized = rawValue?.trim();
-    if (!normalized) {
-        return defaultValue;
-    }
-    const parsed = Number(normalized);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new Error(`${name} must be a positive number, got: "${rawValue}"`);
-    }
-    return parsed;
-}
-function parseUnitIntervalEnv(name, rawValue, defaultValue) {
-    const normalized = rawValue?.trim();
-    if (!normalized) {
-        return defaultValue;
-    }
-    const parsed = Number(normalized);
-    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
-        throw new Error(`${name} must be a number between 0 and 1, got: "${rawValue}"`);
-    }
-    return parsed;
-}
 function parseHourEnv(name, rawValue, defaultValue) {
     const normalized = rawValue?.trim();
     if (!normalized) {
@@ -342,15 +303,6 @@ export function parseRuntimeConfig(env, options = {}) {
     const apiRateLimitSseMaxConnections = parsePositiveIntegerEnv("API_RATE_LIMIT_SSE_MAX_CONNECTIONS", raw.API_RATE_LIMIT_SSE_MAX_CONNECTIONS, DEFAULT_API_RATE_LIMIT_SSE_MAX_CONNECTIONS);
     const sseBufferCapacity = parsePositiveIntegerEnv("CHAPTERHOUSE_SSE_BUFFER_CAPACITY", raw.CHAPTERHOUSE_SSE_BUFFER_CAPACITY, DEFAULT_SSE_BUFFER_CAPACITY);
     const sseReplayLimit = parsePositiveIntegerEnv("CHAPTERHOUSE_SSE_REPLAY_LIMIT", raw.CHAPTERHOUSE_SSE_REPLAY_LIMIT, DEFAULT_SSE_REPLAY_LIMIT);
-    const memoryCheckpointTurns = parsePositiveIntegerEnv("CHAPTERHOUSE_MEMORY_CHECKPOINT_TURNS", raw.CHAPTERHOUSE_MEMORY_CHECKPOINT_TURNS, 5);
-    const memoryCheckpointMinTurnsForScopeFire = parsePositiveIntegerEnv("CHAPTERHOUSE_MEMORY_CHECKPOINT_MIN_TURNS_FOR_SCOPE_FIRE", raw.CHAPTERHOUSE_MEMORY_CHECKPOINT_MIN_TURNS_FOR_SCOPE_FIRE, 2);
-    const memoryHousekeepingTurns = parsePositiveIntegerEnv("CHAPTERHOUSE_MEMORY_HOUSEKEEPING_TURNS", raw.CHAPTERHOUSE_MEMORY_HOUSEKEEPING_TURNS, 50);
-    const memoryHousekeepingSimilarityThreshold = parseUnitIntervalEnv("CHAPTERHOUSE_MEMORY_HOUSEKEEPING_SIMILARITY_THRESHOLD", raw.CHAPTERHOUSE_MEMORY_HOUSEKEEPING_SIMILARITY_THRESHOLD, 0.8);
-    const memoryCheckpointDuplicateThreshold = parseUnitIntervalEnv("CHAPTERHOUSE_MEMORY_CHECKPOINT_DUPLICATE_THRESHOLD", raw.CHAPTERHOUSE_MEMORY_CHECKPOINT_DUPLICATE_THRESHOLD, 0.85);
-    const memoryDecayDays = parsePositiveIntegerEnv("CHAPTERHOUSE_MEMORY_DECAY_DAYS", raw.CHAPTERHOUSE_MEMORY_DECAY_DAYS, 30);
-    const memoryInboxRetentionDays = parsePositiveIntegerEnv("CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS", raw.CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS, 7);
-    const memoryHotRecallBoost = parsePositiveNumberEnv("CHAPTERHOUSE_MEMORY_HOT_RECALL_BOOST", raw.CHAPTERHOUSE_MEMORY_HOT_RECALL_BOOST, 1.5);
-    const memoryHotAgeDays = parsePositiveIntegerEnv("CHAPTERHOUSE_MEMORY_HOT_AGE_DAYS", raw.CHAPTERHOUSE_MEMORY_HOT_AGE_DAYS, 30);
     const pkbConsolidationEnabled = parseBooleanEnv("CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED", raw.CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED, true);
     const pkbConsolidationHour = parseHourEnv("CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR", raw.CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR, 3);
     const jsonBodyLimit = raw.CHAPTERHOUSE_JSON_LIMIT?.trim() || DEFAULT_JSON_BODY_LIMIT;
@@ -422,24 +374,7 @@ export function parseRuntimeConfig(env, options = {}) {
         orchestratorTimeoutMs,
         chatSseEnabled: parseZeroOneEnv("CHAPTERHOUSE_CHAT_SSE", raw.CHAPTERHOUSE_CHAT_SSE, true),
         jsonBodyLimit,
-        memoryCheckpointEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED", raw.CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED, true),
-        memoryCheckpointTurns,
-        memoryCheckpointOnScopeChange: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_CHECKPOINT_ON_SCOPE_CHANGE", raw.CHAPTERHOUSE_MEMORY_CHECKPOINT_ON_SCOPE_CHANGE, true),
-        memoryCheckpointMinTurnsForScopeFire,
-        memoryInjectEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_INJECT", raw.CHAPTERHOUSE_MEMORY_INJECT, true),
-        memoryAutoAcceptEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_AUTO_ACCEPT", raw.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT, true),
-        memoryEndOfTaskHookEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED", raw.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED, true),
-        memoryEndOfTaskFrictionEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED", raw.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED, false),
-        memoryHooksEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_HOOKS_ENABLED", raw.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED, true),
-        memoryHousekeepingEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_HOUSEKEEPING_ENABLED", raw.CHAPTERHOUSE_MEMORY_HOUSEKEEPING_ENABLED, true),
-        memoryHousekeepingTurns,
-        memoryHousekeepingSimilarityThreshold,
-        memoryCheckpointDuplicateThreshold,
-        memoryDecayDays,
-        memoryInboxRetentionDays,
-        memoryTieringEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_TIERING_ENABLED", raw.CHAPTERHOUSE_MEMORY_TIERING_ENABLED, true),
-        memoryHotRecallBoost,
-        memoryHotAgeDays,
+        memoryEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_ENABLED", raw.CHAPTERHOUSE_MEMORY_ENABLED, true),
         pkbConsolidationEnabled,
         pkbConsolidationHour,
         pkbTruthRewriteBudget,
@@ -507,24 +442,7 @@ export const config = {
     get orchestratorTimeoutMs() { return currentRuntimeConfig().orchestratorTimeoutMs; },
     get chatSseEnabled() { return currentRuntimeConfig().chatSseEnabled; },
     get jsonBodyLimit() { return currentRuntimeConfig().jsonBodyLimit; },
-    get memoryCheckpointEnabled() { return currentRuntimeConfig().memoryCheckpointEnabled; },
-    get memoryCheckpointTurns() { return currentRuntimeConfig().memoryCheckpointTurns; },
-    get memoryCheckpointOnScopeChange() { return currentRuntimeConfig().memoryCheckpointOnScopeChange; },
-    get memoryCheckpointMinTurnsForScopeFire() { return currentRuntimeConfig().memoryCheckpointMinTurnsForScopeFire; },
-    get memoryInjectEnabled() { return currentRuntimeConfig().memoryInjectEnabled; },
-    get memoryAutoAcceptEnabled() { return currentRuntimeConfig().memoryAutoAcceptEnabled; },
-    get memoryEndOfTaskHookEnabled() { return currentRuntimeConfig().memoryEndOfTaskHookEnabled; },
-    get memoryEndOfTaskFrictionEnabled() { return currentRuntimeConfig().memoryEndOfTaskFrictionEnabled; },
-    get memoryHooksEnabled() { return currentRuntimeConfig().memoryHooksEnabled; },
-    get memoryHousekeepingEnabled() { return currentRuntimeConfig().memoryHousekeepingEnabled; },
-    get memoryHousekeepingTurns() { return currentRuntimeConfig().memoryHousekeepingTurns; },
-    get memoryHousekeepingSimilarityThreshold() { return currentRuntimeConfig().memoryHousekeepingSimilarityThreshold; },
-    get memoryCheckpointDuplicateThreshold() { return currentRuntimeConfig().memoryCheckpointDuplicateThreshold; },
-    get memoryDecayDays() { return currentRuntimeConfig().memoryDecayDays; },
-    get memoryInboxRetentionDays() { return currentRuntimeConfig().memoryInboxRetentionDays; },
-    get memoryTieringEnabled() { return currentRuntimeConfig().memoryTieringEnabled; },
-    get memoryHotRecallBoost() { return currentRuntimeConfig().memoryHotRecallBoost; },
-    get memoryHotAgeDays() { return currentRuntimeConfig().memoryHotAgeDays; },
+    get memoryEnabled() { return currentRuntimeConfig().memoryEnabled; },
     get pkbConsolidationEnabled() { return currentRuntimeConfig().pkbConsolidationEnabled; },
     get pkbConsolidationHour() { return currentRuntimeConfig().pkbConsolidationHour; },
     get pkbTruthRewriteBudget() { return currentRuntimeConfig().pkbTruthRewriteBudget; },

package/dist/config.test.js

@@ -125,130 +125,12 @@ test("parses configurable JSON body and consolidation truth rewrite limits", asy
     assert.equal(parsedExplicit.jsonBodyLimit, "8mb");
     assert.equal(parsedExplicit.pkbTruthRewriteBudget, 7);
 });
-test("defaults memory checkpoint turns to 5 and parses integer overrides", async () => {
+test("defaults memory enabled on and honors CHAPTERHOUSE_MEMORY_ENABLED overrides", async () => {
     const configModule = await import("./config.js");
-    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
-    const parsedDefault = configModule.parseRuntimeConfig({});
-    const parsedThree = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_CHECKPOINT_TURNS: "3",
-    });
-    const parsedTen = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_CHECKPOINT_TURNS: "10",
-    });
-    assert.equal(parsedDefault.memoryCheckpointTurns, 5);
-    assert.equal(parsedThree.memoryCheckpointTurns, 3);
-    assert.equal(parsedTen.memoryCheckpointTurns, 10);
-});
-test("parses PKB consolidation defaults and explicit hour overrides", async () => {
-    const configModule = await import("./config.js");
-    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
-    const parsedDefault = configModule.parseRuntimeConfig({});
-    const parsedExplicit = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED: "false",
-        CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR: "5",
-    });
-    assert.equal(parsedDefault.pkbConsolidationEnabled, true);
-    assert.equal(parsedDefault.pkbConsolidationHour, 3);
-    assert.equal(parsedExplicit.pkbConsolidationEnabled, false);
-    assert.equal(parsedExplicit.pkbConsolidationHour, 5);
-});
-test("rejects invalid PKB consolidation hours outside 0-23", async () => {
-    const configModule = await import("./config.js");
-    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
-    assert.throws(() => configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR: "24",
-    }), /CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR must be an integer between 0 and 23/);
-});
-test("defaults memory injection on and still honors explicit CHAPTERHOUSE_MEMORY_INJECT overrides", async () => {
-    const configModule = await import("./config.js");
-    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
-    const parsedDefault = configModule.parseRuntimeConfig({});
-    const parsedDisabled = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_INJECT: "0",
-    });
-    const parsedEnabled = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_INJECT: "1",
-    });
-    assert.equal(parsedDefault.memoryInjectEnabled, true);
-    assert.equal(parsedDisabled.memoryInjectEnabled, false);
-    assert.equal(parsedEnabled.memoryInjectEnabled, true);
-});
-test("defaults memory checkpoint extraction on and still honors explicit CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED overrides", async () => {
-    const configModule = await import("./config.js");
-    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
-    const parsedDefault = configModule.parseRuntimeConfig({});
-    const parsedDisabled = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED: "0",
-    });
-    const parsedEnabled = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED: "1",
-    });
-    assert.equal(parsedDefault.memoryCheckpointEnabled, true);
-    assert.equal(parsedDisabled.memoryCheckpointEnabled, false);
-    assert.equal(parsedEnabled.memoryCheckpointEnabled, true);
-});
-test("defaults end-of-task memory processing on and still honors explicit CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED overrides", async () => {
-    const configModule = await import("./config.js");
-    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
-    const parsedDefault = configModule.parseRuntimeConfig({});
-    const parsedDisabled = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED: "0",
-    });
-    const parsedEnabled = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED: "1",
-    });
-    assert.equal(parsedDefault.memoryEndOfTaskHookEnabled, true);
-    assert.equal(parsedDisabled.memoryEndOfTaskHookEnabled, false);
-    assert.equal(parsedEnabled.memoryEndOfTaskHookEnabled, true);
-});
-test("parses memory housekeeping config defaults and overrides", async () => {
-    const configModule = await import("./config.js");
-    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
-    const parsedDefault = configModule.parseRuntimeConfig({});
-    const parsedOverride = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_HOUSEKEEPING_ENABLED: "0",
-        CHAPTERHOUSE_MEMORY_HOUSEKEEPING_TURNS: "12",
-        CHAPTERHOUSE_MEMORY_DECAY_DAYS: "45",
-        CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS: "14",
-        CHAPTERHOUSE_MEMORY_HOUSEKEEPING_SIMILARITY_THRESHOLD: "0.91",
-        CHAPTERHOUSE_MEMORY_CHECKPOINT_DUPLICATE_THRESHOLD: "0.72",
-    });
-    assert.equal(parsedDefault.memoryHousekeepingEnabled, true);
-    assert.equal(parsedDefault.memoryHousekeepingTurns, 50);
-    assert.equal(parsedDefault.memoryDecayDays, 30);
-    assert.equal(parsedDefault.memoryInboxRetentionDays, 7);
-    assert.equal(parsedDefault.memoryHousekeepingSimilarityThreshold, 0.8);
-    assert.equal(parsedDefault.memoryCheckpointDuplicateThreshold, 0.85);
-    assert.equal(parsedOverride.memoryHousekeepingEnabled, false);
-    assert.equal(parsedOverride.memoryHousekeepingTurns, 12);
-    assert.equal(parsedOverride.memoryDecayDays, 45);
-    assert.equal(parsedOverride.memoryInboxRetentionDays, 14);
-    assert.equal(parsedOverride.memoryHousekeepingSimilarityThreshold, 0.91);
-    assert.equal(parsedOverride.memoryCheckpointDuplicateThreshold, 0.72);
-});
-test("rejects memory similarity thresholds outside the 0..1 range", async () => {
-    const configModule = await import("./config.js");
-    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
-    assert.throws(() => configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_HOUSEKEEPING_SIMILARITY_THRESHOLD: "1.1",
-    }), /CHAPTERHOUSE_MEMORY_HOUSEKEEPING_SIMILARITY_THRESHOLD must be a number between 0 and 1/);
-    assert.throws(() => configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_CHECKPOINT_DUPLICATE_THRESHOLD: "-0.1",
-    }), /CHAPTERHOUSE_MEMORY_CHECKPOINT_DUPLICATE_THRESHOLD must be a number between 0 and 1/);
-});
-test("defaults automatic proposal acceptance on and still honors explicit CHAPTERHOUSE_MEMORY_AUTO_ACCEPT overrides", async () => {
-    const configModule = await import("./config.js");
-    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
-    const parsedDefault = configModule.parseRuntimeConfig({});
-    const parsedDisabled = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_AUTO_ACCEPT: "0",
-    });
-    const parsedEnabled = configModule.parseRuntimeConfig({
-        CHAPTERHOUSE_MEMORY_AUTO_ACCEPT: "1",
-    });
-    assert.equal(parsedDefault.memoryAutoAcceptEnabled, true);
-    assert.equal(parsedDisabled.memoryAutoAcceptEnabled, false);
-    assert.equal(parsedEnabled.memoryAutoAcceptEnabled, true);
+    const parse = configModule.parseRuntimeConfig;
+    assert.equal(parse({}).memoryEnabled, true);
+    assert.equal(parse({ CHAPTERHOUSE_MEMORY_ENABLED: "0" }).memoryEnabled, false);
+    assert.equal(parse({ CHAPTERHOUSE_MEMORY_ENABLED: "1" }).memoryEnabled, true);
 });
 test("prefers COPILOT_TOKEN over GITHUB_TOKEN for Copilot SDK auth", async () => {
     const configModule = await import("./config.js");