chapterhouse 0.3.26 → 0.4.1

package/dist/copilot/orchestrator.js

@@ -3,6 +3,11 @@ 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 { getActiveScope } from "../memory/active-scope.js";
+import { CheckpointTracker, isCheckpointInFlight, runCheckpointExtraction } from "../memory/checkpoint.js";
+import { isHousekeepingInFlight, runHousekeeping } from "../memory/housekeeping.js";
+import { runEndOfTaskMemoryHook } from "../memory/eot.js";
 import { CHAPTERHOUSE_VERSION } from "../version.js";
 import { config, DEFAULT_MODEL } from "../config.js";
 import { loadMcpConfig } from "./mcp-config.js";
@@ -14,6 +19,7 @@ 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, } from "./agents.js";
+import * as agentsModule from "./agents.js";
 import { childLogger } from "../util/logger.js";
 import { agentEventBus } from "./agent-event-bus.js";
 import { initTaskEventLog } from "./task-event-log.js";
@@ -67,9 +73,163 @@ 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;
 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 = getActiveScope();
+    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 = getActiveScope();
+    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;
+    }
+    try {
+        void runHousekeeping({ scopeIds });
+    }
+    catch (error) {
+        log.error({ err: error, sessionKey, scope_ids: scopeIds }, "memory.housekeeping.error");
+    }
+}
+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) => {
+        log.error({ err: error, sessionKey }, "memory.checkpoint.error");
+    });
+}
 export function subscribeTaskEvents(taskId, listener) {
     return agentEventBus.subscribe("session:tool_call", (event) => {
         if (event.sessionId !== taskId)
@@ -152,18 +312,30 @@ export function getCurrentAuthorizationHeader() {
 // Internal helpers
 // ---------------------------------------------------------------------------
 function getSessionConfig() {
-    const tools = createTools({
+    const baseTools = createTools({
         client: copilotClient,
         onAgentTaskComplete: feedAgentResult,
     });
+    const tools = agentsModule.bindToolsToAgent?.("chapterhouse", baseTools) ?? baseTools;
     const mcpServers = loadMcpConfig();
     const skillDirectories = getSkillDirectories();
     return { tools, mcpServers, skillDirectories };
 }
+function buildHotTierContext() {
+    if (!config.memoryInjectEnabled) {
+        return undefined;
+    }
+    const hotTierXml = renderHotTierForActiveScope();
+    if (!hotTierXml) {
+        return undefined;
+    }
+    return hotTierXml.trimEnd();
+}
 function getSystemMessageOptions(memorySummary) {
     return {
         selfEditEnabled: config.selfEditEnabled,
         memorySummary: memorySummary || undefined,
+        hotTierXml: buildHotTierContext(),
         agentRoster: buildAgentRoster(),
         userContext: currentUserContext,
     };
@@ -183,6 +355,9 @@ function updateUserContext(source) {
     // Invalidate the default session so it's recreated with the updated system message
     registry?.get("default")?.invalidateSession();
 }
+export function invalidateOrchestratorSession(sessionKey) {
+    registry?.get(sessionKey)?.invalidateSession();
+}
 function updateRequestContext(source) {
     if (source.type !== "web" && source.type !== "sse-web") {
         currentAuthenticatedUser = undefined;
@@ -196,6 +371,15 @@ 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");
+        });
+    }
     const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}:\n\n${result}`;
     const sessionKey = getTaskSessionKey(taskId);
     sendToOrchestrator(prompt, { type: "background", sessionKey }, (text, done) => {
@@ -276,6 +460,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 infiniteSessions,
             });
             log.info({ sessionKey }, "Session resumed successfully");
+            resetCheckpointSessionState(sessionKey);
             upsertCopilotSession(sessionKey, isProjectSession ? "project" : "default", session.sessionId, projectRoot, config.copilotModel);
             const mgr = registry?.get(sessionKey);
             if (mgr)
@@ -301,6 +486,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         infiniteSessions,
     });
     log.info({ sessionKey, sessionId: session.sessionId.slice(0, 8) }, "Session created");
+    resetCheckpointSessionState(sessionKey);
     upsertCopilotSession(sessionKey, isProjectSession ? "project" : "default", session.sessionId, projectRoot, config.copilotModel);
     if (sessionKey === "default")
         setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
@@ -397,9 +583,17 @@ async function executeOnSession(manager, item) {
         // Correlates the SDK's subagent.started event (which only carries agent_type fields) with the
         // actual spawn parameters (name, description) passed to the task() tool call.
         const spawnArgsMap = new Map();
+        const toolStartDetails = new Map();
         // Unconditional capture — must fire even when onActivity is absent so the DB handler can resolve names.
         const unsubSpawnCapture = session.on("tool.execution_start", (event) => {
             const data = event.data;
+            if (data.toolCallId) {
+                toolStartDetails.set(data.toolCallId, {
+                    toolName: String(data.toolName ?? "unknown"),
+                    mcpServerName: typeof data.mcpServerName === "string" ? data.mcpServerName : undefined,
+                    arguments: data.arguments,
+                });
+            }
             if (data.toolName === "task" && data.toolCallId) {
                 const args = (data.arguments ?? {});
                 spawnArgsMap.set(data.toolCallId, {
@@ -424,6 +618,9 @@ async function executeOnSession(manager, item) {
                 : typeof result?.content === "string"
                     ? result.content
                     : undefined;
+            const toolCallId = String(data.toolCallId ?? "");
+            const startDetails = toolStartDetails.get(toolCallId);
+            const completionToolName = data.toolName;
             if (item.onActivity) {
                 item.onActivity({
                     kind: "tool_complete",
@@ -436,13 +633,20 @@ async function executeOnSession(manager, item) {
             // Emit turn:delta with tool-call part (coexistence — #130)
             const toolPart = {
                 type: "tool-call",
-                toolCallId: String(data.toolCallId ?? ""),
-                toolName: String(data.toolName ?? "unknown"),
+                toolCallId,
+                toolName: typeof completionToolName === "string" && completionToolName.length > 0
+                    ? completionToolName
+                    : (startDetails?.toolName ?? "unknown"),
+                mcpServerName: startDetails?.mcpServerName,
+                arguments: startDetails?.arguments,
                 status: data.success !== false ? "done" : "failed",
                 resultPreview,
                 detailedContent,
             };
             emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: toolPart });
+            if (toolCallId) {
+                toolStartDetails.delete(toolCallId);
+            }
         });
         const unsubToolStart = item.onActivity
             ? session.on("tool.execution_start", (event) => {
@@ -586,6 +790,15 @@ 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) => {
+                        log.error({ err: error, taskId }, "memory.eot.error");
+                    });
+                }
                 const taskRow = db.prepare(`SELECT agent_slug FROM agent_tasks WHERE task_id = ?`).get(taskId);
                 void agentEventBus.emit({
                     type: "session:destroyed",
@@ -898,6 +1111,8 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     logConversation("assistant", finalContent, sourceLabel, sessionKey);
                 }
                 catch { /* best-effort */ }
+                scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source);
+                scheduleHousekeeping(sessionKey, source);
                 if (copilotClient) {
                     maybeWriteEpisode(copilotClient).catch((err) => {
                         log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
@@ -997,6 +1212,8 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                     logConversation("assistant", finalContent, sourceLabel, sessionKey);
                 }
                 catch { /* best-effort */ }
+                scheduleCheckpointExtraction(sessionKey, newPrompt, finalContent, source);
+                scheduleHousekeeping(sessionKey, source);
                 if (copilotClient) {
                     maybeWriteEpisode(copilotClient).catch((err) => {
                         log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
@@ -1123,10 +1340,14 @@ export function getAgentInfo() {
 /** Clean up on shutdown/restart. */
 export async function shutdownAgents() {
     if (!registry) {
+        checkpointTrackers.clear();
+        checkpointTurnsBySession.clear();
         await clearActiveTasks();
         return;
     }
     await registry.shutdown();
+    checkpointTrackers.clear();
+    checkpointTurnsBySession.clear();
     await clearActiveTasks();
 }
 //# sourceMappingURL=orchestrator.js.map