@agent-native/core 0.47.1 → 0.48.2

package/dist/cli/code-agent-executor.js

@@ -1,23 +1,43 @@
 import { createToolSearchEntry, TOOL_SEARCH_ACTION_NAME, } from "../agent/tool-search.js";
-import { createCodingToolRegistry, isReadOnlyShellCommand, runCodingCommand, truncateCodingOutput, } from "../coding-tools/index.js";
+import { createCodingToolRegistry, isReadOnlyShellCommand, runCodingCommand, truncateBashOutput, truncateCodingOutput, } from "../coding-tools/index.js";
 import { buildMergedConfig, McpClientManager, mcpToolsToActionEntries, } from "../mcp-client/index.js";
 import { runWithRequestContext } from "../server/request-context.js";
 import { actionsToEngineTools, runAgentLoop, } from "../agent/production-agent.js";
 import { resolveEngine, getStoredModelForEngine, registerBuiltinEngines, } from "../agent/engine/index.js";
 import { PROVIDER_ENV_VARS } from "../agent/engine/provider-env-vars.js";
+import { DEFAULT_AGENT_MAX_ITERATIONS } from "../agent/loop-settings.js";
+import { readAgentsBundleFromFs, generateSkillsPromptBlock, } from "../server/agents-bundle.js";
 import { isReasoningEffort, } from "../shared/reasoning-effort.js";
 import { formatPromptWithAttachments, } from "../code-agents/prompt-attachments.js";
-import { appendCodeAgentTranscriptEvent, dequeueCodeAgentFollowUp, getCodeAgentRunRecord, listCodeAgentTranscriptEvents, updateCodeAgentRunRecord, } from "./code-agent-runs.js";
+import { addCodeAgentCommandToAllowlist, appendCodeAgentTranscriptEvent, dequeueCodeAgentFollowUp, getCodeAgentRunRecord, isCodeAgentCommandAllowed, listCodeAgentTranscriptEvents, updateCodeAgentRunRecord, } from "./code-agent-runs.js";
 import { createCodeAgentOutputSmoother } from "./code-agent-output-smoother.js";
 const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
 const MAX_TOOL_OUTPUT_CHARS = 50_000;
 const MAX_FILE_READ_CHARS = 120_000;
+/**
+ * Number of most-recent transcript events reconstructed as native
+ * EngineMessage objects (with proper tool-call / tool-result pairing).
+ * Events older than this cap are summarised into a single compact text
+ * preamble so the model retains broad context without token waste.
+ */
+const STRUCTURED_HISTORY_RECENT_EVENTS = 40;
+/**
+ * Per-tool-result text cap when reconstructing history.  Matches the overall
+ * tool-output cap so old results don't balloon the context.
+ */
+const STRUCTURED_HISTORY_RESULT_CAP = MAX_TOOL_OUTPUT_CHARS;
 export async function executeCodeAgentRun(options) {
     const existing = getCodeAgentRunRecord(options.runId);
     if (!existing)
         return null;
     const prompt = options.prompt ?? latestUserPrompt(existing.id);
-    const executionPrompt = formatPromptWithAttachments(prompt, options.attachments ?? latestUserPromptAttachments(existing.id, prompt));
+    const rawAttachments = options.attachments ?? latestUserPromptAttachments(existing.id, prompt);
+    // Split attachments: images (dataUrl) go as engine image parts; text/file
+    // attachments are still inlined into the prompt text. This prevents 2 MB
+    // images from consuming ~700 K tokens of garbage when treated as plain text.
+    const imageAttachments = rawAttachments.filter((a) => a.dataUrl);
+    const textOnlyAttachments = rawAttachments.filter((a) => !a.dataUrl);
+    const executionPrompt = formatPromptWithAttachments(prompt, textOnlyAttachments);
     if (!prompt) {
         appendCodeAgentTranscriptEvent({
             runId: existing.id,
@@ -95,14 +115,23 @@ export async function executeCodeAgentRun(options) {
     const reasoningEffort = options.reasoningEffort ?? metadataReasoningEffort(existing);
     const cwd = existing.cwd || process.cwd();
     const permissionMode = existing.permissionMode ?? "full-auto";
-    const actions = createLocalCodeAgentActions(cwd, permissionMode, existing.id);
+    // Holds structured metadata emitted by the coding tools side-channel.
+    // Keyed by tool name; consumed when the matching tool_start / tool_done fires.
+    const pendingToolMeta = new Map();
+    const actions = createLocalCodeAgentActions(cwd, permissionMode, existing.id, (toolName, _phase, meta) => {
+        // Both "start" and "done" phases update the map; done has richer data.
+        pendingToolMeta.set(toolName, meta);
+    }, (chunk) => {
+        // Stream incremental bash output to stdout for the terminal smoother
+        options.stdout?.write(chunk);
+    });
     const mcpManager = await startCodeAgentMcpManager(existing.id);
     if (mcpManager) {
         Object.assign(actions, mcpToolsToActionEntries(mcpManager));
     }
     actions[TOOL_SEARCH_ACTION_NAME] = createToolSearchEntry(() => actions);
     const tools = actionsToEngineTools(actions);
-    const messages = buildCodeAgentMessages(existing, executionPrompt);
+    const messages = buildCodeAgentMessages(existing, executionPrompt, imageAttachments);
     const controller = new AbortController();
     const abortFromParent = () => controller.abort();
     if (options.signal) {
@@ -113,12 +142,43 @@ export async function executeCodeAgentRun(options) {
     }
     let assistantText = "";
     const outputSmoother = createCodeAgentOutputSmoother(options.stdout);
+    // Accumulate thinking text across deltas so we can persist a single event
+    // per reasoning block rather than one event per delta chunk.
+    let pendingThinkingText = "";
+    let thinkingFlushTimer;
+    const runId = existing.id;
+    function flushThinkingEvent() {
+        thinkingFlushTimer = undefined;
+        const text = pendingThinkingText.trim();
+        pendingThinkingText = "";
+        if (!text)
+            return;
+        appendCodeAgentTranscriptEvent({
+            runId,
+            kind: "status",
+            message: text,
+            metadata: { type: "thinking" },
+        });
+    }
     const send = (event) => {
         if (event.type === "text") {
+            // Flush any buffered thinking when real content arrives.
+            if (thinkingFlushTimer !== undefined) {
+                clearTimeout(thinkingFlushTimer);
+                flushThinkingEvent();
+            }
             assistantText += event.text;
             outputSmoother.write(event.text);
             return;
         }
+        if (event.type === "thinking") {
+            pendingThinkingText += event.text;
+            // Debounce: flush 300ms after the last delta so rapid chunks are merged.
+            if (thinkingFlushTimer !== undefined)
+                clearTimeout(thinkingFlushTimer);
+            thinkingFlushTimer = setTimeout(flushThinkingEvent, 300);
+            return;
+        }
         if (event.type === "activity") {
             appendCodeAgentTranscriptEvent({
                 runId: existing.id,
@@ -129,15 +189,24 @@ export async function executeCodeAgentRun(options) {
             return;
         }
         if (event.type === "tool_start") {
+            const startMeta = pendingToolMeta.get(event.tool ?? "");
             appendCodeAgentTranscriptEvent({
                 runId: existing.id,
                 kind: "status",
                 message: `Running ${event.tool}.`,
-                metadata: { type: "tool_start", tool: event.tool, input: event.input },
+                metadata: {
+                    type: "tool_start",
+                    tool: event.tool,
+                    input: event.input,
+                    ...(startMeta ? { structuredMeta: startMeta } : {}),
+                },
             });
             return;
         }
         if (event.type === "tool_done") {
+            const pendingMeta = pendingToolMeta.get(event.tool ?? "");
+            if (pendingMeta)
+                pendingToolMeta.delete(event.tool ?? "");
             appendCodeAgentTranscriptEvent({
                 runId: existing.id,
                 kind: "status",
@@ -145,8 +214,9 @@ export async function executeCodeAgentRun(options) {
                 metadata: {
                     type: "tool_done",
                     tool: event.tool,
-                    result: truncateCodingOutput(event.result, 4000),
+                    result: truncateBashOutput(truncateCodingOutput(event.result, MAX_TOOL_OUTPUT_CHARS)),
                     ...(event.mcpApp ? { mcpApp: event.mcpApp } : {}),
+                    ...(pendingMeta ? { structuredMeta: pendingMeta } : {}),
                 },
             });
             return;
@@ -160,19 +230,31 @@ export async function executeCodeAgentRun(options) {
             });
         }
     };
+    let loopUsage = null;
     try {
-        await runWithOptionalCodeAgentRequestContext(existing, () => runAgentLoop({
+        const systemPrompt = await buildCodeAgentSystemPrompt(cwd, permissionMode);
+        const usageResult = await runWithOptionalCodeAgentRequestContext(existing, () => runAgentLoop({
             engine,
             model,
-            systemPrompt: codeAgentSystemPrompt(cwd, permissionMode),
+            systemPrompt,
             tools,
             actions,
             messages,
             send,
             signal: controller.signal,
-            maxIterations: 12,
+            maxIterations: DEFAULT_AGENT_MAX_ITERATIONS,
             reasoningEffort,
         }));
+        loopUsage = usageResult ?? null;
+        // Persist cumulative token totals from this turn into the run record so
+        // the UI can display per-run usage statistics.
+        if (loopUsage) {
+            updateCodeAgentRunRecord(existing.id, (record) => ({
+                metadata: {
+                    tokenUsage: accumulateTokenUsage(record.metadata?.tokenUsage, loopUsage),
+                },
+            }));
+        }
         await outputSmoother.flush();
         if (assistantText.trim()) {
             options.stdout?.write("\n");
@@ -296,6 +378,10 @@ export async function executeCodeAgentRun(options) {
         });
     }
     finally {
+        if (thinkingFlushTimer !== undefined) {
+            clearTimeout(thinkingFlushTimer);
+            flushThinkingEvent();
+        }
         outputSmoother.cancel();
         options.signal?.removeEventListener("abort", abortFromParent);
         await mcpManager?.stop().catch(() => undefined);
@@ -305,6 +391,24 @@ export async function executeCodeAgentRun(options) {
 export async function executeExistingCodeAgentRun(runId, options = {}) {
     return executeCodeAgentRun({ ...options, runId, appendUserEvent: false });
 }
+/**
+ * Add the pending approval command to the per-project allowlist, then approve
+ * and auto-resume.  Future occurrences of this exact command will bypass the
+ * approval gate without prompting.
+ */
+export async function executeApproveAlwaysCodeAgentApproval(runId, options = {}) {
+    const approval = getPendingApproval(runId);
+    if (approval?.command) {
+        addCodeAgentCommandToAllowlist(approval.command);
+        appendCodeAgentTranscriptEvent({
+            runId,
+            kind: "status",
+            message: `Command added to allowlist: ${approval.command}`,
+            metadata: { type: "allowlist-added", command: approval.command },
+        });
+    }
+    return executePendingCodeAgentApproval(runId, options);
+}
 export async function executePendingCodeAgentApproval(runId, options = {}) {
     const record = getCodeAgentRunRecord(runId);
     if (!record)
@@ -360,24 +464,19 @@ export async function executePendingCodeAgentApproval(runId, options = {}) {
         kind: "status",
         message: summary,
         metadata: {
-            status: result.code === 0 ? "paused" : "errored",
+            status: "running",
             phase: "approval-complete",
             approvalId: approval.id,
             exitCode: result.code,
             timedOut: result.timedOut,
         },
     });
-    return updateCodeAgentRunRecord(runId, {
-        status: result.code === 0 ? "paused" : "errored",
-        phase: result.code === 0 ? "approval-complete" : "approval-command-error",
+    // Clear the pending approval and immediately auto-resume so the model sees
+    // the command result and can continue — no manual "Resume" click needed.
+    updateCodeAgentRunRecord(runId, {
+        status: "running",
+        phase: "approval-resuming",
         needsApproval: false,
-        progress: {
-            label: result.code === 0 ? "Approval complete" : "Approval failed",
-            completed: result.code === 0 ? 1 : 0,
-            total: 1,
-            failed: result.code === 0 ? 0 : 1,
-            percent: result.code === 0 ? 100 : 0,
-        },
         metadata: {
             pendingApproval: undefined,
             lastApproval: {
@@ -387,6 +486,61 @@ export async function executePendingCodeAgentApproval(runId, options = {}) {
             },
         },
     });
+    appendCodeAgentTranscriptEvent({
+        runId,
+        kind: "status",
+        message: "Resuming run after approval.",
+        metadata: { status: "running", phase: "approval-resuming" },
+    });
+    return executeExistingCodeAgentRun(runId, { stdout: options.stdout });
+}
+/**
+ * Deny a pending approval: record the denial, feed it back to the model as a
+ * "command denied by user" result, and immediately resume the run so the model
+ * can adapt its plan without leaving the run dangling.
+ */
+export async function executeDenyCodeAgentApproval(runId, options = {}) {
+    const record = getCodeAgentRunRecord(runId);
+    if (!record)
+        return null;
+    const approval = getPendingApproval(runId);
+    if (!approval) {
+        options.stdout?.write("No pending approval was found for this run.\n");
+        return record;
+    }
+    const message = `User denied command: ${approval.command} (${approval.reason})`;
+    options.stdout?.write(`${message}\n`);
+    appendCodeAgentTranscriptEvent({
+        runId,
+        kind: "status",
+        message,
+        metadata: {
+            status: "running",
+            phase: "approval-denied",
+            approvalId: approval.id,
+            command: approval.command,
+        },
+    });
+    updateCodeAgentRunRecord(runId, {
+        status: "running",
+        phase: "approval-denied-resuming",
+        needsApproval: false,
+        metadata: {
+            pendingApproval: undefined,
+            lastApproval: {
+                ...approval,
+                deniedAt: new Date().toISOString(),
+                denied: true,
+            },
+        },
+    });
+    appendCodeAgentTranscriptEvent({
+        runId,
+        kind: "status",
+        message: "Resuming run after denial — model will adapt its plan.",
+        metadata: { status: "running", phase: "approval-denied-resuming" },
+    });
+    return executeExistingCodeAgentRun(runId, { stdout: options.stdout });
 }
 function latestUserPrompt(runId) {
     const events = listCodeAgentTranscriptEvents(runId);
@@ -537,35 +691,321 @@ function createFakeCodeAgentEngine(text) {
         },
     };
 }
-function buildCodeAgentMessages(run, prompt) {
-    const transcript = listCodeAgentTranscriptEvents(run.id)
-        .slice(-40)
-        .map((event) => {
-        const label = event.kind === "user"
-            ? "User"
-            : event.metadata?.role === "assistant"
-                ? "Assistant"
-                : event.kind;
-        return `${label}: ${event.message}`;
-    })
-        .join("\n");
-    const context = transcript
-        ? `\n\nPrevious session transcript:\n${transcript}`
+const SUPPORTED_IMAGE_MEDIA_TYPES = new Set([
+    "image/jpeg",
+    "image/jpg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+]);
+function buildCodeAgentMessages(run, prompt, attachments) {
+    const allEvents = listCodeAgentTranscriptEvents(run.id);
+    // Split events into an "older" prefix (summarised) and a "recent" tail
+    // (reconstructed as native structured messages).
+    const splitAt = Math.max(0, allEvents.length - STRUCTURED_HISTORY_RECENT_EVENTS);
+    const olderEvents = allEvents.slice(0, splitAt);
+    const recentEvents = allEvents.slice(splitAt);
+    // Build a compact text preamble from any events that pre-date the recent
+    // window.  Reuses the old flat-text approach so the model still has broad
+    // context without paying for full token cost on every old tool result.
+    let preamble = "";
+    if (olderEvents.length > 0) {
+        const summaryLines = olderEvents
+            .filter((e) => e.kind === "user" ||
+            (e.kind === "system" && e.metadata?.role === "assistant") ||
+            (e.kind === "status" &&
+                (e.metadata?.type === "tool_done" ||
+                    e.metadata?.role === "assistant")))
+            .map((e) => {
+            if (e.kind === "user")
+                return `User: ${e.message}`;
+            if (e.metadata?.role === "assistant")
+                return `Assistant: ${e.message}`;
+            if (e.metadata?.type === "tool_done") {
+                const tool = e.metadata?.tool;
+                const result = e.metadata?.result;
+                const resultText = typeof result === "string"
+                    ? truncateCodingOutput(result, 500)
+                    : result != null
+                        ? truncateCodingOutput(String(result), 500)
+                        : "";
+                return tool ? `Tool[${tool}]: ${resultText}` : `Tool: ${resultText}`;
+            }
+            return null;
+        })
+            .filter((line) => line !== null);
+        if (summaryLines.length > 0) {
+            preamble = `Earlier conversation summary:\n${summaryLines.join("\n")}`;
+        }
+    }
+    // Reconstruct the recent events as native EngineMessage objects.
+    // We build up a sequence of user/assistant messages, pairing tool-call
+    // events (from tool_start metadata) with their matching tool-result events
+    // (from tool_done metadata), and accumulating assistant text from system
+    // events with role=assistant.
+    const structuredMessages = buildStructuredMessagesFromEvents(recentEvents);
+    // Separate image attachments from text attachments. Images are passed as
+    // proper EngineImagePart entries rather than inlined base64 text (which
+    // would consume ~700K tokens per megabyte of image data).
+    const imageParts = [];
+    const unsupportedImageNotes = [];
+    for (const att of attachments ?? []) {
+        if (!att.dataUrl)
+            continue;
+        const match = att.dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+        if (!match)
+            continue;
+        const mime = match[1].toLowerCase();
+        if (SUPPORTED_IMAGE_MEDIA_TYPES.has(mime)) {
+            imageParts.push({
+                type: "image",
+                data: match[2],
+                mediaType: mime,
+            });
+        }
+        else {
+            // Unsupported format — inject a note so the model understands what happened.
+            const label = att.name ? `"${att.name}"` : "An image";
+            unsupportedImageNotes.push(`[${label} could not be processed — unsupported image format (${mime}). ` +
+                `Only JPEG, PNG, GIF, and WebP are supported.]`);
+        }
+    }
+    const notesBlock = unsupportedImageNotes.length > 0
+        ? `\n\n${unsupportedImageNotes.join("\n")}`
         : "";
-    return [
-        {
-            role: "user",
-            content: [
-                {
+    // The current prompt (plus optional preamble) becomes the final user message.
+    const promptText = [preamble, prompt, notesBlock]
+        .filter(Boolean)
+        .join("\n\n");
+    const promptContent = [...imageParts, { type: "text", text: promptText }];
+    // If there are structured messages from the recent window and the last one
+    // is a user message that already contains the current prompt (happens when
+    // appendUserEvent added a "user" event that got included), de-duplicate by
+    // using the structured messages as-is but replacing the last user message's
+    // content with the enriched content (images + prompt).
+    if (structuredMessages.length > 0) {
+        const lastMsg = structuredMessages[structuredMessages.length - 1];
+        if (lastMsg.role === "user") {
+            // Replace last user message content with the enriched prompt content.
+            structuredMessages[structuredMessages.length - 1] = {
+                role: "user",
+                content: promptContent,
+            };
+            return structuredMessages;
+        }
+        // Last message is assistant — append a new user message.
+        return [...structuredMessages, { role: "user", content: promptContent }];
+    }
+    return [{ role: "user", content: promptContent }];
+}
+/**
+ * Reconstruct a sequence of EngineMessage objects from transcript events,
+ * preserving the native tool-call / tool-result pair structure that models
+ * expect when replaying multi-turn conversations.
+ *
+ * Event mapping:
+ *   kind=user                          → user message with text content
+ *   kind=system, role=assistant        → assistant message with text content
+ *   kind=status, type=tool_start       → assistant message with a tool-call part
+ *                                        (grouped with any preceding assistant text)
+ *   kind=status, type=tool_done        → user message with a tool-result part
+ *   kind=status, type=thinking         → excluded (ephemeral reasoning)
+ *   everything else                    → excluded from model history
+ *
+ * Each tool_start generates a synthetic toolCallId derived from the event id so
+ * that the matching tool_done can reference it.  Old events that lack tool/input
+ * metadata fall back gracefully to text content.
+ */
+/** @internal exported for unit tests */
+export function buildStructuredMessagesFromEvents(events) {
+    const pending = [];
+    // Track in-flight tool-call IDs keyed by event id so tool_done can
+    // reference the corresponding call.
+    const toolCallIdByEventOrder = new Map();
+    for (const event of events) {
+        // Exclude thinking — ephemeral reasoning, never replayed to model.
+        if (event.kind === "status" && event.metadata?.type === "thinking") {
+            continue;
+        }
+        if (event.kind === "user") {
+            const text = event.message.trim();
+            if (!text)
+                continue;
+            appendOrMerge(pending, "user", { type: "text", text });
+            continue;
+        }
+        // Assistant text (persisted after a turn completes).
+        if (event.kind === "system" && event.metadata?.role === "assistant") {
+            const text = event.message.trim();
+            if (!text)
+                continue;
+            appendOrMerge(pending, "assistant", { type: "text", text });
+            continue;
+        }
+        // Tool call start — emit an assistant tool-call part.
+        if (event.kind === "status" && event.metadata?.type === "tool_start") {
+            const tool = typeof event.metadata?.tool === "string" && event.metadata.tool
+                ? event.metadata.tool
+                : null;
+            if (!tool)
+                continue;
+            // Generate a stable ID from the event id so tool_done can reference it.
+            const toolCallId = `tc-${event.id}`;
+            toolCallIdByEventOrder.set(event.id, toolCallId);
+            const input = event.metadata?.input != null ? event.metadata.input : {};
+            appendOrMerge(pending, "assistant", {
+                type: "tool-call",
+                id: toolCallId,
+                name: tool,
+                input,
+            });
+            continue;
+        }
+        // Tool result — emit a user tool-result part paired with the last
+        // unmatched tool_start for the same tool name.
+        if (event.kind === "status" && event.metadata?.type === "tool_done") {
+            const tool = typeof event.metadata?.tool === "string" && event.metadata.tool
+                ? event.metadata.tool
+                : null;
+            if (!tool)
+                continue;
+            // Find the most recent tool_start event id for this tool.
+            const matchedCallId = findMatchingToolCallId(toolCallIdByEventOrder, events, event, tool);
+            const rawResult = event.metadata?.result;
+            const resultText = truncateCodingOutput(typeof rawResult === "string"
+                ? rawResult
+                : rawResult != null
+                    ? String(rawResult)
+                    : "(no output)", STRUCTURED_HISTORY_RESULT_CAP);
+            if (matchedCallId) {
+                const toolInput = event.metadata?.input != null
+                    ? safeJsonStringify(event.metadata.input)
+                    : "{}";
+                appendOrMerge(pending, "user", {
+                    type: "tool-result",
+                    toolCallId: matchedCallId,
+                    toolName: tool,
+                    toolInput,
+                    content: resultText,
+                });
+            }
+            else {
+                // Orphaned tool result (no matching call in the recent window) — fall
+                // back to plain text so the model still sees the output.
+                appendOrMerge(pending, "user", {
                     type: "text",
-                    text: `${prompt}${context}`,
-                },
-            ],
-        },
-    ];
+                    text: `[Tool result for ${tool}]: ${resultText}`,
+                });
+            }
+            continue;
+        }
+    }
+    return pending;
+}
+/**
+ * Append a content part to the last message if it has the same role, or
+ * start a new message otherwise.
+ */
+function appendOrMerge(pending, role, part) {
+    const last = pending[pending.length - 1];
+    if (last && last.role === role) {
+        last.content.push(part);
+    }
+    else {
+        pending.push({ role, content: [part] });
+    }
+}
+/**
+ * Find the toolCallId generated for the most recent tool_start event that
+ * matches the given tool name and precedes the current tool_done event.
+ * Returns null if no match exists in the recent window.
+ */
+function findMatchingToolCallId(toolCallIdByEventOrder, events, doneEvent, toolName) {
+    // Walk backwards from doneEvent's position to find the nearest unmatched start.
+    const doneIndex = events.indexOf(doneEvent);
+    for (let i = doneIndex - 1; i >= 0; i--) {
+        const e = events[i];
+        if (e.kind === "status" &&
+            e.metadata?.type === "tool_start" &&
+            e.metadata?.tool === toolName) {
+            const id = toolCallIdByEventOrder.get(e.id);
+            if (id) {
+                // Consume it so a second done for the same tool gets the next start.
+                toolCallIdByEventOrder.delete(e.id);
+                return id;
+            }
+        }
+    }
+    return null;
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value) ?? "{}";
+    }
+    catch {
+        return "{}";
+    }
+}
+/**
+ * Maximum character length for inlined AGENTS.md content in the system prompt.
+ * Content beyond this cap is truncated with a note so the model knows more exists.
+ */
+const AGENTS_MD_INLINE_CAP = 16_000;
+/**
+ * Build the coding agent system prompt, inlining AGENTS.md (or CLAUDE.md as
+ * fallback) and a skills index from .agents/skills/ into the prompt so the
+ * coding agent has the same repo-context awareness that Claude Code / Codex
+ * provide when running locally.
+ *
+ * The bundle is read synchronously from the filesystem via `readAgentsBundleFromFs`
+ * (same function used by the Vite build-time plugin) so there is no async I/O
+ * on the hot path — the call is cheap and the result is used once per run leg.
+ */
+/** @internal exported for unit tests */
+export async function buildCodeAgentSystemPrompt(cwd, permissionMode) {
+    const bundle = readAgentsBundleFromFs(cwd);
+    // If the bundle has no AGENTS.md, try CLAUDE.md as a fallback — many repos
+    // use that name for agent instructions (e.g. Claude Code projects).
+    let agentsMdContent = bundle.agentsMd;
+    if (!agentsMdContent.trim()) {
+        try {
+            const fs = await import("node:fs");
+            const path = await import("node:path");
+            const claudeMdPath = path.join(cwd, "CLAUDE.md");
+            if (fs.existsSync(claudeMdPath)) {
+                agentsMdContent = fs.readFileSync(claudeMdPath, "utf-8");
+            }
+        }
+        catch {
+            // Not readable — skip
+        }
+    }
+    const repoInstructionsBlock = buildRepoInstructionsBlock(agentsMdContent);
+    const skillsBlock = generateSkillsPromptBlock(bundle);
+    return codeAgentSystemPrompt(cwd, permissionMode, repoInstructionsBlock, skillsBlock);
 }
-function codeAgentSystemPrompt(cwd, permissionMode) {
+/** @internal exported for unit tests */
+export function buildRepoInstructionsBlock(agentsMdContent) {
+    if (!agentsMdContent.trim())
+        return "";
+    const needsTruncation = agentsMdContent.length > AGENTS_MD_INLINE_CAP;
+    const truncated = needsTruncation
+        ? agentsMdContent.slice(0, AGENTS_MD_INLINE_CAP)
+        : agentsMdContent;
+    const truncationNote = needsTruncation
+        ? `\n\n[Note: AGENTS.md was truncated to ${AGENTS_MD_INLINE_CAP} characters. Read the full file for complete instructions.]`
+        : "";
+    return `## Repository instructions
+
+${truncated}${truncationNote}`;
+}
+/** @internal exported for unit tests */
+export function codeAgentSystemPrompt(cwd, permissionMode, repoInstructionsBlock = "", skillsBlock = "") {
     const mode = permissionMode === "read-only" ? "Plan" : "Auto";
+    const repoSection = repoInstructionsBlock
+        ? `\n\n${repoInstructionsBlock}`
+        : "";
+    const skillsSection = skillsBlock ? `\n\n${skillsBlock}` : "";
     return `You are Agent-Native Code, a coding agent running in ${cwd}. You and the user share one workspace, and your job is to collaborate with them until their goal is genuinely handled.
 
 # General
@@ -619,9 +1059,9 @@ Current run mode: ${mode} mode (${permissionMode}).
 - Reference files as clickable paths (e.g. \`packages/core/src/foo.ts\`), with a line number when it helps. Do not paste large file contents back — the user shares this machine and can open them.
 - State what you changed, and show evidence you verified it: name the check you ran (e.g. \`pnpm typecheck\`) and its key result, not just a claim that it passed. If you could not run something, say so plainly.
 - No emojis or em dashes unless the user used them first.
-- Respect any AGENTS.md instructions in the repository; they override these defaults on conflict.`;
+- AGENTS.md files take precedence over these defaults on conflict. More deeply nested AGENTS.md files take precedence over shallower ones — check for them in directories you work in.${repoSection}${skillsSection}`;
 }
-function createLocalCodeAgentActions(cwd, permissionMode, runId) {
+function createLocalCodeAgentActions(cwd, permissionMode, runId, onToolMetadata, onBashOutputChunk) {
     const actions = createCodingToolRegistry({
         cwd,
         restrictToCwd: true,
@@ -629,6 +1069,8 @@ function createLocalCodeAgentActions(cwd, permissionMode, runId) {
         maxOutputChars: MAX_TOOL_OUTPUT_CHARS,
         maxFileReadChars: MAX_FILE_READ_CHARS,
         canWrite: (toolName) => permissionErrorForWrite(permissionMode, toolName),
+        onToolMetadata,
+        onBashOutputChunk,
         beforeBash: ({ command }) => {
             const permission = classifyCodeAgentCommandPermission(command);
             if (permission.kind === "forbidden") {
@@ -640,6 +1082,9 @@ function createLocalCodeAgentActions(cwd, permissionMode, runId) {
                     return permissionError;
             }
             if (permission.kind === "approval-required") {
+                // Skip the approval gate when the user has allowlisted this command.
+                if (isCodeAgentCommandAllowed(command))
+                    return null;
                 const approval = requestCodeAgentApproval(runId, {
                     tool: "bash",
                     command,
@@ -791,4 +1236,15 @@ function getPendingApproval(runId) {
             : "full-auto",
     };
 }
+function accumulateTokenUsage(existing, next) {
+    const prev = existing && typeof existing === "object" && !Array.isArray(existing)
+        ? existing
+        : {};
+    return {
+        inputTokens: (prev.inputTokens ?? 0) + next.inputTokens,
+        outputTokens: (prev.outputTokens ?? 0) + next.outputTokens,
+        cacheReadTokens: (prev.cacheReadTokens ?? 0) + next.cacheReadTokens,
+        cacheWriteTokens: (prev.cacheWriteTokens ?? 0) + next.cacheWriteTokens,
+    };
+}
 //# sourceMappingURL=code-agent-executor.js.map