@oni.bot/core 1.0.1 → 1.0.3

package/dist/harness/agent-loop.js

@@ -4,6 +4,7 @@
 // ============================================================
 import { generateId } from "./types.js";
 import { validateToolArgs } from "./validate-args.js";
+import { MemoryLoader } from "./memory-loader.js";
 // ─── agentLoop ─────────────────────────────────────────────────────────────
 export async function* agentLoop(prompt, config) {
     const sessionId = generateId("ses");
@@ -13,6 +14,27 @@ export async function* agentLoop(prompt, config) {
         ? [...config.initialMessages]
         : [];
     let turn = 0;
+    // ── 0. Memory init ───────────────────────────────────────────────────────
+    const memoryLoader = config.memoryRoot
+        ? MemoryLoader.fromRoot(config.memoryRoot, {
+            budgets: config.memoryBudgets,
+            debug: config.memoryDebug,
+        })
+        : null;
+    let memoryContext = "";
+    if (memoryLoader && !config.signal?.aborted) {
+        memoryLoader.wake();
+        memoryLoader.orient();
+        const t2 = memoryLoader.match(prompt);
+        if (config.memoryDebug && t2.dropped.length > 0) {
+            console.log(`[MemoryLoader] match() dropped ${t2.dropped.length} units over T2 budget`);
+        }
+        memoryContext = memoryLoader.buildSystemPrompt([0, 1, 2]);
+    }
+    const effectiveSystemPrompt = memoryContext
+        ? [memoryContext, config.systemPrompt].filter(Boolean).join("\n\n")
+        : config.systemPrompt;
+    let sessionOutcome = "completed";
     // ── 1. Session Init ──────────────────────────────────────────────────
     if (config.hooksEngine) {
         const hookResult = await config.hooksEngine.fire("SessionStart", {
@@ -25,6 +47,12 @@ export async function* agentLoop(prompt, config) {
             messages.push({ role: "assistant", content: "Context loaded." });
         }
     }
+    // ── 1b. Build allTools (base tools + memory_query if memory is active) ──
+    // Note: config.tools is used in SessionStart hooks (intentional — memory_query
+    // is a runtime capability, not a base tool). allTools is used for llmTools/toolMap.
+    const allTools = memoryLoader
+        ? [...config.tools, memoryLoader.getQueryTool()]
+        : config.tools;
     // Push user prompt
     messages.push({ role: "user", content: prompt });
     yield makeMessage("system", sessionId, turn, {
@@ -32,423 +60,478 @@ export async function* agentLoop(prompt, config) {
         content: `Session ${sessionId} started for agent "${config.agentName}"`,
     });
     // ── 2. Build LLMToolDef[] ────────────────────────────────────────────
-    const llmTools = config.tools.map((t) => ({
+    const llmTools = allTools.map((t) => ({
         name: t.name,
         description: t.description,
         parameters: t.schema,
     }));
     // Tool lookup map
     const toolMap = new Map();
-    for (const t of config.tools) {
+    for (const t of allTools) {
         toolMap.set(t.name, t);
     }
     // ── 3. Main Loop ─────────────────────────────────────────────────────
-    while (turn < maxTurns) {
-        // ── 3a. Check AbortSignal ────────────────────────────────────────
-        if (config.signal?.aborted) {
-            yield makeMessage("error", sessionId, turn, {
-                content: "Agent loop aborted by signal",
-            });
-            return;
-        }
-        // ── 3b. Context Compaction ───────────────────────────────────────
-        if (config.compactor) {
-            const compactionCheck = config.compactor.checkCompaction(messages);
-            if (compactionCheck.needed) {
-                const beforeCount = messages.length;
-                yield makeMessage("system", sessionId, turn, {
-                    subtype: "compact_start",
-                    content: "Context compaction starting",
-                    metadata: {
-                        beforeCount,
-                        estimatedTokens: compactionCheck.estimatedTokens,
-                        threshold: compactionCheck.threshold,
-                        maxTokens: compactionCheck.maxTokens,
-                        percentUsed: compactionCheck.percentUsed,
-                    },
+    try {
+        while (turn < maxTurns) {
+            // ── 3a. Check AbortSignal ────────────────────────────────────────
+            if (config.signal?.aborted) {
+                sessionOutcome = "interrupted";
+                yield makeMessage("error", sessionId, turn, {
+                    content: "Agent loop aborted by signal",
                 });
-                try {
-                    if (config.hooksEngine) {
-                        await config.hooksEngine.fire("PreCompact", {
-                            sessionId,
-                            messageCount: beforeCount,
-                            estimatedTokens: compactionCheck.estimatedTokens,
-                        });
-                    }
-                    const compacted = await config.compactor.compact(messages, { skipInitialCheck: true });
-                    const estimatedTokensAfter = config.compactor.estimateTokens(compacted);
-                    const percentUsedAfter = compactionCheck.maxTokens > 0
-                        ? estimatedTokensAfter / compactionCheck.maxTokens
-                        : 0;
-                    const afterCount = compacted.length;
-                    const summarized = afterCount <= 2 && beforeCount > 2;
-                    messages.length = 0;
-                    messages.push(...compacted);
+                return;
+            }
+            // ── 3b. Context Compaction ───────────────────────────────────────
+            if (config.compactor) {
+                const compactionCheck = config.compactor.checkCompaction(messages);
+                if (compactionCheck.needed) {
+                    const beforeCount = messages.length;
                     yield makeMessage("system", sessionId, turn, {
-                        subtype: "compact_boundary",
-                        content: "Context compacted",
+                        subtype: "compact_start",
+                        content: "Context compaction starting",
                         metadata: {
                             beforeCount,
-                            afterCount,
-                            summarized,
-                            estimatedTokensBefore: compactionCheck.estimatedTokens,
-                            estimatedTokensAfter,
+                            estimatedTokens: compactionCheck.estimatedTokens,
                             threshold: compactionCheck.threshold,
                             maxTokens: compactionCheck.maxTokens,
-                            percentUsedBefore: compactionCheck.percentUsed,
-                            percentUsedAfter,
+                            percentUsed: compactionCheck.percentUsed,
                         },
                     });
+                    try {
+                        if (config.hooksEngine) {
+                            await config.hooksEngine.fire("PreCompact", {
+                                sessionId,
+                                messageCount: beforeCount,
+                                estimatedTokens: compactionCheck.estimatedTokens,
+                            });
+                        }
+                        const compacted = await config.compactor.compact(messages, { skipInitialCheck: true });
+                        const estimatedTokensAfter = config.compactor.estimateTokens(compacted);
+                        const percentUsedAfter = compactionCheck.maxTokens > 0
+                            ? estimatedTokensAfter / compactionCheck.maxTokens
+                            : 0;
+                        const afterCount = compacted.length;
+                        const summarized = afterCount <= 2 && beforeCount > 2;
+                        messages.length = 0;
+                        messages.push(...compacted);
+                        yield makeMessage("system", sessionId, turn, {
+                            subtype: "compact_boundary",
+                            content: "Context compacted",
+                            metadata: {
+                                beforeCount,
+                                afterCount,
+                                summarized,
+                                estimatedTokensBefore: compactionCheck.estimatedTokens,
+                                estimatedTokensAfter,
+                                threshold: compactionCheck.threshold,
+                                maxTokens: compactionCheck.maxTokens,
+                                percentUsedBefore: compactionCheck.percentUsed,
+                                percentUsedAfter,
+                            },
+                        });
+                        if (config.hooksEngine) {
+                            await config.hooksEngine.fire("PostCompact", {
+                                sessionId,
+                                beforeCount,
+                                afterCount,
+                                estimatedTokensAfter,
+                                summarized,
+                            });
+                        }
+                    }
+                    catch (err) {
+                        const errorMsg = err instanceof Error ? err.message : String(err);
+                        yield makeMessage("system", sessionId, turn, {
+                            subtype: "compact_error",
+                            content: `Context compaction failed: ${errorMsg}`,
+                            metadata: {
+                                beforeCount,
+                                afterCount: beforeCount,
+                                estimatedTokensBefore: compactionCheck.estimatedTokens,
+                                threshold: compactionCheck.threshold,
+                                maxTokens: compactionCheck.maxTokens,
+                                percentUsedBefore: compactionCheck.percentUsed,
+                                error: errorMsg,
+                            },
+                        });
+                    }
+                }
+            }
+            // ── 3c. Build system prompt ──────────────────────────────────────
+            let systemPrompt = effectiveSystemPrompt;
+            // Inject remaining turns so the model knows its budget
+            const remaining = maxTurns - turn;
+            systemPrompt += `\n\nYou have ${remaining} turns remaining. Each turn lets you call multiple tools. Do NOT stop early — use your tools and complete the task autonomously.`;
+            if (config.env) {
+                const envLines = [];
+                if (config.env.cwd)
+                    envLines.push(`Working directory: ${config.env.cwd}`);
+                if (config.env.platform)
+                    envLines.push(`Platform: ${config.env.platform}`);
+                if (config.env.date)
+                    envLines.push(`Date: ${config.env.date}`);
+                if (config.env.gitBranch)
+                    envLines.push(`Git branch: ${config.env.gitBranch}`);
+                if (config.env.gitStatus)
+                    envLines.push(`Git status: ${config.env.gitStatus}`);
+                if (envLines.length > 0) {
+                    systemPrompt += `\n\n<env>\n${envLines.join("\n")}\n</env>`;
+                }
+            }
+            // ── 3d. Skill injection ──────────────────────────────────────────
+            if (config.skillLoader) {
+                const pending = config.skillLoader.getPendingInjection();
+                if (pending) {
+                    messages.push({ role: "user", content: pending });
+                    messages.push({ role: "assistant", content: "Skill instructions loaded." });
+                    config.skillLoader.clearPendingInjection();
+                }
+            }
+            // ── 3e. Yield step_start ─────────────────────────────────────────
+            const stepStartTime = Date.now();
+            yield makeMessage("step_start", sessionId, turn, {
+                metadata: { step: turn },
+            });
+            // ── 3f. Inference (with retry on transient errors) ───────────────
+            let response;
+            const maxRetries = 3;
+            let lastInferenceError = null;
+            let succeeded = false;
+            const inferenceTimeoutMs = config.inferenceTimeoutMs ?? 120_000;
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                try {
+                    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Inference timeout after ${inferenceTimeoutMs}ms`)), inferenceTimeoutMs));
+                    response = await Promise.race([
+                        config.model.chat({
+                            messages,
+                            tools: llmTools.length > 0 ? llmTools : undefined,
+                            systemPrompt,
+                            maxTokens: config.maxTokens ?? 8192,
+                        }),
+                        timeoutPromise,
+                    ]);
+                    succeeded = true;
+                    break;
                 }
                 catch (err) {
-                    const errorMsg = err instanceof Error ? err.message : String(err);
+                    lastInferenceError = err;
+                    const isRetryable = isRetryableError(err);
+                    if (!isRetryable || attempt >= maxRetries) {
+                        break;
+                    }
+                    // Check abort signal before retrying
+                    if (config.signal?.aborted) {
+                        break;
+                    }
+                    // Yield inference_retry so the conductor can emit events and update the UI
+                    const delayMs = getRetryDelay(err, attempt);
                     yield makeMessage("system", sessionId, turn, {
-                        subtype: "compact_error",
-                        content: `Context compaction failed: ${errorMsg}`,
+                        subtype: "inference_retry",
+                        content: `Retrying inference (attempt ${attempt + 1}/${maxRetries}): ${err instanceof Error ? err.message : String(err)}`,
                         metadata: {
-                            beforeCount,
-                            afterCount: beforeCount,
-                            estimatedTokensBefore: compactionCheck.estimatedTokens,
-                            threshold: compactionCheck.threshold,
-                            maxTokens: compactionCheck.maxTokens,
-                            percentUsedBefore: compactionCheck.percentUsed,
-                            error: errorMsg,
+                            attempt: attempt + 1,
+                            maxRetries,
+                            delayMs,
+                            error: err instanceof Error ? err.message : String(err),
                         },
                     });
+                    if (delayMs > 0) {
+                        // Abort-aware delay: resolve early if signal fires
+                        await new Promise((resolve) => {
+                            if (config.signal) {
+                                const onAbort = () => { clearTimeout(timer); resolve(); };
+                                if (config.signal.aborted) {
+                                    resolve();
+                                    return;
+                                }
+                                config.signal.addEventListener("abort", onAbort, { once: true });
+                                const timer = setTimeout(() => {
+                                    config.signal.removeEventListener("abort", onAbort);
+                                    resolve();
+                                }, delayMs);
+                            }
+                            else {
+                                setTimeout(resolve, delayMs);
+                            }
+                        });
+                    }
                 }
             }
-        }
-        // ── 3c. Build system prompt ──────────────────────────────────────
-        let systemPrompt = config.systemPrompt;
-        // Inject remaining turns so the model knows its budget
-        const remaining = maxTurns - turn;
-        systemPrompt += `\n\nYou have ${remaining} turns remaining. Each turn lets you call multiple tools. Do NOT stop early — use your tools and complete the task autonomously.`;
-        if (config.env) {
-            const envLines = [];
-            if (config.env.cwd)
-                envLines.push(`Working directory: ${config.env.cwd}`);
-            if (config.env.platform)
-                envLines.push(`Platform: ${config.env.platform}`);
-            if (config.env.date)
-                envLines.push(`Date: ${config.env.date}`);
-            if (config.env.gitBranch)
-                envLines.push(`Git branch: ${config.env.gitBranch}`);
-            if (config.env.gitStatus)
-                envLines.push(`Git status: ${config.env.gitStatus}`);
-            if (envLines.length > 0) {
-                systemPrompt += `\n\n<env>\n${envLines.join("\n")}\n</env>`;
-            }
-        }
-        // ── 3d. Skill injection ──────────────────────────────────────────
-        if (config.skillLoader) {
-            const pending = config.skillLoader.getPendingInjection();
-            if (pending) {
-                messages.push({ role: "user", content: pending });
-                messages.push({ role: "assistant", content: "Skill instructions loaded." });
-                config.skillLoader.clearPendingInjection();
-            }
-        }
-        // ── 3e. Yield step_start ─────────────────────────────────────────
-        const stepStartTime = Date.now();
-        yield makeMessage("step_start", sessionId, turn, {
-            metadata: { step: turn },
-        });
-        // ── 3f. Inference (with retry on transient errors) ───────────────
-        let response;
-        const maxRetries = 3;
-        let lastInferenceError = null;
-        let succeeded = false;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                response = await config.model.chat({
-                    messages,
-                    tools: llmTools.length > 0 ? llmTools : undefined,
-                    systemPrompt,
-                    maxTokens: config.maxTokens ?? 8192,
+            if (!succeeded) {
+                sessionOutcome = "error";
+                yield makeMessage("error", sessionId, turn, {
+                    content: `Inference error: ${lastInferenceError instanceof Error ? lastInferenceError.message : String(lastInferenceError)}`,
+                    metadata: { finalMessages: messages },
                 });
-                succeeded = true;
-                break;
+                return;
             }
-            catch (err) {
-                lastInferenceError = err;
-                const isRetryable = isRetryableError(err);
-                if (!isRetryable || attempt >= maxRetries) {
-                    break;
-                }
-                // Check abort signal before retrying
-                if (config.signal?.aborted) {
-                    break;
+            // ── 3g. Yield assistant message ──────────────────────────────────
+            yield makeMessage("assistant", sessionId, turn, {
+                content: response.content,
+                toolCalls: response.toolCalls,
+                metadata: {
+                    usage: response.usage,
+                    stopReason: response.stopReason,
+                },
+            });
+            // ── 3g2. Yield step_finish with usage (for parent stats merge) ──
+            yield makeMessage("step_finish", sessionId, turn, {
+                metadata: {
+                    stepDurationMs: Date.now() - stepStartTime,
+                    usage: response.usage,
+                    stopReason: response.stopReason,
+                    toolCount: response.toolCalls?.length ?? 0,
+                },
+            });
+            // ── 3h. Stop condition ───────────────────────────────────────────
+            if (!response.toolCalls || response.toolCalls.length === 0) {
+                if (config.hooksEngine) {
+                    const stopResult = await config.hooksEngine.fire("Stop", {
+                        sessionId,
+                        response: response.content,
+                    });
+                    if (stopResult?.decision === "block") {
+                        // Inject feedback as user message, increment turn, continue
+                        const feedback = stopResult.reason ?? "Please provide a more complete response.";
+                        messages.push({
+                            role: "assistant",
+                            content: response.content,
+                        });
+                        messages.push({
+                            role: "user",
+                            content: feedback,
+                        });
+                        turn++;
+                        continue;
+                    }
                 }
-                // Yield inference_retry so the conductor can emit events and update the UI
-                const delayMs = getRetryDelay(err, attempt);
-                yield makeMessage("system", sessionId, turn, {
-                    subtype: "inference_retry",
-                    content: `Retrying inference (attempt ${attempt + 1}/${maxRetries}): ${err instanceof Error ? err.message : String(err)}`,
-                    metadata: {
-                        attempt: attempt + 1,
-                        maxRetries,
-                        delayMs,
-                        error: err instanceof Error ? err.message : String(err),
-                    },
-                });
-                if (delayMs > 0) {
-                    // Abort-aware delay: resolve early if signal fires
-                    await new Promise((resolve) => {
-                        const timer = setTimeout(resolve, delayMs);
-                        if (config.signal) {
-                            const onAbort = () => { clearTimeout(timer); resolve(); };
-                            if (config.signal.aborted) {
-                                clearTimeout(timer);
-                                resolve();
-                                return;
-                            }
-                            config.signal.addEventListener("abort", onAbort, { once: true });
-                        }
+                // Fire SessionEnd and yield result
+                if (config.hooksEngine) {
+                    await config.hooksEngine.fire("SessionEnd", {
+                        sessionId,
+                        reason: "completed",
+                        turns: turn + 1,
                     });
                 }
-            }
-        }
-        if (!succeeded) {
-            yield makeMessage("error", sessionId, turn, {
-                content: `Inference error: ${lastInferenceError instanceof Error ? lastInferenceError.message : String(lastInferenceError)}`,
-                metadata: { finalMessages: messages },
-            });
-            return;
-        }
-        // ── 3g. Yield assistant message ──────────────────────────────────
-        yield makeMessage("assistant", sessionId, turn, {
-            content: response.content,
-            toolCalls: response.toolCalls,
-            metadata: {
-                usage: response.usage,
-                stopReason: response.stopReason,
-            },
-        });
-        // ── 3g2. Yield step_finish with usage (for parent stats merge) ──
-        yield makeMessage("step_finish", sessionId, turn, {
-            metadata: {
-                stepDurationMs: Date.now() - stepStartTime,
-                usage: response.usage,
-                stopReason: response.stopReason,
-                toolCount: response.toolCalls?.length ?? 0,
-            },
-        });
-        // ── 3h. Stop condition ───────────────────────────────────────────
-        if (!response.toolCalls || response.toolCalls.length === 0) {
-            if (config.hooksEngine) {
-                const stopResult = await config.hooksEngine.fire("Stop", {
-                    sessionId,
-                    response: response.content,
+                // Include the assistant's final message in history before emitting
+                messages.push({ role: "assistant", content: response.content });
+                yield makeMessage("result", sessionId, turn, {
+                    content: response.content,
+                    metadata: { totalTurns: turn + 1, finalMessages: messages },
                 });
-                if (stopResult?.decision === "block") {
-                    // Inject feedback as user message, increment turn, continue
-                    const feedback = stopResult.reason ?? "Please provide a more complete response.";
-                    messages.push({
-                        role: "assistant",
-                        content: response.content,
+                return;
+            }
+            // ── 3i. Tool execution ───────────────────────────────────────────
+            const toolResults = [];
+            for (const toolCall of response.toolCalls) {
+                // Fire PreToolUse hook
+                if (config.hooksEngine) {
+                    const preResult = await config.hooksEngine.fire("PreToolUse", {
+                        sessionId,
+                        toolName: toolCall.name,
+                        input: toolCall.args,
                     });
-                    messages.push({
-                        role: "user",
-                        content: feedback,
+                    if (preResult?.decision === "deny") {
+                        toolResults.push({
+                            toolCallId: toolCall.id,
+                            toolName: toolCall.name,
+                            content: `Tool use denied: ${preResult.reason ?? "blocked by hook"}`,
+                            isError: true,
+                        });
+                        continue;
+                    }
+                    // Apply modifiedInput if hook returned one
+                    if (preResult?.modifiedInput) {
+                        Object.assign(toolCall.args, preResult.modifiedInput);
+                    }
+                }
+                // Safety gate check
+                if (config.safetyGate && config.safetyGate.requiresCheck(toolCall.name)) {
+                    const safetyResult = await config.safetyGate.check({
+                        id: toolCall.id,
+                        name: toolCall.name,
+                        args: toolCall.args,
                     });
-                    turn++;
-                    continue;
+                    if (!safetyResult.approved) {
+                        toolResults.push({
+                            toolCallId: toolCall.id,
+                            toolName: toolCall.name,
+                            content: `Tool blocked by safety gate: ${safetyResult.reason ?? "unsafe operation"}`,
+                            isError: true,
+                        });
+                        continue;
+                    }
                 }
-            }
-            // Fire SessionEnd and yield result
-            if (config.hooksEngine) {
-                await config.hooksEngine.fire("SessionEnd", {
-                    sessionId,
-                    reason: "completed",
-                    turns: turn + 1,
-                });
-            }
-            // Include the assistant's final message in history before emitting
-            messages.push({ role: "assistant", content: response.content });
-            yield makeMessage("result", sessionId, turn, {
-                content: response.content,
-                metadata: { totalTurns: turn + 1, finalMessages: messages },
-            });
-            return;
-        }
-        // ── 3i. Tool execution ───────────────────────────────────────────
-        const toolResults = [];
-        for (const toolCall of response.toolCalls) {
-            // Fire PreToolUse hook
-            if (config.hooksEngine) {
-                const preResult = await config.hooksEngine.fire("PreToolUse", {
-                    sessionId,
-                    toolName: toolCall.name,
-                    input: toolCall.args,
-                });
-                if (preResult?.decision === "deny") {
+                // Find and execute tool
+                const toolDef = toolMap.get(toolCall.name);
+                if (!toolDef) {
                     toolResults.push({
                         toolCallId: toolCall.id,
                         toolName: toolCall.name,
-                        content: `Tool use denied: ${preResult.reason ?? "blocked by hook"}`,
+                        content: `Unknown tool: ${toolCall.name}`,
                         isError: true,
                     });
                     continue;
                 }
-                // Apply modifiedInput if hook returned one
-                if (preResult?.modifiedInput) {
-                    Object.assign(toolCall.args, preResult.modifiedInput);
+                // Validate tool arguments before execution
+                if (toolDef.schema) {
+                    const validationError = validateToolArgs(toolCall.args, toolDef.schema, toolCall.name);
+                    if (validationError) {
+                        toolResults.push({
+                            toolCallId: toolCall.id,
+                            toolName: toolCall.name,
+                            content: `${validationError}. Please retry with correct arguments.`,
+                            isError: true,
+                        });
+                        continue;
+                    }
                 }
-            }
-            // Safety gate check
-            if (config.safetyGate && config.safetyGate.requiresCheck(toolCall.name)) {
-                const safetyResult = await config.safetyGate.check({
-                    id: toolCall.id,
-                    name: toolCall.name,
-                    args: toolCall.args,
+                // Yield tool_start so the conductor can emit tool.call events
+                yield makeMessage("tool_start", sessionId, turn, {
+                    metadata: {
+                        toolName: toolCall.name,
+                        toolArgs: toolCall.args,
+                        toolCallId: toolCall.id,
+                    },
                 });
-                if (!safetyResult.approved) {
+                const metadataUpdates = [];
+                const toolCtx = {
+                    config: {},
+                    store: null,
+                    state: {},
+                    emit: () => { },
+                    sessionId,
+                    threadId,
+                    agentName: config.agentName,
+                    turn,
+                    signal: config.signal,
+                    metadata: (update) => {
+                        metadataUpdates.push(update);
+                    },
+                };
+                try {
+                    const startTime = Date.now();
+                    const rawResult = await toolDef.execute(toolCall.args, toolCtx);
+                    const durationMs = Date.now() - startTime;
+                    const content = typeof rawResult === "string" ? rawResult : JSON.stringify(rawResult);
+                    // Push the successful result first — before the hook — so a hook
+                    // throw cannot retroactively mark this tool call as failed.
                     toolResults.push({
                         toolCallId: toolCall.id,
                         toolName: toolCall.name,
-                        content: `Tool blocked by safety gate: ${safetyResult.reason ?? "unsafe operation"}`,
-                        isError: true,
+                        content,
+                        durationMs,
                     });
-                    continue;
+                    // Yield collected metadata updates from ctx.metadata() calls
+                    for (const mu of metadataUpdates) {
+                        yield makeMessage("tool_metadata", sessionId, turn, {
+                            metadata: {
+                                toolCallId: toolCall.id,
+                                toolName: toolCall.name,
+                                title: mu.title,
+                                data: mu.metadata,
+                            },
+                        });
+                    }
+                    // Fire PostToolUse — in its own try/catch so a hook error does not
+                    // corrupt the conversation history by triggering PostToolUseFailure
+                    // for a tool that actually succeeded.
+                    if (config.hooksEngine) {
+                        try {
+                            await config.hooksEngine.fire("PostToolUse", {
+                                sessionId,
+                                toolName: toolCall.name,
+                                input: toolCall.args,
+                                output: rawResult,
+                                durationMs,
+                            });
+                        }
+                        catch {
+                            // Hook errors are non-fatal — the tool result is already recorded.
+                        }
+                    }
                 }
-            }
-            // Find and execute tool
-            const toolDef = toolMap.get(toolCall.name);
-            if (!toolDef) {
-                toolResults.push({
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.name,
-                    content: `Unknown tool: ${toolCall.name}`,
-                    isError: true,
-                });
-                continue;
-            }
-            // Validate tool arguments before execution
-            if (toolDef.schema) {
-                const validationError = validateToolArgs(toolCall.args, toolDef.schema, toolCall.name);
-                if (validationError) {
+                catch (err) {
+                    const errorMsg = err instanceof Error ? err.message : String(err);
+                    // Fire PostToolUseFailure — in its own try/catch so a hook error does not
+                    // drop the error result from toolResults or corrupt conversation history.
+                    if (config.hooksEngine) {
+                        try {
+                            await config.hooksEngine.fire("PostToolUseFailure", {
+                                sessionId,
+                                toolName: toolCall.name,
+                                input: toolCall.args,
+                                error: err instanceof Error ? err : errorMsg,
+                            });
+                        }
+                        catch {
+                            // Hook errors are non-fatal — the tool error result is still recorded.
+                        }
+                    }
                     toolResults.push({
                         toolCallId: toolCall.id,
                         toolName: toolCall.name,
-                        content: `${validationError}. Please retry with correct arguments.`,
+                        content: memoryLoader
+                            ? `Tool error: ${errorMsg}\n\nMemory query may help — call memory_query with a specific topic if this failure suggests a knowledge gap.`
+                            : `Tool error: ${errorMsg}`,
                         isError: true,
                     });
-                    continue;
                 }
             }
-            // Yield tool_start so the conductor can emit tool.call events
-            yield makeMessage("tool_start", sessionId, turn, {
-                metadata: {
-                    toolName: toolCall.name,
-                    toolArgs: toolCall.args,
-                    toolCallId: toolCall.id,
-                },
+            // ── 3j. Update messages ──────────────────────────────────────────
+            messages.push({
+                role: "assistant",
+                content: response.content,
+                toolCalls: response.toolCalls,
             });
-            const metadataUpdates = [];
-            const toolCtx = {
-                config: {},
-                store: null,
-                state: {},
-                emit: () => { },
-                sessionId,
-                threadId,
-                agentName: config.agentName,
-                turn,
-                signal: config.signal,
-                metadata: (update) => {
-                    metadataUpdates.push(update);
-                },
-            };
-            try {
-                const startTime = Date.now();
-                const rawResult = await toolDef.execute(toolCall.args, toolCtx);
-                const durationMs = Date.now() - startTime;
-                const content = typeof rawResult === "string" ? rawResult : JSON.stringify(rawResult);
-                // Fire PostToolUse
-                if (config.hooksEngine) {
-                    await config.hooksEngine.fire("PostToolUse", {
-                        sessionId,
-                        toolName: toolCall.name,
-                        input: toolCall.args,
-                        output: rawResult,
-                        durationMs,
-                    });
-                }
-                toolResults.push({
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.name,
-                    content,
-                    durationMs,
+            for (const tr of toolResults) {
+                messages.push({
+                    role: "tool",
+                    content: tr.content,
+                    toolCallId: tr.toolCallId,
+                    name: tr.toolName,
                 });
-                // Yield collected metadata updates from ctx.metadata() calls
-                for (const mu of metadataUpdates) {
-                    yield makeMessage("tool_metadata", sessionId, turn, {
-                        metadata: {
-                            toolCallId: toolCall.id,
-                            toolName: toolCall.name,
-                            title: mu.title,
-                            data: mu.metadata,
-                        },
-                    });
-                }
             }
-            catch (err) {
-                const errorMsg = err instanceof Error ? err.message : String(err);
-                // Fire PostToolUseFailure
-                if (config.hooksEngine) {
-                    await config.hooksEngine.fire("PostToolUseFailure", {
-                        sessionId,
-                        toolName: toolCall.name,
-                        input: toolCall.args,
-                        error: err instanceof Error ? err : errorMsg,
+            // ── 3j. TODO reminder ────────────────────────────────────────────
+            if (config.todoModule) {
+                const todoState = config.todoModule.getState();
+                if (todoState.todos.length > 0) {
+                    const reminder = config.todoModule.toContextString();
+                    messages.push({ role: "user", content: `<system-reminder>\n${reminder}\n</system-reminder>` });
+                    messages.push({ role: "assistant", content: "Noted." });
+                    yield makeMessage("system", sessionId, turn, {
+                        subtype: "todo_reminder",
+                        content: reminder,
                     });
                 }
-                toolResults.push({
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.name,
-                    content: `Tool error: ${errorMsg}`,
-                    isError: true,
-                });
             }
-        }
-        // ── 3j. Update messages ──────────────────────────────────────────
-        messages.push({
-            role: "assistant",
-            content: response.content,
-            toolCalls: response.toolCalls,
-        });
-        for (const tr of toolResults) {
-            messages.push({
-                role: "tool",
-                content: tr.content,
-                toolCallId: tr.toolCallId,
-                name: tr.toolName,
+            // ── 3k. Yield tool_result, increment turn ───────────────────────
+            yield makeMessage("tool_result", sessionId, turn, {
+                toolResults,
             });
+            turn++;
         }
-        // ── 3j. TODO reminder ────────────────────────────────────────────
-        if (config.todoModule) {
-            const todoState = config.todoModule.getState();
-            if (todoState.todos.length > 0) {
-                const reminder = config.todoModule.toContextString();
-                messages.push({ role: "user", content: `<system-reminder>\n${reminder}\n</system-reminder>` });
-                messages.push({ role: "assistant", content: "Noted." });
-                yield makeMessage("system", sessionId, turn, {
-                    subtype: "todo_reminder",
-                    content: reminder,
-                });
-            }
-        }
-        // ── 3k. Yield tool_result, increment turn ───────────────────────
-        yield makeMessage("tool_result", sessionId, turn, {
-            toolResults,
+        // Post-loop: maxTurns exhausted
+        sessionOutcome = "budget-exceeded";
+        yield makeMessage("error", sessionId, turn, {
+            content: `Agent loop exceeded maxTurns (${maxTurns})`,
+            metadata: { finalMessages: messages },
         });
-        turn++;
     }
-    // ── 4. maxTurns exceeded ─────────────────────────────────────────────
-    yield makeMessage("error", sessionId, turn, {
-        content: `Agent loop exceeded maxTurns (${maxTurns})`,
-        metadata: { finalMessages: messages },
-    });
+    catch (err) {
+        sessionOutcome = "error";
+        yield makeMessage("error", sessionId, turn, {
+            content: `Agent loop error: ${err instanceof Error ? err.message : String(err)}`,
+            metadata: { finalMessages: messages },
+        });
+    }
+    finally {
+        if (memoryLoader) {
+            const log = buildEpisodicLog(sessionId, prompt, turn, sessionOutcome, config.compactor);
+            memoryLoader.persistEpisodic(sessionId, log);
+            memoryLoader.resetSession();
+        }
+    }
 }
 // ─── wrapWithAgentLoop ─────────────────────────────────────────────────────
 export function wrapWithAgentLoop(config) {
@@ -521,4 +604,40 @@ function getRetryDelay(err, attempt) {
     }
     return Math.min(1000 * Math.pow(2, attempt), 10_000);
 }
+/**
+ * buildEpisodicLog — Assemble session log for persistEpisodic().
+ *
+ * When compactor.getLastSummary() is unavailable (not yet implemented),
+ * ## What Happened falls back to the raw task description.
+ */
+function buildEpisodicLog(sessionId, taskDescription, turnCount, outcome, compactor) {
+    const c = compactor;
+    const summary = c?.getLastSummary?.() ?? null;
+    const openThreads = c?.getOpenThreads?.() ?? "none";
+    const outcomeNote = outcome === "budget-exceeded"
+        ? "Session ended at turn limit. Task may be incomplete — check Open Threads before assuming prior work is done."
+        : "";
+    return [
+        `---`,
+        `type: episodic`,
+        `session: ${sessionId}`,
+        `outcome: ${outcome}`,
+        `turns: ${turnCount}`,
+        `created: ${new Date().toISOString()}`,
+        `---`,
+        ``,
+        `## What Happened`,
+        summary ?? taskDescription,
+        ``,
+        `## Turns`,
+        String(turnCount),
+        ``,
+        `## Outcome`,
+        outcome,
+        ...(outcomeNote ? [``, outcomeNote] : []),
+        ``,
+        `## Open Threads`,
+        openThreads,
+    ].join("\n");
+}
 //# sourceMappingURL=agent-loop.js.map