chapterhouse 0.5.2 → 0.7.0

package/dist/copilot/orchestrator.js

@@ -3,13 +3,9 @@ import { randomUUID } from "node:crypto";
 import { approveAll } from "@github/copilot-sdk";
 import { createTools } from "./tools.js";
 import { getOrchestratorSystemMessage } from "./system-message.js";
-import { renderHotTierForActiveScope } from "../memory/hot-tier.js";
-import { getHotTierEntries, renderHotTierXML } from "../memory/hot-tier.js";
 import { getActiveScope, withActiveScope } from "../memory/active-scope.js";
 import { getScope } from "../memory/scopes.js";
-import { CheckpointTracker, isCheckpointInFlight, runCheckpointExtraction } from "../memory/checkpoint.js";
-import { isHousekeepingInFlight, runHousekeeping } from "../memory/housekeeping.js";
-import { runEndOfTaskMemoryHook } from "../memory/eot.js";
+import { MemoryCoordinator } from "./memory-coordinator.js";
 import { CHAPTERHOUSE_VERSION } from "../version.js";
 import { config, DEFAULT_MODEL } from "../config.js";
 import { loadMcpConfig } from "./mcp-config.js";
@@ -20,7 +16,7 @@ import { maybeWriteEpisode } from "./episode-writer.js";
 import { getWikiSummary } from "../wiki/context.js";
 import { SESSIONS_DIR } from "../paths.js";
 import { resolveModel } from "./router.js";
-import { loadAgents, ensureDefaultAgents, clearActiveTasks, getAgentRegistry, setActiveAgent, parseAtMention, buildAgentRoster, getActiveTasks, getAgent, composeAgentSystemMessage, filterToolsForAgent, withToolTaskContext, } from "./agents.js";
+import { loadAgents, ensureDefaultAgents, clearActiveTasks, getAgentRegistry, setActiveAgent, parseAtMention, buildAgentRoster, getActiveTasks, getAgent, composeAgentSystemMessage, filterMcpServersForAgent, filterToolsForAgent, withToolTaskContext, } from "./agents.js";
 import * as agentsModule from "./agents.js";
 import { childLogger } from "../util/logger.js";
 import { agentEventBus } from "./agent-event-bus.js";
@@ -77,157 +73,15 @@ let currentUserContext;
 let currentAuthenticatedUser;
 let currentAuthorizationHeader;
 let lastRouteResult;
-const checkpointTrackers = new Map();
-const checkpointTurnsBySession = new Map();
-const housekeepingTurnsBySession = new Map();
-const MAX_CHECKPOINT_CHARS_PER_SIDE = 4_000;
+let memoryCoordinator;
 export function getLastRouteResult() {
     return lastRouteResult;
 }
-function truncateCheckpointText(value) {
-    const trimmed = value.trim();
-    if (trimmed.length <= MAX_CHECKPOINT_CHARS_PER_SIDE) {
-        return trimmed;
-    }
-    return `${trimmed.slice(0, MAX_CHECKPOINT_CHARS_PER_SIDE)}…`;
-}
-function getCheckpointTracker(sessionKey) {
-    let tracker = checkpointTrackers.get(sessionKey);
-    if (!tracker) {
-        tracker = new CheckpointTracker();
-        checkpointTrackers.set(sessionKey, tracker);
-    }
-    return tracker;
-}
 export function resetCheckpointSessionState(sessionKey) {
-    getCheckpointTracker(sessionKey).reset();
-    checkpointTurnsBySession.delete(sessionKey);
-    housekeepingTurnsBySession.delete(sessionKey);
-}
-function appendCheckpointTurn(sessionKey, turn) {
-    const turns = checkpointTurnsBySession.get(sessionKey) ?? [];
-    turns.push(turn);
-    const overflow = turns.length - config.memoryCheckpointTurns;
-    if (overflow > 0) {
-        turns.splice(0, overflow);
-    }
-    checkpointTurnsBySession.set(sessionKey, turns);
-    return turns;
-}
-function scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source) {
-    if (source.type === "background") {
-        return;
-    }
-    const tracker = getCheckpointTracker(sessionKey);
-    const turns = appendCheckpointTurn(sessionKey, {
-        user: truncateCheckpointText(prompt),
-        assistant: truncateCheckpointText(finalContent),
-    });
-    if (!config.memoryCheckpointEnabled) {
-        log.info({ sessionKey }, "memory.checkpoint.disabled");
-        return;
-    }
-    tracker.tickOrchestratorTurn();
-    if (!tracker.shouldFire()) {
-        return;
-    }
-    tracker.markFired();
-    if (isCheckpointInFlight(sessionKey)) {
-        log.info({ sessionKey }, "memory.checkpoint.in_flight_skip");
-        return;
-    }
-    if (!copilotClient) {
-        log.error({ sessionKey }, "memory.checkpoint.error");
-        return;
-    }
-    const activeScope = getMemoryScopeForSession(sessionKey);
-    void runCheckpointExtraction({
-        sessionKey,
-        turns: turns.slice(-config.memoryCheckpointTurns),
-        activeScope,
-        copilotClient,
-        trigger: "cadence",
-    }).catch((error) => {
-        log.error({ err: error, sessionKey }, "memory.checkpoint.error");
-    });
-}
-function scheduleHousekeeping(sessionKey, source) {
-    if (source.type === "background") {
-        return;
-    }
-    if (!config.memoryHousekeepingEnabled) {
-        log.info({ sessionKey }, "memory.housekeeping.disabled");
-        return;
-    }
-    const turns = (housekeepingTurnsBySession.get(sessionKey) ?? 0) + 1;
-    if (turns < config.memoryHousekeepingTurns) {
-        housekeepingTurnsBySession.set(sessionKey, turns);
-        return;
-    }
-    housekeepingTurnsBySession.set(sessionKey, 0);
-    const activeScope = getMemoryScopeForSession(sessionKey);
-    if (!activeScope) {
-        log.info({ sessionKey }, "memory.housekeeping.no_active_scope");
-        return;
-    }
-    const scopeIds = [activeScope.id];
-    if (isHousekeepingInFlight(scopeIds)) {
-        log.info({ sessionKey, scope_ids: scopeIds }, "memory.housekeeping.in_flight_skip");
-        return;
-    }
-    void runHousekeeping({ scopeIds }).catch((error) => {
-        log.error({ err: error, sessionKey, scope_ids: scopeIds }, "memory.housekeeping.error");
-    });
+    memoryCoordinator?.reset(sessionKey);
 }
 export function maybeScheduleScopeChangeCheckpoint(sessionKey, previousScope, nextScope) {
-    if (!previousScope) {
-        return;
-    }
-    if (!config.memoryCheckpointOnScopeChange) {
-        log.info({ sessionKey, scope: previousScope.slug }, "memory.checkpoint.scope_change_disabled");
-        return;
-    }
-    const tracker = getCheckpointTracker(sessionKey);
-    const turnsSinceLast = tracker.turnsSinceLastFire();
-    if (turnsSinceLast < config.memoryCheckpointMinTurnsForScopeFire) {
-        log.info({
-            sessionKey,
-            scope: previousScope.slug,
-            turns_since_last: turnsSinceLast,
-            min_required: config.memoryCheckpointMinTurnsForScopeFire,
-        }, "memory.checkpoint.scope_change_skip");
-        return;
-    }
-    if (isCheckpointInFlight(sessionKey)) {
-        log.info({ sessionKey, trigger: "scope_change" }, "memory.checkpoint.in_flight_skip");
-        return;
-    }
-    if (!copilotClient) {
-        log.error({ sessionKey }, "memory.checkpoint.error");
-        return;
-    }
-    const turns = checkpointTurnsBySession.get(sessionKey) ?? [];
-    if (turns.length === 0) {
-        log.info({
-            sessionKey,
-            scope: previousScope.slug,
-            turns_since_last: turnsSinceLast,
-            min_required: config.memoryCheckpointMinTurnsForScopeFire,
-        }, "memory.checkpoint.scope_change_skip");
-        return;
-    }
-    tracker.markScopeChangeFire();
-    void runCheckpointExtraction({
-        sessionKey,
-        turns: turns.slice(-config.memoryCheckpointTurns),
-        activeScope: previousScope,
-        copilotClient,
-        trigger: "scope_change",
-        scopeChangeContext: {
-            from: previousScope.slug,
-            to: nextScope?.slug ?? "no active scope",
-        },
-    }).catch((error) => {
+    void memoryCoordinator?.onScopeChange(sessionKey, previousScope?.slug ?? "", nextScope?.slug ?? "").catch((error) => {
         log.error({ err: error, sessionKey }, "memory.checkpoint.error");
     });
 }
@@ -325,6 +179,13 @@ function getSessionConfig() {
 function agentSlugFromSessionKey(sessionKey) {
     return sessionKey.startsWith("agent:") ? sessionKey.slice("agent:".length) : undefined;
 }
+function persistentAgentSessionKey(slug) {
+    const agent = getAgent(slug);
+    if (!agent?.persistent) {
+        return undefined;
+    }
+    return `agent:${agent.slug}`;
+}
 function getPersistentAgentForSessionKey(sessionKey) {
     const slug = agentSlugFromSessionKey(sessionKey);
     if (!slug)
@@ -339,39 +200,11 @@ function getMemoryScopeForSession(sessionKey) {
     }
     return getActiveScope();
 }
-function buildScopedHotTierContext(scope) {
-    if (!config.memoryInjectEnabled || !scope) {
-        return undefined;
-    }
-    const hotTierXml = renderHotTierXML(getHotTierEntries(scope.id));
-    return hotTierXml ? hotTierXml.trimEnd() : undefined;
-}
-function buildHotTierContext() {
-    if (!config.memoryInjectEnabled) {
-        return undefined;
-    }
-    const hotTierXml = renderHotTierForActiveScope();
-    if (!hotTierXml) {
-        return undefined;
-    }
-    return hotTierXml.trimEnd();
-}
-function buildPerTurnMemoryHooks(sessionKey) {
-    if (!config.memoryInjectEnabled) {
-        return undefined;
-    }
-    return {
-        onUserPromptSubmitted: () => {
-            const hotTierXml = buildScopedHotTierContext(getMemoryScopeForSession(sessionKey));
-            return hotTierXml ? { additionalContext: hotTierXml } : undefined;
-        },
-    };
-}
-function getSystemMessageOptions(memorySummary) {
+function getSystemMessageOptions(memorySummary, hotTierXml) {
     return {
         selfEditEnabled: config.selfEditEnabled,
         memorySummary: memorySummary || undefined,
-        hotTierXml: buildHotTierContext(),
+        hotTierXml,
         agentRoster: buildAgentRoster(),
         userContext: currentUserContext,
     };
@@ -407,15 +240,9 @@ function updateRequestContext(source) {
     }
 }
 export function feedAgentResult(taskId, agentSlug, result) {
-    if (copilotClient) {
-        void runEndOfTaskMemoryHook({
-            taskId,
-            finalResult: result,
-            copilotClient,
-        }).catch((error) => {
-            log.error({ err: error, taskId }, "memory.eot.error");
-        });
-    }
+    void memoryCoordinator?.onAgentTaskComplete(taskId, result).catch((error) => {
+        log.error({ err: error, taskId }, "memory.eot.error");
+    });
     const sessionKey = getTaskSessionKey(taskId) || "default";
     const agentTurnId = randomUUID();
     const agentDisplayName = getAgentRegistry().find((agent) => agent.slug === agentSlug)?.name ?? agentSlug;
@@ -509,13 +336,12 @@ async function createOrResumeSession(sessionKey, projectRoot) {
     let { tools, mcpServers, skillDirectories } = baseConfig;
     const isProjectSession = sessionKey.startsWith("project:");
     const persistentAgent = getPersistentAgentForSessionKey(sessionKey);
-    const agentScope = persistentAgent?.scope ? getScope(persistentAgent.scope) ?? null : null;
     const infiniteSessions = {
         enabled: true,
         backgroundCompactionThreshold: 0.80,
         bufferExhaustionThreshold: 0.95,
     };
-    const memoryHooks = buildPerTurnMemoryHooks(sessionKey);
+    const memoryHooks = memoryCoordinator?.buildPerTurnHooks(sessionKey);
     let model = config.copilotModel;
     let systemMessageContent;
     let sessionMode = isProjectSession ? "project" : "default";
@@ -525,7 +351,8 @@ async function createOrResumeSession(sessionKey, projectRoot) {
             client: copilotClient,
             onAgentTaskComplete: feedAgentResult,
         })));
-        const scopedHotTier = buildScopedHotTierContext(agentScope);
+        mcpServers = filterMcpServersForAgent(persistentAgent, mcpServers);
+        const scopedHotTier = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
         const channelNote = `You are in your persistent Chapterhouse channel (${sessionKey}). Your memory scope is ${persistentAgent.scope}.`;
         systemMessageContent = [
             composeAgentSystemMessage(persistentAgent),
@@ -536,8 +363,9 @@ async function createOrResumeSession(sessionKey, projectRoot) {
     }
     else {
         const memorySummary = getWikiSummary();
+        const hotTierXml = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
         systemMessageContent = getOrchestratorSystemMessage({
-            ...getSystemMessageOptions(memorySummary),
+            ...getSystemMessageOptions(memorySummary, hotTierXml),
             version: CHAPTERHOUSE_VERSION,
         });
     }
@@ -559,7 +387,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 infiniteSessions,
             });
             log.info({ sessionKey }, "Session resumed successfully");
-            resetCheckpointSessionState(sessionKey);
+            memoryCoordinator?.reset(sessionKey);
             upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
             const mgr = registry?.get(sessionKey);
             if (mgr)
@@ -586,7 +414,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         infiniteSessions,
     });
     log.info({ sessionKey, sessionId: session.sessionId.slice(0, 8) }, "Session created");
-    resetCheckpointSessionState(sessionKey);
+    memoryCoordinator?.reset(sessionKey);
     upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
     if (sessionKey === "default")
         setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
@@ -597,6 +425,12 @@ async function createOrResumeSession(sessionKey, projectRoot) {
 }
 export async function initOrchestrator(client) {
     copilotClient = client;
+    memoryCoordinator?.shutdown();
+    memoryCoordinator = new MemoryCoordinator({
+        getCopilotClient: () => copilotClient,
+        config,
+        resolveScopeForSession: getMemoryScopeForSession,
+    });
     // Initialize per-task ring buffer — subscribes to agentEventBus for session:tool_call events.
     initTaskEventLog();
     // (Re-)create the registry — supports multiple initOrchestrator calls in tests
@@ -893,12 +727,8 @@ async function executeOnSession(manager, item) {
                 spawnArgsMap.delete(taskId);
                 activeSubagentTaskIds.delete(taskId);
                 db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(finalResult?.slice(0, 10000) ?? null, taskId);
-                if (copilotClient && finalResult) {
-                    void runEndOfTaskMemoryHook({
-                        taskId,
-                        finalResult,
-                        copilotClient,
-                    }).catch((error) => {
+                if (finalResult) {
+                    void memoryCoordinator?.onAgentTaskComplete(taskId, finalResult).catch((error) => {
                         log.error({ err: error, taskId }, "memory.eot.error");
                     });
                 }
@@ -1249,8 +1079,9 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     logConversation("assistant", finalContent, logSource, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
-                scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source);
-                scheduleHousekeeping(sessionKey, source);
+                void memoryCoordinator?.onTurnComplete(sessionKey, prompt, finalContent, source.type).catch((error) => {
+                    log.error({ err: error, sessionKey }, "memory.turn_complete.error");
+                });
                 if (copilotClient) {
                     maybeWriteEpisode(copilotClient).catch((err) => {
                         log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
@@ -1350,8 +1181,9 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                     logConversation("assistant", finalContent, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
-                scheduleCheckpointExtraction(sessionKey, newPrompt, finalContent, source);
-                scheduleHousekeeping(sessionKey, source);
+                void memoryCoordinator?.onTurnComplete(sessionKey, newPrompt, finalContent, source.type).catch((error) => {
+                    log.error({ err: error, sessionKey }, "memory.turn_complete.error");
+                });
                 if (copilotClient) {
                     maybeWriteEpisode(copilotClient).catch((err) => {
                         log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
@@ -1385,19 +1217,18 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
     await manager.abortCurrentTurn();
     log.info({ sessionKey, replacementTurnId: turnId }, "turn.interrupted");
 }
-/**
- * Enqueue a turn for the new POST→SSE chat path (#130).
- *
- * Unlike `sendToOrchestrator`, this function:
- *  - Returns the `turnId` immediately without waiting for the turn to complete.
- *  - Routes through the shared lifecycle emitter in sendToOrchestrator.
- *  - Does NOT write to sseClients — the SSE channel delivers events via subscribeSession().
- *  - Supports interrupt: true which calls interruptCurrentTurn under the hood.
- *
- * @returns turnId (UUID)
- */
 export function enqueueForSse(opts) {
+    if (opts.type === "agent_saved") {
+        agentEventBus.emit({
+            type: "agent_saved",
+            payload: { slug: opts.slug ?? "" },
+        });
+        return;
+    }
     const { sessionKey, prompt, attachments, authUser, authHeader, interrupt } = opts;
+    if (!sessionKey || !prompt) {
+        throw new Error("Missing sessionKey or prompt for SSE turn enqueue");
+    }
     const turnId = randomUUID();
     // sse-web carries auth and enables onQueued — unlike "background" (Fixes 2 & 3).
     const source = { type: "sse-web", sessionKey, user: authUser, authorizationHeader: authHeader };
@@ -1464,6 +1295,37 @@ export async function interruptSessionTurn(sessionKey) {
     }
     return aborted;
 }
+export function getPersistentAgentSessionState(slug) {
+    const sessionKey = persistentAgentSessionKey(slug);
+    if (!sessionKey) {
+        return "none";
+    }
+    const manager = registry?.get(sessionKey);
+    if (!manager) {
+        return "none";
+    }
+    return manager.isProcessing ? "in_flight" : "idle";
+}
+export async function reloadPersistentAgent(slug, onReloaded) {
+    const sessionKey = persistentAgentSessionKey(slug);
+    if (!sessionKey || !registry) {
+        return "none";
+    }
+    let manager = registry.get(sessionKey);
+    if (!manager) {
+        manager = registry.getOrCreate(sessionKey);
+        await manager.ensureSession();
+        onReloaded?.();
+        return "reloaded";
+    }
+    if (manager.isProcessing) {
+        manager.requestSessionReload(onReloaded);
+        return "scheduled";
+    }
+    await manager.restartSession();
+    onReloaded?.();
+    return "reloaded";
+}
 /** Switch the model on the live default orchestrator session without destroying it. */
 export function switchSessionModel(newModel) {
     const manager = registry?.get("default");
@@ -1491,15 +1353,13 @@ export function getAgentInfo() {
 }
 /** Clean up on shutdown/restart. */
 export async function shutdownAgents() {
+    memoryCoordinator?.shutdown();
+    memoryCoordinator = undefined;
     if (!registry) {
-        checkpointTrackers.clear();
-        checkpointTurnsBySession.clear();
         await clearActiveTasks();
         return;
     }
     await registry.shutdown();
-    checkpointTrackers.clear();
-    checkpointTurnsBySession.clear();
     await clearActiveTasks();
 }
 //# sourceMappingURL=orchestrator.js.map