chapterhouse 0.3.26 → 0.4.0

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));
@@ -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

@@ -124,6 +124,25 @@ function readProjectRegistryRows(testRoot) {
         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,
@@ -208,6 +227,26 @@ test("server runs in standalone mode without auth", async () => {
         API_TOKEN: "",
     }, 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 }) => {
         const response = await fetch(`${baseUrl}/api/bootstrap`, {

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,8 @@ 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) {
@@ -110,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) {
@@ -200,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");
     }
@@ -239,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: 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);
@@ -280,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;

package/dist/config.test.js

@@ -109,6 +109,95 @@ test("defaults chat SSE on and still honors explicit CHAPTERHOUSE_CHAT_SSE overr
     assert.equal(parsedDisabled.chatSseEnabled, false);
     assert.equal(parsedEnabled.chatSseEnabled, true);
 });
+test("defaults memory checkpoint turns to 5 and parses integer 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("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",
+    });
+    assert.equal(parsedDefault.memoryHousekeepingEnabled, true);
+    assert.equal(parsedDefault.memoryHousekeepingTurns, 50);
+    assert.equal(parsedDefault.memoryDecayDays, 30);
+    assert.equal(parsedDefault.memoryInboxRetentionDays, 7);
+    assert.equal(parsedOverride.memoryHousekeepingEnabled, false);
+    assert.equal(parsedOverride.memoryHousekeepingTurns, 12);
+    assert.equal(parsedOverride.memoryDecayDays, 45);
+    assert.equal(parsedOverride.memoryInboxRetentionDays, 14);
+});
+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);
+});
 test("prefers COPILOT_TOKEN over GITHUB_TOKEN for Copilot SDK auth", async () => {
     const configModule = await import("./config.js");
     assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
@@ -159,4 +248,24 @@ test("rejects invalid rate limiting settings", async () => {
         API_RATE_LIMIT_GENERAL_MAX: "0",
     }), /API_RATE_LIMIT_GENERAL_MAX must be a positive integer/);
 });
+test("parses SSE replay settings and defaults", 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_SSE_BUFFER_CAPACITY: "2500",
+        CHAPTERHOUSE_SSE_REPLAY_LIMIT: "20000",
+    });
+    assert.equal(parsedDefault.sseBufferCapacity, 2000);
+    assert.equal(parsedDefault.sseReplayLimit, 10000);
+    assert.equal(parsedExplicit.sseBufferCapacity, 2500);
+    assert.equal(parsedExplicit.sseReplayLimit, 20000);
+});
+test("rejects invalid SSE replay settings", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    assert.throws(() => configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_SSE_BUFFER_CAPACITY: "0",
+    }), /CHAPTERHOUSE_SSE_BUFFER_CAPACITY must be a positive integer/);
+});
 //# sourceMappingURL=config.test.js.map

package/dist/copilot/agents.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { readdirSync, readFileSync, mkdirSync, writeFileSync, existsSync, rmSync, copyFileSync } from "fs";
 import { createHash } from "crypto";
 import { join, dirname, sep } from "path";
@@ -10,6 +11,8 @@ import { loadMcpConfig } from "./mcp-config.js";
 import { getSkillDirectories } from "./skills.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("agents");
+const toolAgentContext = new AsyncLocalStorage();
+const toolTaskContext = new AsyncLocalStorage();
 // Frontmatter schema
 const agentFrontmatterSchema = z.object({
     name: z.string().min(1),
@@ -213,12 +216,18 @@ let taskCounter = 0;
 function nextTaskId() {
     return `task-${++taskCounter}-${Date.now().toString(36)}`;
 }
+export function createTaskId() {
+    return nextTaskId();
+}
 /** Shared base prompt injected into all agent sessions. */
 function getAgentBasePrompt() {
     return `## Runtime Context
 
 You are an agent within Chapterhouse, a team-level AI assistant for engineering teams. You run on the user's local machine.
 
+### Agent Memory
+Chapterhouse agent memory follows a three-tier memory model: **read** with \`memory_recall\`, **propose** with \`memory_propose\`, and **write** with orchestrator-only tools. Do not call \`memory_remember\` directly; when you discover something memory-worthy, use \`memory_propose\` instead. Proposals are processed automatically at end-of-task, so do not wait for confirmation. Examples: a durable fact is an \`observation\`, a settled implementation choice is a \`decision\`, and a named system/tool/person can be proposed as an \`entity\`.
+
 ### Shared Wiki
 All agents share a wiki knowledge base for persistent memory. Use \`wiki_read\` and \`wiki_search\` to find existing knowledge, and \`wiki_update\` to save important findings.
 
@@ -263,6 +272,7 @@ export function buildAgentRoster() {
 const WIKI_TOOL_NAMES = new Set([
     "wiki_search", "wiki_read", "wiki_update", "remember", "recall", "forget",
     "wiki_ingest", "wiki_lint", "wiki_rebuild_index",
+    "memory_recall", "memory_propose",
 ]);
 // Management tools that only @chapterhouse should have
 const MANAGEMENT_TOOL_NAMES = new Set([
@@ -271,7 +281,20 @@ const MANAGEMENT_TOOL_NAMES = new Set([
     "switch_model", "toggle_auto", "list_models",
     "restart_chapterhouse", "list_skills", "learn_skill", "uninstall_skill",
     "list_machine_sessions", "attach_machine_session",
+    "memory_remember", "memory_set_scope", "memory_housekeep", "memory_promote", "memory_demote",
 ]);
+export function getCurrentToolAgentSlug() {
+    return toolAgentContext.getStore();
+}
+export function getCurrentToolTaskId() {
+    return toolTaskContext.getStore();
+}
+export function bindToolsToAgent(agentSlug, allTools, taskId) {
+    return allTools.map((tool) => ({
+        ...tool,
+        handler: (args, invocation) => toolAgentContext.run(agentSlug, () => toolTaskContext.run(taskId, () => tool.handler(args, invocation))),
+    }));
+}
 /** Filter tools based on agent config. */
 export function filterToolsForAgent(agent, allTools) {
     if (agent.tools && agent.tools.length > 0) {
@@ -286,7 +309,7 @@ export function filterToolsForAgent(agent, allTools) {
     return allTools.filter((t) => !MANAGEMENT_TOOL_NAMES.has(t.name));
 }
 /** Create an ephemeral session for an agent. Always creates a fresh session — caller is responsible for destroying it. */
-export async function createEphemeralAgentSession(slug, client, allTools, modelOverride, systemMessagePrefix) {
+export async function createEphemeralAgentSession(slug, client, allTools, modelOverride, systemMessagePrefix, taskId) {
     const agent = getAgent(slug);
     if (!agent)
         throw new Error(`Agent '${slug}' not found in registry.`);
@@ -295,7 +318,7 @@ export async function createEphemeralAgentSession(slug, client, allTools, modelO
     const model = (modelOverride && modelOverride.length > 0)
         ? modelOverride
         : (agent.model === "auto" ? "claude-sonnet-4.6" : agent.model);
-    const tools = filterToolsForAgent(agent, allTools);
+    const tools = bindToolsToAgent(agent.slug, filterToolsForAgent(agent, allTools), taskId);
     const mcpServers = loadMcpConfig();
     const skillDirectories = getSkillDirectories();
     const baseSystemMessage = composeAgentSystemMessage(agent);
@@ -342,9 +365,9 @@ export function getTask(taskId) {
     return activeTasks.get(taskId);
 }
 /** Register a new task. */
-export function registerTask(agentSlug, description, originChannel) {
+export function registerTask(agentSlug, description, originChannel, taskId = nextTaskId()) {
     const task = {
-        taskId: nextTaskId(),
+        taskId,
         agentSlug,
         description,
         status: "running",

package/dist/copilot/agents.test.js

@@ -19,4 +19,11 @@ test("composeAgentSystemMessage steers wiki-capable agents to wiki-conventions",
         assert.match(message, /scan the last 20-30 entries of `pages\/_meta\/log\.md`/i);
     }
 });
+test("composeAgentSystemMessage teaches subagents the three-tier memory model and directs them to memory_propose", () => {
+    const message = composeAgentSystemMessage(makeAgent("coder"));
+    assert.match(message, /three-tier memory model|read, propose, write/i);
+    assert.match(message, /memory_recall/i);
+    assert.match(message, /memory_propose/i);
+    assert.match(message, /do not call `memory_remember` directly|should not call `memory_remember` directly/i);
+});
 //# sourceMappingURL=agents.test.js.map

package/dist/copilot/oneshot.js

@@ -0,0 +1,54 @@
+import { approveAll } from "@github/copilot-sdk";
+import { config } from "../config.js";
+import { SESSIONS_DIR } from "../paths.js";
+import { childLogger } from "../util/logger.js";
+const log = childLogger("copilot.oneshot");
+const DEFAULT_ONE_SHOT_TIMEOUT_MS = 60_000;
+export async function runOneShotPrompt(input) {
+    const model = input.model ?? config.copilotModel;
+    const timeoutMs = input.timeoutMs ?? DEFAULT_ONE_SHOT_TIMEOUT_MS;
+    const maxAttempts = input.expectJson ? 2 : 1;
+    let prompt = input.user;
+    let lastContent = "";
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const session = await input.client.createSession({
+            model,
+            configDir: SESSIONS_DIR,
+            streaming: false,
+            systemMessage: { content: input.system },
+            onPermissionRequest: approveAll,
+        });
+        try {
+            const response = await session.sendAndWait({ prompt }, timeoutMs);
+            lastContent = response?.data?.content?.trim() ?? "";
+            if (!input.expectJson) {
+                return { content: lastContent, model, attempts: attempt };
+            }
+            try {
+                JSON.parse(lastContent);
+                return { content: lastContent, model, attempts: attempt };
+            }
+            catch (error) {
+                if (attempt >= maxAttempts) {
+                    throw error;
+                }
+                prompt = [
+                    input.user,
+                    "",
+                    "Your previous reply was not valid JSON.",
+                    "Return only valid JSON matching the requested schema. Do not wrap it in markdown fences.",
+                ].join("\n");
+            }
+        }
+        finally {
+            try {
+                await session.disconnect();
+            }
+            catch (error) {
+                log.warn({ err: error instanceof Error ? error.message : error, model }, "one-shot disconnect failed");
+            }
+        }
+    }
+    return { content: lastContent, model, attempts: maxAttempts };
+}
+//# sourceMappingURL=oneshot.js.map