@edwardlee5423/magi 0.1.0-alpha.0

package/dist/agent/query-engine.js

@@ -0,0 +1,938 @@
+import { randomUUID } from "node:crypto";
+import { parsePromptIntoParts, textMessage } from "../providers/ir.js";
+import { runAgentQuery } from "./query.js";
+import { executeHooks } from "../hooks/runner.js";
+import { compactSessionWithHooks } from "../context/compaction.js";
+import { computeSessionContextBudget } from "../context/token-budget.js";
+import { buildLayeredContext } from "../context/layers.js";
+import { interactionErrorStatus } from "../interactions.js";
+import { appendMemory, extractExplicitMemoryWrite } from "../memory.js";
+import { selectRelevantMemories } from "../memory-selection.js";
+import { buildSystemInstructions } from "./system-prompt.js";
+import { getBuiltinToolDefinitions } from "../tools/registry.js";
+import { searchMemdir, readMemdirIndex } from "../memdir.js";
+import { formatGoalContext, getGoal } from "../goal.js";
+export class QueryEngine {
+    input;
+    toolUses = new Map();
+    constructor(input) {
+        this.input = input;
+    }
+    async submitMessage(prompt) {
+        const jobId = this.input.jobId ?? randomUUID();
+        const events = [];
+        const currentUserMessageId = this.input.store.appendMessage({
+            sessionId: this.input.sessionId,
+            role: "user",
+            content: prompt,
+            metadata: { source: "query-engine" }
+        });
+        this.input.store.recordJob({
+            id: jobId,
+            sessionId: this.input.sessionId,
+            kind: "agent.query",
+            status: "running",
+            metadata: {
+                provider: this.input.routes[0]?.providerName,
+                model: this.input.routes[0]?.model
+            }
+        });
+        this.input.store.recordAudit({
+            sessionId: this.input.sessionId,
+            jobId,
+            action: "agent.query.started",
+            target: this.input.routes[0]?.providerName,
+            metadata: { routeCount: this.input.routes.length }
+        });
+        this.input.activeInteractions?.registerJob({ sessionId: this.input.sessionId, jobId });
+        const memoryWrite = await this.handleExplicitMemoryWrite(prompt, jobId);
+        events.push(...memoryWrite);
+        const promptHooks = await this.executeSessionHooks("user_prompt_submit", jobId, {
+            source: "query",
+            provider: this.input.routes[0]?.providerName,
+            model: this.input.routes[0]?.model,
+            prompt
+        });
+        events.push(...promptHooks);
+        const startHooks = await this.executeSessionHooks("session_start", jobId, {
+            source: "query",
+            provider: this.input.routes[0]?.providerName,
+            model: this.input.routes[0]?.model
+        });
+        events.push(...startHooks);
+        const preparedContext = await this.prepareContext(prompt, jobId, currentUserMessageId);
+        events.push(...preparedContext.events);
+        const iterator = runAgentQuery({
+            routes: this.input.routes,
+            messages: preparedContext.messages,
+            cwd: this.input.cwd,
+            env: this.input.env,
+            stateRoot: this.input.stateRoot,
+            webSearchConfig: this.input.webSearchConfig,
+            permissionMode: this.input.permissionMode,
+            approvalResolver: (request) => this.resolveApproval(jobId, request),
+            userQuestionResolver: (request) => this.resolveUserQuestion(jobId, request),
+            userMessageSink: this.input.userMessageSink,
+            spawnSubAgent: this.input.spawnSubAgent,
+            hooks: this.input.hooks,
+            sessionId: this.input.sessionId,
+            signal: this.input.signal,
+            mcp: this.input.mcp ? {
+                servers: this.input.mcp.servers,
+                tokenLookup: (serverName) => this.input.store.getMcpOAuthToken(serverName)?.accessToken,
+                tokenRefresh: async (serverName) => {
+                    try {
+                        const { refreshStoredToken } = await import("../mcp/oauth-flow.js");
+                        return await refreshStoredToken({ serverName, store: this.input.store });
+                    }
+                    catch {
+                        return undefined;
+                    }
+                }
+            } : undefined,
+            onStreamEvent: this.input.onStreamEvent
+        });
+        let final;
+        try {
+            let next = await iterator.next();
+            while (!next.done) {
+                events.push(next.value);
+                events.push(...await this.persistEvent(jobId, next.value));
+                next = await iterator.next();
+            }
+            final = next.value;
+            this.input.store.appendMessage({
+                sessionId: this.input.sessionId,
+                role: "assistant",
+                content: final.text,
+                metadata: {
+                    provider: final.providerName,
+                    model: final.model,
+                    turns: final.turns,
+                    attempts: final.attempts
+                }
+            });
+            this.input.store.updateJobStatus({
+                id: jobId,
+                status: "completed",
+                metadata: {
+                    provider: final.providerName,
+                    model: final.model,
+                    turns: final.turns,
+                    attempts: final.attempts
+                }
+            });
+            this.input.store.recordUsage({
+                sessionId: this.input.sessionId,
+                provider: final.providerName,
+                model: final.model,
+                inputTokens: final.usage.inputTokens,
+                outputTokens: final.usage.outputTokens,
+                costUsd: 0
+            });
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.query.completed",
+                target: final.providerName,
+                metadata: { turns: final.turns, attempts: final.attempts }
+            });
+            const endHooks = await this.executeSessionHooks("session_end", jobId, {
+                source: "query",
+                provider: final.providerName,
+                model: final.model,
+                lastAssistantMessage: final.text
+            });
+            events.push(...endHooks);
+            return { ...final, jobId, events };
+        }
+        catch (error) {
+            const cancelled = isAbortError(error) || this.input.signal?.aborted === true;
+            this.input.store.updateJobStatus({
+                id: jobId,
+                status: cancelled ? "cancelled" : "failed",
+                metadata: { error: error instanceof Error ? error.message : String(error) }
+            });
+            if (!cancelled || !events.some((event) => event.type === "cancelled")) {
+                this.input.store.recordAudit({
+                    sessionId: this.input.sessionId,
+                    jobId,
+                    action: cancelled ? "agent.query.cancelled" : "agent.query.failed",
+                    metadata: {
+                        error: error instanceof Error ? error.message : String(error),
+                        reason: this.input.signal?.reason ? String(this.input.signal.reason) : undefined
+                    }
+                });
+            }
+            await this.executeSessionHooks("session_end", jobId, {
+                source: "query",
+                provider: this.input.routes[0]?.providerName,
+                model: this.input.routes[0]?.model,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+        finally {
+            this.input.activeInteractions?.unregisterJob(jobId);
+        }
+    }
+    async resolveApproval(jobId, request) {
+        if (!this.input.activeInteractions) {
+            return this.input.approvalResolver?.(request) ?? false;
+        }
+        const wait = this.input.activeInteractions.waitForApproval({
+            sessionId: this.input.sessionId,
+            jobId,
+            toolUse: request.toolUse,
+            reason: request.reason,
+            timeoutMs: this.input.interactionTimeoutMs
+        });
+        const cleanupAbort = this.cancelInteractionOnAbort({
+            jobId,
+            toolUseId: request.toolUse.id,
+            reason: "request aborted"
+        });
+        const pending = this.input.activeInteractions.getInteraction({ jobId, toolUseId: request.toolUse.id });
+        this.input.store.recordAudit({
+            sessionId: this.input.sessionId,
+            jobId,
+            action: "agent.approval.pending",
+            target: request.toolUse.name,
+            metadata: {
+                status: "pending",
+                interactionKind: "approval",
+                toolUseId: request.toolUse.id,
+                toolUse: request.toolUse,
+                reason: request.reason,
+                diff: request.diff,
+                timeoutAt: pending?.timeoutAt
+            }
+        });
+        try {
+            const approved = await wait;
+            const resolved = this.input.activeInteractions.getInteraction({ jobId, toolUseId: request.toolUse.id });
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.approval.resolved",
+                target: request.toolUse.name,
+                metadata: {
+                    status: "resolved",
+                    interactionKind: "approval",
+                    toolUseId: request.toolUse.id,
+                    approved,
+                    resolvedAt: resolved?.updatedAt
+                }
+            });
+            return approved;
+        }
+        catch (error) {
+            const status = interactionErrorStatus(error);
+            if (status) {
+                const current = this.input.activeInteractions.getInteraction({ jobId, toolUseId: request.toolUse.id });
+                this.input.store.recordAudit({
+                    sessionId: this.input.sessionId,
+                    jobId,
+                    action: status === "timeout" ? "agent.approval.timeout" : "agent.approval.cancelled",
+                    target: request.toolUse.name,
+                    metadata: {
+                        status,
+                        interactionKind: "approval",
+                        toolUseId: request.toolUse.id,
+                        reason: current?.cancelReason ?? request.reason,
+                        error: error instanceof Error ? error.message : String(error)
+                    }
+                });
+            }
+            throw error;
+        }
+        finally {
+            cleanupAbort();
+        }
+    }
+    async resolveUserQuestion(jobId, request) {
+        if (!this.input.activeInteractions) {
+            if (!this.input.userQuestionResolver) {
+                throw new Error("AskUserQuestion requires an interactive user question resolver");
+            }
+            return await this.input.userQuestionResolver(request);
+        }
+        const wait = this.input.activeInteractions.waitForQuestion({
+            sessionId: this.input.sessionId,
+            jobId,
+            toolUse: request.toolUse,
+            question: request.question,
+            timeoutMs: this.input.interactionTimeoutMs
+        });
+        const cleanupAbort = this.cancelInteractionOnAbort({
+            jobId,
+            toolUseId: request.toolUse.id,
+            reason: "request aborted"
+        });
+        const pending = this.input.activeInteractions.getInteraction({ jobId, toolUseId: request.toolUse.id });
+        this.input.store.recordAudit({
+            sessionId: this.input.sessionId,
+            jobId,
+            action: "agent.user_question.pending",
+            target: request.toolUse.name,
+            metadata: {
+                status: "pending",
+                interactionKind: "question",
+                toolUseId: request.toolUse.id,
+                toolUse: request.toolUse,
+                questionCount: request.question.questions.length,
+                question: request.question,
+                timeoutAt: pending?.timeoutAt
+            }
+        });
+        try {
+            const answer = await wait;
+            const resolved = this.input.activeInteractions.getInteraction({ jobId, toolUseId: request.toolUse.id });
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.user_question.resolved",
+                target: request.toolUse.name,
+                metadata: {
+                    status: "resolved",
+                    interactionKind: "question",
+                    toolUseId: request.toolUse.id,
+                    questionCount: request.question.questions.length,
+                    answer,
+                    resolvedAt: resolved?.updatedAt
+                }
+            });
+            return answer;
+        }
+        catch (error) {
+            const status = interactionErrorStatus(error);
+            if (status) {
+                const current = this.input.activeInteractions.getInteraction({ jobId, toolUseId: request.toolUse.id });
+                this.input.store.recordAudit({
+                    sessionId: this.input.sessionId,
+                    jobId,
+                    action: status === "timeout" ? "agent.user_question.timeout" : "agent.user_question.cancelled",
+                    target: request.toolUse.name,
+                    metadata: {
+                        status,
+                        interactionKind: "question",
+                        toolUseId: request.toolUse.id,
+                        questionCount: request.question.questions.length,
+                        reason: current?.cancelReason,
+                        error: error instanceof Error ? error.message : String(error)
+                    }
+                });
+            }
+            throw error;
+        }
+        finally {
+            cleanupAbort();
+        }
+    }
+    cancelInteractionOnAbort(input) {
+        const signal = this.input.signal;
+        if (!signal) {
+            return () => undefined;
+        }
+        const cancel = () => {
+            try {
+                this.input.activeInteractions?.cancelInteraction(input);
+            }
+            catch {
+                // The interaction may have already resolved or timed out.
+            }
+        };
+        if (signal.aborted) {
+            cancel();
+            return () => undefined;
+        }
+        signal.addEventListener("abort", cancel, { once: true });
+        return () => signal.removeEventListener("abort", cancel);
+    }
+    async executeSessionHooks(event, jobId, context, extraContext) {
+        const results = await executeHooks({
+            event,
+            hooks: this.input.hooks ?? [],
+            env: this.input.env,
+            context: {
+                sessionId: this.input.sessionId,
+                jobId,
+                cwd: this.input.cwd,
+                permissionMode: this.input.permissionMode,
+                ...context,
+                ...extraContext
+            },
+            promptModel: async ({ model, messages }) => {
+                const route = this.input.routes[0];
+                const response = await route.adapter.complete({ model, messages });
+                return { text: response.text };
+            }
+        });
+        const events = results.map((result) => ({
+            type: "hook_result",
+            event,
+            result
+        }));
+        for (const hookEvent of events) {
+            await this.persistEvent(jobId, hookEvent);
+        }
+        return events;
+    }
+    async prepareContext(prompt, jobId, currentUserMessageId) {
+        const events = [];
+        const session = this.input.store.getSession(this.input.sessionId);
+        if (!session) {
+            return { messages: [textMessage("user", prompt)], events };
+        }
+        const summaries = this.input.store.listContextSummaries(session.id);
+        const budget = computeSessionContextBudget({ session, summaries });
+        const tokenThreshold = this.input.contextOptions?.autoCompactTokenThreshold;
+        const messageThreshold = this.input.contextOptions?.autoCompactMessageThreshold;
+        // Count messages NOT yet covered by an existing summary so we don't
+        // re-trigger compaction immediately after a recent compact.
+        const lastSummary = summaries[summaries.length - 1];
+        const messagesSinceCompact = lastSummary
+            ? Math.max(0, session.messages.length - lastSummary.sourceMessageCount)
+            : session.messages.length;
+        const tokenTriggered = tokenThreshold !== undefined && budget.estimatedTokens > tokenThreshold;
+        const messageTriggered = messageThreshold !== undefined && messagesSinceCompact > messageThreshold;
+        if (tokenTriggered || messageTriggered) {
+            const route = this.input.contextOptions?.compactionRoute ?? this.input.routes[0];
+            const compactModel = this.input.contextOptions?.compactionRoute?.model ?? this.input.contextOptions?.compactionModel;
+            const compacted = await compactSessionWithHooks({
+                store: this.input.store,
+                sessionId: session.id,
+                hooks: this.input.hooks ?? [],
+                cwd: this.input.cwd,
+                env: this.input.env,
+                trigger: "auto",
+                modelRunner: compactModel
+                    ? {
+                        adapter: route.adapter,
+                        providerName: route.providerName,
+                        model: compactModel
+                    }
+                    : undefined
+            });
+            const compactEvent = {
+                type: "compact_boundary",
+                summaryId: compacted.summary.id,
+                sourceMessageCount: compacted.summary.sourceMessageCount,
+                estimatedTokensBefore: budget.estimatedTokens
+            };
+            events.push(compactEvent);
+            await this.persistEvent(jobId, compactEvent);
+        }
+        return {
+            messages: buildSessionMessages({
+                store: this.input.store,
+                sessionId: session.id,
+                prompt,
+                currentUserMessageId,
+                recentMessages: this.input.contextOptions?.recentMessages ?? 20,
+                memoryContext: await this.buildMemoryContext(prompt, jobId),
+                goalContext: this.input.memoryOptions?.paths ? formatGoalContext(getGoal(this.input.memoryOptions.paths, session.id)) : undefined,
+                cwd: this.input.cwd,
+                paths: this.input.memoryOptions?.paths
+            }),
+            events
+        };
+    }
+    async handleExplicitMemoryWrite(prompt, jobId) {
+        const memory = this.input.memoryOptions;
+        if (!memory?.paths || memory.enabled === false || memory.autoWrite === "off") {
+            return [];
+        }
+        const write = extractExplicitMemoryWrite(prompt);
+        if (!write) {
+            return [];
+        }
+        const result = appendMemory({
+            paths: memory.paths,
+            scope: write.scope,
+            cwd: this.input.cwd,
+            sessionId: this.input.sessionId,
+            text: write.text,
+            store: this.input.store,
+            detailed: true
+        });
+        this.input.store.recordAudit({
+            sessionId: this.input.sessionId,
+            jobId,
+            action: result.appended ? "agent.memory.written" : result.conflicts.length > 0 ? "agent.memory.conflict" : "agent.memory.duplicate",
+            target: result.file,
+            metadata: {
+                scope: write.scope,
+                appended: result.appended,
+                duplicate: result.duplicate,
+                conflictCount: result.conflicts.length,
+                key: result.entry.key
+            }
+        });
+        return [];
+    }
+    async buildMemoryContext(prompt, jobId) {
+        const memory = this.input.memoryOptions;
+        if (!memory?.paths || memory.enabled === false) {
+            return undefined;
+        }
+        const sections = [];
+        // 1. Memdir index — always loaded if present
+        const memdirIndex = readMemdirIndex(memory.paths);
+        if (memdirIndex.trim()) {
+            sections.push(memdirIndex.trim());
+        }
+        // 2. Memdir relevant entries — top matches
+        const memdirMatches = searchMemdir({
+            paths: memory.paths,
+            query: prompt,
+            maxResults: 5
+        });
+        if (memdirMatches.length > 0) {
+            const lines = ["[Relevant memdir entries]"];
+            for (const entry of memdirMatches) {
+                lines.push(`## ${entry.name} (${entry.type})`);
+                lines.push(entry.description);
+                if (entry.body) {
+                    const summary = entry.body.length > 600 ? entry.body.slice(0, 600) + "..." : entry.body;
+                    lines.push(summary);
+                }
+                lines.push("");
+            }
+            sections.push(lines.join("\n").trim());
+        }
+        // 3. Legacy memory.ts entries — for backwards compatibility
+        const result = await selectRelevantMemories({
+            paths: memory.paths,
+            cwd: this.input.cwd,
+            sessionId: this.input.sessionId,
+            scopes: memory.scopes,
+            maxResults: memory.maxResults ?? 5,
+            prompt,
+            selectionRoute: memory.selectionRoute,
+            signal: this.input.signal
+        });
+        if (result.entries.length === 0) {
+            // Legacy memory empty, but memdir sections may have content
+            if (sections.length === 0)
+                return undefined;
+            return sections.join("\n\n");
+        }
+        this.input.store.recordAudit({
+            sessionId: this.input.sessionId,
+            jobId,
+            action: "agent.memory.retrieved",
+            target: this.input.sessionId,
+            metadata: {
+                resultCount: result.entries.length,
+                method: result.method,
+                scopes: Array.from(new Set(result.entries.map((entry) => entry.scope))),
+                keys: result.entries.map((entry) => entry.key).filter((key) => Boolean(key))
+            }
+        });
+        if (result.formatted) {
+            sections.push(result.formatted);
+        }
+        return sections.join("\n\n");
+    }
+    async persistEvent(jobId, event) {
+        if (event.type === "tool_use") {
+            this.toolUses.set(event.toolUse.id, event.toolUse);
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.tool.use",
+                target: event.toolUse.name,
+                metadata: { id: event.toolUse.id, input: event.toolUse.input }
+            });
+            return [];
+        }
+        if (event.type === "request_start") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.request.started",
+                target: this.input.routes[0]?.providerName,
+                metadata: {
+                    provider: this.input.routes[0]?.providerName,
+                    model: this.input.routes[0]?.model
+                }
+            });
+            return [];
+        }
+        if (event.type === "text_delta") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.text.delta",
+                target: this.input.routes[0]?.providerName,
+                metadata: {
+                    length: event.text.length,
+                    preview: event.text.slice(0, 240)
+                }
+            });
+            return [];
+        }
+        if (event.type === "assistant_message") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.assistant.message",
+                target: this.input.routes[0]?.providerName,
+                metadata: {
+                    partCount: event.message.content.length,
+                    textLength: event.message.content
+                        .filter((part) => part.type === "text")
+                        .reduce((sum, part) => sum + part.text.length, 0),
+                    toolUseCount: event.message.content.filter((part) => part.type === "tool-use").length
+                }
+            });
+            return [];
+        }
+        if (event.type === "tool_result") {
+            this.input.store.appendMessage({
+                sessionId: this.input.sessionId,
+                role: "tool",
+                content: event.content,
+                metadata: {
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    isError: event.isError,
+                    retryable: event.retryable
+                }
+            });
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: event.isError ? "agent.tool.failed" : "agent.tool.completed",
+                target: event.toolName,
+                metadata: { toolCallId: event.toolCallId }
+            });
+            const toolUse = this.toolUses.get(event.toolCallId);
+            const extraEvents = [];
+            if (event.isError && event.content.startsWith("Permission ")) {
+                this.input.store.recordAudit({
+                    sessionId: this.input.sessionId,
+                    jobId,
+                    action: "agent.permission.denied",
+                    target: event.toolName,
+                    metadata: { toolCallId: event.toolCallId, reason: event.content }
+                });
+                extraEvents.push(...await this.executeSessionHooks("permission_denied", jobId, {
+                    source: "query",
+                    provider: this.input.routes[0]?.providerName,
+                    model: this.input.routes[0]?.model,
+                    error: event.content
+                }, {
+                    toolName: event.toolName,
+                    toolInput: toolUse?.input,
+                    toolUseId: event.toolCallId,
+                    reason: event.content
+                }));
+            }
+            if (event.toolName === "TodoWrite" && !event.isError) {
+                this.input.store.recordAudit({
+                    sessionId: this.input.sessionId,
+                    jobId,
+                    action: "agent.todo.updated",
+                    target: this.input.sessionId,
+                    metadata: buildTodoAuditMetadata(event.toolCallId, toolUse)
+                });
+            }
+            if (event.toolName === "Config" && !event.isError) {
+                if (toolUse?.input.value !== undefined) {
+                    this.input.store.recordAudit({
+                        sessionId: this.input.sessionId,
+                        jobId,
+                        action: "agent.config.updated",
+                        target: typeof toolUse.input.setting === "string" ? toolUse.input.setting : "unknown",
+                        metadata: {
+                            toolCallId: event.toolCallId,
+                            valueType: typeof toolUse.input.value
+                        }
+                    });
+                    extraEvents.push(...await this.executeSessionHooks("config_change", jobId, {
+                        source: "query",
+                        provider: this.input.routes[0]?.providerName,
+                        model: this.input.routes[0]?.model
+                    }, {
+                        toolName: event.toolName,
+                        toolInput: toolUse.input,
+                        toolUseId: event.toolCallId,
+                        filePath: this.input.stateRoot ? `${this.input.stateRoot}/../config.yaml` : undefined
+                    }));
+                }
+            }
+            if (event.toolName === "Skill" && !event.isError) {
+                if (typeof toolUse?.input.skill === "string") {
+                    this.input.store.recordAudit({
+                        sessionId: this.input.sessionId,
+                        jobId,
+                        action: "agent.skill.loaded",
+                        target: toolUse.input.skill,
+                        metadata: {
+                            toolCallId: event.toolCallId,
+                            argsProvided: typeof toolUse.input.args === "string"
+                        }
+                    });
+                }
+            }
+            return extraEvents;
+        }
+        if (event.type === "fallback_switched") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.provider.fallback",
+                target: event.toProvider,
+                metadata: event
+            });
+            return await this.executeSessionHooks("notification", jobId, {
+                source: "query",
+                provider: event.toProvider,
+                model: event.toModel,
+                message: `Provider fallback switched from ${event.fromProvider} to ${event.toProvider}`,
+                title: "Provider fallback",
+                notificationType: "provider_fallback"
+            });
+        }
+        if (event.type === "approval_request") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.approval.requested",
+                target: event.toolUse.name,
+                metadata: { toolUse: event.toolUse, reason: event.reason }
+            });
+            return await this.executeSessionHooks("permission_request", jobId, {
+                source: "query",
+                provider: this.input.routes[0]?.providerName,
+                model: this.input.routes[0]?.model
+            }, {
+                toolName: event.toolUse.name,
+                toolInput: event.toolUse.input,
+                toolUseId: event.toolUse.id,
+                reason: event.reason
+            });
+        }
+        if (event.type === "user_question") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.user_question.answered",
+                target: event.toolUse.name,
+                metadata: {
+                    toolUse: event.toolUse,
+                    questionCount: event.question.questions.length,
+                    answer: event.answer
+                }
+            });
+            return [];
+        }
+        if (event.type === "user_message") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.user_message.sent",
+                target: event.toolUse.name,
+                metadata: {
+                    toolUse: event.toolUse,
+                    message: event.message,
+                    result: event.result
+                }
+            });
+            return [];
+        }
+        if (event.type === "hook_result") {
+            this.persistHookResult(jobId, event.event, event.result, {
+                toolCallId: event.toolCallId,
+                toolName: event.toolName
+            });
+            return [];
+        }
+        if (event.type === "compact_boundary") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.context.compacted",
+                target: event.summaryId,
+                metadata: event
+            });
+            return [];
+        }
+        if (event.type === "usage") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.usage.reported",
+                target: this.input.routes[0]?.providerName,
+                metadata: {
+                    inputTokens: event.usage.inputTokens,
+                    outputTokens: event.usage.outputTokens
+                }
+            });
+            return [];
+        }
+        if (event.type === "max_turns_reached") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.query.max_turns",
+                metadata: { maxTurnsReached: true }
+            });
+            return [];
+        }
+        if (event.type === "cancelled") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.query.cancelled",
+                target: this.input.routes[0]?.providerName,
+                metadata: { reason: event.reason }
+            });
+            return [];
+        }
+        if (event.type === "done") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.query.done",
+                target: this.input.routes[0]?.providerName,
+                metadata: {
+                    textLength: event.text.length,
+                    messageCount: event.messages.length
+                }
+            });
+            return [];
+        }
+        if (event.type === "error") {
+            this.input.store.recordAudit({
+                sessionId: this.input.sessionId,
+                jobId,
+                action: "agent.query.error",
+                metadata: event
+            });
+            return [];
+        }
+        return [];
+    }
+    persistHookResult(jobId, event, result, metadata) {
+        this.input.store.recordAudit({
+            sessionId: this.input.sessionId,
+            jobId,
+            action: result.error ? "agent.hook.failed" : "agent.hook.completed",
+            target: `${event}:${result.hook.type}`,
+            metadata: {
+                event,
+                hookType: result.hook.type,
+                condition: result.hook.if,
+                toolCallId: metadata?.toolCallId,
+                toolName: metadata?.toolName,
+                exitCode: result.exitCode,
+                blocked: result.blocked,
+                timedOut: result.timedOut,
+                output: result.output,
+                error: result.error
+            }
+        });
+    }
+}
+function isAbortError(error) {
+    return error instanceof DOMException && error.name === "AbortError"
+        || error instanceof Error && error.name === "AbortError";
+}
+function buildTodoAuditMetadata(toolCallId, toolUse) {
+    const todos = Array.isArray(toolUse?.input.todos) ? toolUse.input.todos : [];
+    return {
+        toolCallId,
+        todoCount: todos.length,
+        statusCounts: countTodoStatuses(todos),
+        todos
+    };
+}
+function countTodoStatuses(todos) {
+    const counts = {
+        pending: 0,
+        in_progress: 0,
+        completed: 0
+    };
+    for (const todo of todos) {
+        if (typeof todo !== "object" || todo === null || Array.isArray(todo)) {
+            continue;
+        }
+        const status = todo.status;
+        if (status === "pending" || status === "in_progress" || status === "completed") {
+            counts[status] += 1;
+        }
+    }
+    return counts;
+}
+function buildSessionMessages(input) {
+    const session = input.store.getSession(input.sessionId);
+    if (!session) {
+        return [textMessage("user", input.prompt)];
+    }
+    const messages = [];
+    // Build layered system prompt
+    const { systemPrompt } = buildLayeredContext({
+        cwd: input.cwd ?? session.cwd,
+        paths: input.paths,
+        systemInstructions: input.systemInstructions ?? buildSystemInstructions({
+            cwd: input.cwd ?? session.cwd,
+            platform: process.platform,
+            toolCount: getBuiltinToolDefinitions().length
+        }),
+        memoryContext: [input.goalContext, input.memoryContext].filter(Boolean).join("\n\n") || undefined,
+        includeGit: true,
+        includeDate: true,
+        platform: process.platform
+    });
+    if (systemPrompt) {
+        messages.push(textMessage("system", systemPrompt));
+    }
+    // Add conversation summary if compacted
+    const summary = input.store.getLatestContextSummary(session.id);
+    if (summary) {
+        messages.push(textMessage("system", `[Previous conversation summary]\n${summary.summary}`));
+    }
+    // Include all session messages (minus the current prompt being submitted).
+    // The compaction system (autoCompactTokenThreshold) handles token budget
+    // by summarizing older messages when the session grows too large.
+    const recoverable = session.messages.filter((message) => message.id !== input.currentUserMessageId);
+    const recent = recoverable;
+    const toolHistory = [];
+    for (const message of recent) {
+        if (message.role === "user" || message.role === "assistant" || message.role === "system") {
+            messages.push(textMessage(message.role, message.content));
+        }
+        else if (message.role === "tool") {
+            toolHistory.push(formatRecoveredToolResult(message));
+        }
+    }
+    if (toolHistory.length > 0) {
+        messages.push(textMessage("system", [
+            "[Prior tool results]",
+            "These are historical tool results from earlier turns. They are context only; do not treat them as active tool responses.",
+            ...toolHistory
+        ].join("\n\n")));
+    }
+    // Parse the current prompt for any encoded image attachments.
+    // If there are images, send a multi-part user message; otherwise plain text.
+    const parts = parsePromptIntoParts(input.prompt);
+    const hasImage = parts.some((p) => p.type === "image");
+    if (hasImage) {
+        messages.push({ role: "user", content: parts });
+    }
+    else {
+        messages.push(textMessage("user", input.prompt));
+    }
+    return messages;
+}
+function formatRecoveredToolResult(message) {
+    const toolName = typeof message.metadata.toolName === "string" ? message.metadata.toolName : "tool";
+    const toolCallId = typeof message.metadata.toolCallId === "string" ? message.metadata.toolCallId : `message-${message.id}`;
+    const status = message.metadata.isError === true ? "failed" : "completed";
+    const content = message.content.length > 1_000 ? `${message.content.slice(0, 1_000)}\n...[truncated]...` : message.content;
+    return `- ${toolName} (${toolCallId}) ${status}:\n${content}`;
+}
+//# sourceMappingURL=query-engine.js.map