chapterhouse 0.3.25 → 0.4.0

package/dist/api/server-runtime.js

@@ -20,7 +20,7 @@ export function createHealthPayload(now = new Date()) {
     };
 }
 export function createPublicConfigPayload(config) {
-    const chatSseEnabled = config.chatSseEnabled ?? false;
+    const chatSseEnabled = config.chatSseEnabled ?? true;
     if (!config.entraAuthEnabled) {
         return {
             appName: "Chapterhouse",

package/dist/api/server.js

@@ -31,6 +31,7 @@ import { formatSseData, formatSseEvent } from "./sse.js";
 import { assertAuthenticationConfigured, createHealthPayload, createPublicConfigPayload, getDisplayHost, resolveApiToken, shouldServeSpaPath, } from "./server-runtime.js";
 import { BadRequestError, ForbiddenError, InternalServerError, NotFoundError, apiNotFoundHandler, asBadRequest, createApiErrorHandler, parseRequest, } from "./errors.js";
 import { childLogger } from "../util/logger.js";
+import { getActiveScope } from "../memory/active-scope.js";
 const log = childLogger("server");
 void searchIndex; // re-exported by index-manager; reference here documents the dep
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -668,7 +669,7 @@ app.post("/api/sessions/:sessionKey/interrupt", (req, res) => {
     res.json({ status: "interrupting" });
 });
 // ---------------------------------------------------------------------------
-// Chat POST→SSE endpoints — gated by CHAPTERHOUSE_CHAT_SSE=1 (#130)
+// Chat POST→SSE endpoints — enabled by default, overridable via CHAPTERHOUSE_CHAT_SSE (#130)
 // ---------------------------------------------------------------------------
 const turnRequestSchema = z.object({
     prompt: z.string().trim().min(1, "Missing prompt"),
@@ -838,6 +839,17 @@ app.get("/api/auto", (_req, res) => {
         lastRoute: lastRoute || null,
     });
 });
+app.get("/api/memory/active-scope", (_req, res) => {
+    const activeScope = getActiveScope();
+    if (!activeScope) {
+        res.json(null);
+        return;
+    }
+    res.json({
+        slug: activeScope.slug,
+        title: activeScope.title,
+    });
+});
 app.post("/api/auto", (req, res) => {
     const body = parseRequest(autoRequestSchema, req.body ?? {});
     const updated = updateRouterConfig(body);

package/dist/api/server.test.js

@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
 import Database from "better-sqlite3";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 test("supports API_TOKEN env var and personal health route helpers", async () => {
     const runtime = await import("./server-runtime.js");
     assert.equal(typeof runtime.resolveApiToken, "function", "resolveApiToken should be exported");
@@ -29,25 +29,25 @@ test("supports API_TOKEN env var and personal health route helpers", async () =>
         standaloneMode: false,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     }), {
         appName: "Chapterhouse",
         entraAuthEnabled: true,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     });
     assert.deepEqual(runtime.createPublicConfigPayload({
         entraAuthEnabled: false,
         standaloneMode: false,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     }), {
         appName: "Chapterhouse",
         entraAuthEnabled: false,
         standalone: false,
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     });
     assert.doesNotThrow(() => runtime.assertAuthenticationConfigured({
         entraAuthEnabled: false,
@@ -62,6 +62,21 @@ test("supports API_TOKEN env var and personal health route helpers", async () =>
         apiToken: null,
     }));
 });
+test("createPublicConfigPayload defaults chat SSE on when not explicitly provided", async () => {
+    const runtime = await import("./server-runtime.js");
+    assert.equal(typeof runtime.createPublicConfigPayload, "function", "createPublicConfigPayload should be exported");
+    assert.deepEqual(runtime.createPublicConfigPayload({
+        entraAuthEnabled: false,
+        standaloneMode: true,
+        entraClientId: "client-id",
+        entraTenantId: "tenant-id",
+    }), {
+        appName: "Chapterhouse",
+        entraAuthEnabled: false,
+        standalone: true,
+        chatSseEnabled: true,
+    });
+});
 test("formats named SSE status events", async () => {
     const sse = await import("./sse.js");
     assert.equal(typeof sse.formatSseEvent, "function", "formatSseEvent should be exported");
@@ -109,42 +124,37 @@ function readProjectRegistryRows(testRoot) {
         db.close();
     }
 }
-async function getFreePort() {
-    const server = createServer();
-    await new Promise((resolve) => {
-        server.listen(0, "127.0.0.1", () => resolve());
-    });
-    const address = server.address();
-    assert.ok(address && typeof address === "object", "server should expose a bound address");
-    await new Promise((resolve, reject) => {
-        server.close((err) => (err ? reject(err) : resolve()));
-    });
-    return address.port;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null) {
-        return;
+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();
     }
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        setTimeout(() => {
-            if (child.exitCode === null) {
-                child.kill("SIGKILL");
-            }
-        }, 2_000);
-    });
 }
 // 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,
-// so the HTTP server cannot respond until SDK init completes (~10-20 s depending on
-// session state).  Other modes complete in ~330 ms because the SDK yields quickly.
+// so the HTTP server cannot respond until SDK init completes (~10-30 s depending on
+// session state and runner load). Other modes usually complete much faster, but cold
+// CI starts can still exceed a 10 s budget.
 // Root cause tracked in decisions notes (backend fix: lazy-import or
-// guard env var in daemon.ts).  Interim fix: 30 s timeout for standalone, 10 s elsewhere.
+// guard env var in daemon.ts). Interim fix: use a more generous startup timeout for
+// integration tests while keeping the same /status readiness probe.
 // Additionally, strip COPILOT_* env vars from the child so it doesn't accidentally
 // piggy-back on the running agent session, which worsens the blocking behaviour.
-async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
+async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
     const testRoot = join(repoRoot, ".test-work", `server-routes-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     rmSync(testRoot, { recursive: true, force: true });
@@ -174,24 +184,8 @@ async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
     child.stderr?.on("data", (chunk) => logs.push(String(chunk)));
     const baseUrl = `http://127.0.0.1:${port}`;
     try {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (child.exitCode !== null) {
-                throw new Error(`API server exited early:\n${logs.join("")}`);
-            }
-            try {
-                const response = await fetch(`${baseUrl}/status`);
-                if (response.ok) {
-                    await run({ baseUrl, authHeader: "Bearer route-token", testRoot });
-                    return;
-                }
-            }
-            catch {
-                // Server still starting.
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        throw new Error(`Timed out waiting for API server to start:\n${logs.join("")}`);
+        await waitForApiServerReady({ child, baseUrl, logs, timeoutMs });
+        await run({ baseUrl, authHeader: "Bearer route-token", testRoot });
     }
     finally {
         await stopChild(child);
@@ -209,7 +203,7 @@ test("server routes expose bootstrap and public config without auth", async () =
             appName: "Chapterhouse",
             entraAuthEnabled: false,
             standalone: false,
-            chatSseEnabled: false,
+            chatSseEnabled: true,
         });
     });
 });
@@ -224,14 +218,34 @@ test("server runs in standalone mode without auth", async () => {
             appName: "Chapterhouse",
             entraAuthEnabled: false,
             standalone: true,
-            chatSseEnabled: false,
+            chatSseEnabled: true,
         });
         const model = await fetch(`${baseUrl}/api/model`);
         assert.equal(model.status, 200);
         assert.deepEqual(await model.json(), { model: "claude-sonnet-4.6" });
     }, {
         API_TOKEN: "",
-    }, 30_000);
+    }, STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS);
+});
+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 bootstrap rejects non-loopback origins", async () => {
     await withStartedServer(async ({ baseUrl }) => {

package/dist/api/sse.integration.test.js

@@ -1,42 +1,16 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { mkdirSync, rmSync } from "node:fs";
-import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 // ---------------------------------------------------------------------------
 // Server harness (copied from server.test.ts; distinct root path suffix to
 // avoid collision when both test files run in parallel in the same process).
 // ---------------------------------------------------------------------------
 const repoRoot = process.cwd();
 const sseTestRoot = join(repoRoot, ".test-work", `sse-integration-${process.pid}`);
-async function getFreePort() {
-    const server = createServer();
-    await new Promise((resolve) => {
-        server.listen(0, "127.0.0.1", () => resolve());
-    });
-    const address = server.address();
-    assert.ok(address && typeof address === "object", "server should expose a bound address");
-    await new Promise((resolve, reject) => {
-        server.close((err) => (err ? reject(err) : resolve()));
-    });
-    return address.port;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null) {
-        return;
-    }
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        setTimeout(() => {
-            if (child.exitCode === null) {
-                child.kill("SIGKILL");
-            }
-        }, 2_000);
-    });
-}
-async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
+async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     rmSync(sseTestRoot, { recursive: true, force: true });
     mkdirSync(sseTestRoot, { recursive: true });
@@ -65,24 +39,8 @@ async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
     child.stderr?.on("data", (chunk) => logs.push(String(chunk)));
     const baseUrl = `http://127.0.0.1:${port}`;
     try {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (child.exitCode !== null) {
-                throw new Error(`API server exited early:\n${logs.join("")}`);
-            }
-            try {
-                const response = await fetch(`${baseUrl}/status`);
-                if (response.ok) {
-                    await run({ baseUrl, authHeader: "Bearer route-token" });
-                    return;
-                }
-            }
-            catch {
-                // Server still starting.
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        throw new Error(`Timed out waiting for API server to start:\n${logs.join("")}`);
+        await waitForApiServerReady({ child, baseUrl, logs, timeoutMs });
+        await run({ baseUrl, authHeader: "Bearer route-token" });
     }
     finally {
         await stopChild(child);

package/dist/api/turn-sse.integration.test.js

@@ -2,8 +2,8 @@
  * Integration tests for the POST→SSE chat endpoints (#130).
  *
  * Tests:
- *  1. POST /api/sessions/:key/turn returns 404 when flag is off
- *  2. GET /api/sessions/:key/stream returns 404 when flag is off
+ *  1. POST /api/sessions/:key/turn returns 404 when flag is explicitly off
+ *  2. GET /api/sessions/:key/stream returns 404 when flag is explicitly off
  *  3. POST /api/sessions/:key/turn returns { turnId } when flag is on
  *  4. GET /api/sessions/:key/stream delivers turn events (SSE)
  *  5. SSE reconnect with Last-Event-ID replays missed events
@@ -11,8 +11,8 @@
  *  7. Legacy POST /api/message path unaffected when flag is off
  *
  * The tests that require the feature flag spawn a separate server process with
- * CHAPTERHOUSE_CHAT_SSE=1.  Tests that verify flag-off behavior use a server
- * without the flag.
+ * CHAPTERHOUSE_CHAT_SSE defaults on. Tests that verify flag-off behavior use a
+ * server with CHAPTERHOUSE_CHAT_SSE=0.
  *
  * Because the Copilot SDK is not available in test env (no valid token), tests
  * that would trigger a real turn instead verify the API shape and event
@@ -23,34 +23,16 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { mkdirSync, rmSync } from "node:fs";
-import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 // ---------------------------------------------------------------------------
 // Helpers — copied/adapted from sse.integration.test.ts
 // ---------------------------------------------------------------------------
 const repoRoot = process.cwd();
 const testWorkRoot = join(repoRoot, ".test-work", `turn-sse-${process.pid}`);
 let _instanceCounter = 0;
-async function getFreePort() {
-    const server = createServer();
-    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
-    const addr = server.address();
-    assert.ok(addr && typeof addr === "object");
-    await new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())));
-    return addr.port;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null)
-        return;
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        setTimeout(() => { if (child.exitCode === null)
-            child.kill("SIGKILL"); }, 2_000);
-    });
-}
-async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
+async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     const instanceRoot = `${testWorkRoot}-${Date.now()}-${++_instanceCounter}`;
     rmSync(instanceRoot, { recursive: true, force: true });
@@ -78,24 +60,15 @@ async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
     child.stderr?.on("data", (c) => logs.push(String(c)));
     const baseUrl = `http://127.0.0.1:${port}`;
     try {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (child.exitCode !== null)
-                throw new Error(`Server exited early:\n${logs.join("")}`);
-            let serverReady = false;
-            try {
-                const r = await fetch(`${baseUrl}/status`);
-                serverReady = r.ok;
-            }
-            catch { /* not ready yet */ }
-            if (serverReady) {
-                // Run outside the fetch try/catch so assertion errors propagate correctly.
-                await run({ baseUrl, authHeader: "Bearer test-token" });
-                return;
-            }
-            await new Promise((r) => setTimeout(r, 100));
-        }
-        throw new Error(`Server did not start in ${timeoutMs}ms:\n${logs.join("")}`);
+        await waitForApiServerReady({
+            child,
+            baseUrl,
+            logs,
+            timeoutMs,
+            timeoutMessage: `Server did not start in ${timeoutMs}ms`,
+            exitMessage: "Server exited early",
+        });
+        await run({ baseUrl, authHeader: "Bearer test-token" });
     }
     finally {
         await stopChild(child);
@@ -162,18 +135,18 @@ test("turn-sse: POST /api/sessions/:key/turn returns 404 when flag is off", asyn
             headers: { Authorization: authHeader, "Content-Type": "application/json" },
             body: JSON.stringify({ prompt: "hello" }),
         });
-        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE is not set");
+        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE=0");
         const body = await res.json();
         assert.ok(typeof body.error === "string" && body.error.includes("Chat SSE"), `Expected error about Chat SSE, got: ${body.error}`);
-    });
+    }, { CHAPTERHOUSE_CHAT_SSE: "0" });
 });
 test("turn-sse: GET /api/sessions/:key/stream returns 404 when flag is off", async () => {
     await withStartedServer(async ({ baseUrl, authHeader }) => {
         const res = await fetch(`${baseUrl}/api/sessions/default/stream`, {
             headers: { Authorization: authHeader },
         });
-        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE is not set");
-    });
+        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE=0");
+    }, { CHAPTERHOUSE_CHAT_SSE: "0" });
 });
 test("turn-sse: legacy POST /api/message is unaffected when flag is off", async () => {
     await withStartedServer(async ({ baseUrl, authHeader }) => {
@@ -186,7 +159,7 @@ test("turn-sse: legacy POST /api/message is unaffected when flag is off", async
         });
         // 400 = route exists and validated the request (connectionId not found in sseClients)
         assert.ok(res.status === 400 || res.status === 401 || res.status === 422, `Expected 4xx from /api/message, got ${res.status}`);
-    });
+    }, { CHAPTERHOUSE_CHAT_SSE: "0" });
 });
 // ---------------------------------------------------------------------------
 // Tests: feature flag ON

package/dist/config.js

@@ -46,8 +46,24 @@ const configSchema = z.object({
     API_RATE_LIMIT_GENERAL_MAX: z.string().optional(),
     API_RATE_LIMIT_AUTH_MAX: z.string().optional(),
     API_RATE_LIMIT_SSE_MAX_CONNECTIONS: z.string().optional(),
+    CHAPTERHOUSE_SSE_BUFFER_CAPACITY: z.string().optional(),
+    CHAPTERHOUSE_SSE_REPLAY_LIMIT: z.string().optional(),
     CHAPTERHOUSE_WORKIQ_AUTO_INSTALL: z.string().optional(),
     CHAPTERHOUSE_CHAT_SSE: 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_HOUSEKEEPING_ENABLED: z.string().optional(),
+    CHAPTERHOUSE_MEMORY_HOUSEKEEPING_TURNS: 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(),
 });
 export const DEFAULT_MODEL = "claude-sonnet-4.6";
 export const DEFAULT_TEAM_WIKI_CACHE_TTL_MINUTES = 60;
@@ -60,6 +76,18 @@ export const DEFAULT_API_RATE_LIMIT_WINDOW_MS = 60_000;
 export const DEFAULT_API_RATE_LIMIT_GENERAL_MAX = 100;
 export const DEFAULT_API_RATE_LIMIT_AUTH_MAX = 10;
 export const DEFAULT_API_RATE_LIMIT_SSE_MAX_CONNECTIONS = 5;
+export const DEFAULT_SSE_BUFFER_CAPACITY = 2_000;
+export const DEFAULT_SSE_REPLAY_LIMIT = 10_000;
+function parseZeroOneEnv(name, rawValue, defaultValue) {
+    const normalized = rawValue?.trim();
+    if (!normalized) {
+        return defaultValue;
+    }
+    if (normalized !== "0" && normalized !== "1") {
+        throw new Error(`${name} must be '0' or '1', got: "${rawValue}"`);
+    }
+    return normalized === "1";
+}
 function parseBooleanEnv(name, rawValue, defaultValue) {
     const normalized = rawValue?.trim();
     if (!normalized) {
@@ -100,6 +128,17 @@ 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 parseCorsAllowedOrigins(rawValue) {
     const normalized = rawValue?.trim();
     if (!normalized) {
@@ -190,6 +229,15 @@ export function parseRuntimeConfig(env, options = {}) {
     const apiRateLimitGeneralMax = parsePositiveIntegerEnv("API_RATE_LIMIT_GENERAL_MAX", raw.API_RATE_LIMIT_GENERAL_MAX, DEFAULT_API_RATE_LIMIT_GENERAL_MAX);
     const apiRateLimitAuthMax = parsePositiveIntegerEnv("API_RATE_LIMIT_AUTH_MAX", raw.API_RATE_LIMIT_AUTH_MAX, DEFAULT_API_RATE_LIMIT_AUTH_MAX);
     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 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);
     if (entraAuthEnabled && (!entraTenantId || !entraClientId)) {
         throw new Error("ENTRA_AUTH_ENABLED=true requires ENTRA_TENANT_ID and ENTRA_CLIENT_ID");
     }
@@ -229,8 +277,24 @@ export function parseRuntimeConfig(env, options = {}) {
         apiRateLimitGeneralMax,
         apiRateLimitAuthMax,
         apiRateLimitSseMaxConnections,
+        sseBufferCapacity,
+        sseReplayLimit,
         workiqAutoInstall: parseBooleanEnv("CHAPTERHOUSE_WORKIQ_AUTO_INSTALL", raw.CHAPTERHOUSE_WORKIQ_AUTO_INSTALL, true),
-        chatSseEnabled: raw.CHAPTERHOUSE_CHAT_SSE === "1",
+        chatSseEnabled: parseZeroOneEnv("CHAPTERHOUSE_CHAT_SSE", raw.CHAPTERHOUSE_CHAT_SSE, true),
+        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),
+        memoryHousekeepingEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_HOUSEKEEPING_ENABLED", raw.CHAPTERHOUSE_MEMORY_HOUSEKEEPING_ENABLED, true),
+        memoryHousekeepingTurns,
+        memoryDecayDays,
+        memoryInboxRetentionDays,
+        memoryTieringEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_TIERING_ENABLED", raw.CHAPTERHOUSE_MEMORY_TIERING_ENABLED, true),
+        memoryHotRecallBoost,
+        memoryHotAgeDays,
     };
 }
 const runtimeConfig = parseRuntimeConfig(process.env);
@@ -270,8 +334,24 @@ export const config = {
     apiRateLimitGeneralMax: runtimeConfig.apiRateLimitGeneralMax,
     apiRateLimitAuthMax: runtimeConfig.apiRateLimitAuthMax,
     apiRateLimitSseMaxConnections: runtimeConfig.apiRateLimitSseMaxConnections,
+    sseBufferCapacity: runtimeConfig.sseBufferCapacity,
+    sseReplayLimit: runtimeConfig.sseReplayLimit,
     workiqAutoInstall: runtimeConfig.workiqAutoInstall,
     chatSseEnabled: runtimeConfig.chatSseEnabled,
+    memoryCheckpointEnabled: runtimeConfig.memoryCheckpointEnabled,
+    memoryCheckpointTurns: runtimeConfig.memoryCheckpointTurns,
+    memoryCheckpointOnScopeChange: runtimeConfig.memoryCheckpointOnScopeChange,
+    memoryCheckpointMinTurnsForScopeFire: runtimeConfig.memoryCheckpointMinTurnsForScopeFire,
+    memoryInjectEnabled: runtimeConfig.memoryInjectEnabled,
+    memoryAutoAcceptEnabled: runtimeConfig.memoryAutoAcceptEnabled,
+    memoryEndOfTaskHookEnabled: runtimeConfig.memoryEndOfTaskHookEnabled,
+    memoryHousekeepingEnabled: runtimeConfig.memoryHousekeepingEnabled,
+    memoryHousekeepingTurns: runtimeConfig.memoryHousekeepingTurns,
+    memoryDecayDays: runtimeConfig.memoryDecayDays,
+    memoryInboxRetentionDays: runtimeConfig.memoryInboxRetentionDays,
+    memoryTieringEnabled: runtimeConfig.memoryTieringEnabled,
+    memoryHotRecallBoost: runtimeConfig.memoryHotRecallBoost,
+    memoryHotAgeDays: runtimeConfig.memoryHotAgeDays,
     copilotAuthToken: runtimeConfig.copilotAuthToken,
     get copilotModel() {
         return _copilotModel;