chapterhouse 0.3.19 → 0.3.21

package/dist/copilot/orchestrator.js

@@ -19,6 +19,11 @@ import { agentEventBus } from "./agent-event-bus.js";
 import { initTaskEventLog } from "./task-event-log.js";
 import { emitTurnEvent, persistTurnEvents, scheduleClearTurnLog, } from "./turn-event-log.js";
 import { SessionManager, SessionRegistry, SESSION_IDLE_TTL_MS, SESSION_MAX_ACTIVE, } from "./session-manager.js";
+import { ActiveProjectRulesLoadError, renderActiveProjectRulesBlock, } from "./project-rules-injection.js";
+import { detectProjectRuleWarnings } from "./project-rule-warnings.js";
+import { loadRegistry } from "../wiki/project-registry.js";
+import { loadProjectRules } from "../wiki/project-rules.js";
+import { resolveProject } from "./project-resolution.js";
 const log = childLogger("orchestrator");
 const MAX_RETRIES = 3;
 const RECONNECT_DELAYS_MS = [1_000, 3_000, 10_000];
@@ -33,6 +38,19 @@ let proactiveNotifyFn;
 export function setProactiveNotify(fn) {
     proactiveNotifyFn = fn;
 }
+function usesSessionTurnLifecycle(source) {
+    return source.type === "background" || source.type === "sse-web";
+}
+function finalizeTurnEvent(sessionKey, event) {
+    if (event.type === "turn:complete") {
+        emitTurnEvent(sessionKey, { type: "turn:complete", turnId: event.turnId, sessionKey, finalMessage: event.finalMessage });
+    }
+    else {
+        emitTurnEvent(sessionKey, { type: "turn:error", turnId: event.turnId, sessionKey, error: event.error });
+    }
+    persistTurnEvents(event.turnId, sessionKey);
+    scheduleClearTurnLog(event.turnId);
+}
 const turnContextStorage = new AsyncLocalStorage();
 // ---------------------------------------------------------------------------
 // Module-level state (not per-session)
@@ -105,6 +123,9 @@ export function getCurrentChannelKey() {
 export function getCurrentActivityCallback() {
     return turnContextStorage.getStore()?.activityCallback;
 }
+export function getCurrentActiveProjectRules() {
+    return turnContextStorage.getStore()?.activeProjectRules ?? null;
+}
 export function getCurrentAuthenticatedUser() {
     return turnContextStorage.getStore()?.authUser ?? currentAuthenticatedUser;
 }
@@ -347,6 +368,14 @@ export const ORCHESTRATOR_TIMEOUT_MS = (() => {
 async function executeOnSession(manager, item) {
     const { sessionKey } = manager;
     const session = await manager.ensureSession();
+    const activeProjectRules = getActiveProjectRules(item.prompt, item.projectPath);
+    const warningLines = activeProjectRules
+        ? detectProjectRuleWarnings(item.prompt, activeProjectRules.rules.hard)
+        : [];
+    const warningBlock = warningLines.length > 0 ? `${warningLines.join("\n")}\n\n` : "";
+    const sessionPrompt = activeProjectRules
+        ? `${warningBlock}${renderActiveProjectRulesBlock(activeProjectRules.project.slug, activeProjectRules.project.path, activeProjectRules.rules.path, activeProjectRules.rules.hard, activeProjectRules.rules.soft)}\n\n${item.prompt}`
+        : item.prompt;
     // Update last-seen globals (backwards compat — for callers that inspect after a turn ends)
     currentAuthenticatedUser = item.authUser;
     currentAuthorizationHeader = item.authHeader;
@@ -357,6 +386,7 @@ async function executeOnSession(manager, item) {
         authUser: item.authUser,
         authHeader: item.authHeader,
         activityCallback: item.onActivity,
+        activeProjectRules,
     }, async () => {
         let accumulated = "";
         let toolCallExecuted = false;
@@ -373,6 +403,11 @@ async function executeOnSession(manager, item) {
                 spawnArgsMap.set(data.toolCallId, {
                     name: typeof args.name === "string" ? args.name : undefined,
                     description: typeof args.description === "string" ? args.description : undefined,
+                    prompt: typeof args.prompt === "string"
+                        ? args.prompt
+                        : typeof args.task === "string"
+                            ? args.task
+                            : undefined,
                 });
             }
         });
@@ -509,7 +544,12 @@ async function executeOnSession(manager, item) {
                 const description = (typeof spawnArgs?.description === "string"
                     ? spawnArgs.description
                     : data.agentDescription || data.agentDisplayName || `Agent dispatch: ${agentSlug}`).slice(0, 500);
-                db.prepare(`INSERT OR IGNORE INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key, source) VALUES (?, ?, ?, 'running', ?, ?, 'adhoc')`).run(data.toolCallId, agentSlug, description, item.sourceChannel || null, sessionKey);
+                const prompt = typeof spawnArgs?.prompt === "string" ? spawnArgs.prompt : null;
+                db.prepare(`INSERT OR IGNORE INTO agent_tasks (task_id, agent_slug, description, prompt, status, origin_channel, session_key, source)
+             VALUES (?, ?, ?, ?, 'running', ?, ?, 'adhoc')`).run(data.toolCallId, agentSlug, description, prompt, item.sourceChannel || null, sessionKey);
+                if (prompt) {
+                    db.prepare(`UPDATE agent_tasks SET prompt = COALESCE(prompt, ?) WHERE task_id = ?`).run(prompt, data.toolCallId);
+                }
                 activeSubagentTaskIds.add(data.toolCallId);
                 void agentEventBus.emit({
                     type: "session:created",
@@ -649,8 +689,22 @@ async function executeOnSession(manager, item) {
             });
         });
         try {
-            const result = await session.sendAndWait({ prompt: item.prompt, ...(item.attachments && item.attachments.length > 0 ? { attachments: item.attachments } : {}) }, ORCHESTRATOR_TIMEOUT_MS);
-            const finalContent = result?.data?.content || accumulated || "(No response)";
+            if (warningBlock) {
+                accumulated = warningBlock;
+                item.callback(accumulated, false, item.turnId);
+                emitTurnEvent(sessionKey, {
+                    type: "turn:delta",
+                    turnId: item.turnId,
+                    sessionKey,
+                    part: { type: "text", text: warningBlock },
+                });
+            }
+            const result = await session.sendAndWait({ prompt: sessionPrompt, ...(item.attachments && item.attachments.length > 0 ? { attachments: item.attachments } : {}) }, ORCHESTRATOR_TIMEOUT_MS);
+            const streamedContent = warningBlock && accumulated.startsWith(warningBlock)
+                ? accumulated.slice(warningBlock.length)
+                : accumulated;
+            const responseContent = result?.data?.content || streamedContent || "(No response)";
+            const finalContent = warningBlock ? `${warningBlock}${responseContent}` : responseContent;
             return finalContent;
         }
         catch (err) {
@@ -730,6 +784,30 @@ async function processItem(item, manager) {
     lastRouteResult = routeResult;
     return executeOnSession(manager, item);
 }
+function getActiveProjectRules(prompt, projectPath) {
+    const registry = loadRegistry();
+    const project = resolveProject(prompt, { projectPath }, registry);
+    if (!project) {
+        return null;
+    }
+    try {
+        const rules = loadProjectRules(project.slug);
+        if (!rules.found) {
+            return null;
+        }
+        return { project, rules };
+    }
+    catch (err) {
+        if (err instanceof ActiveProjectRulesLoadError || err instanceof Error) {
+            log.warn({
+                slug: err instanceof ActiveProjectRulesLoadError ? err.slug : project.slug,
+                err: err.message,
+            }, "Project rules could not be loaded; continuing without injection");
+            return null;
+        }
+        throw err;
+    }
+}
 function isRecoverableError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     if (/timeout/i.test(msg))
@@ -765,6 +843,10 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
     // sse-web carries user identity just like web (Fix 3).
     const authUser = (source.type === "web" || source.type === "sse-web") ? source.user : undefined;
     const authHeader = (source.type === "web" || source.type === "sse-web") ? source.authorizationHeader?.trim() || undefined : undefined;
+    const emitSessionLifecycle = usesSessionTurnLifecycle(source);
+    if (emitSessionLifecycle) {
+        emitTurnEvent(sessionKey, { type: "turn:started", turnId, sessionKey, prompt, attachments });
+    }
     const manager = registry.getOrCreate(sessionKey);
     void (async () => {
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
@@ -772,6 +854,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                 const finalContent = await new Promise((resolve, reject) => {
                     manager.enqueue({
                         prompt: taggedPrompt,
+                        projectPath: source.type === "web" ? source.projectPath : undefined,
                         attachments,
                         callback,
                         // Cast: QueuedMessage.onActivity uses a wide event type to avoid circular
@@ -793,6 +876,9 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     });
                 });
                 callback(finalContent, true, turnId);
+                if (emitSessionLifecycle) {
+                    finalizeTurnEvent(sessionKey, { type: "turn:complete", turnId, finalMessage: finalContent });
+                }
                 try {
                     logMessage("out", sourceLabel, finalContent);
                 }
@@ -829,6 +915,9 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                 }
                 log.error({ msg }, "Error processing message");
                 callback(`Error: ${msg}`, true, turnId);
+                if (emitSessionLifecycle) {
+                    finalizeTurnEvent(sessionKey, { type: "turn:error", turnId, error: msg });
+                }
                 return;
             }
         }
@@ -873,6 +962,7 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                 const finalContent = await new Promise((resolve, reject) => {
                     manager.enqueue({
                         prompt: taggedPrompt,
+                        projectPath: source.type === "web" ? source.projectPath : undefined,
                         attachments,
                         callback,
                         onActivity: onActivity,
@@ -938,7 +1028,7 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
  *
  * Unlike `sendToOrchestrator`, this function:
  *  - Returns the `turnId` immediately without waiting for the turn to complete.
- *  - Emits turn:started, turn:complete, and turn:error events to the turn event log.
+ *  - 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.
  *
@@ -949,15 +1039,9 @@ export function enqueueForSse(opts) {
     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 };
-    // Emit turn:started immediately so the SSE client sees it before any delta
-    emitTurnEvent(sessionKey, { type: "turn:started", turnId, sessionKey, prompt, attachments });
-    const callback = (text, done, tid) => {
-        if (done) {
-            emitTurnEvent(sessionKey, { type: "turn:complete", turnId: tid, sessionKey, finalMessage: text });
-            persistTurnEvents(tid, sessionKey);
-            scheduleClearTurnLog(tid);
-        }
-        // Note: mid-turn text deltas are emitted by executeOnSession's delta handler
+    const callback = (_text, _done, _tid) => {
+        // Note: sendToOrchestrator now owns turn:started/turn:complete/turn:error emission.
+        // Mid-turn text deltas are still emitted by executeOnSession's delta handler.
     };
     const onQueued = (position, tid) => {
         emitTurnEvent(sessionKey, { type: "turn:queued", turnId: tid, sessionKey, position });