@praxis-ai/praxis 0.1.0 → 0.1.2

package/dist/applicationLayer/applicationRuntime.js

@@ -6,19 +6,48 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { praxis, } from "../agentCore/index.js";
-import { invokeChatGPTCodexResponses } from "../agentCore/agent_modelAdapter/actualInvocationLayer/openai/chatgpt_codex_responses.js";
-import { resolveProviderModelMetadata } from "../agentCore/agent_modelAdapter/providerAccessLayer/modelMetadataRegistry.js";
+import { createMcpApplicationStateView, toMcpRuntimeServerProfile, } from "../runtimeImplementation/runtime.mcpPlane/index.js";
+import { invokeOpenAIV1Responses, } from "../modelAdapter/actualInvocationLayer/openai/v1_responses.js";
+import { invokeChatGPTCodexResponses } from "../modelAdapter/actualInvocationLayer/openai/chatgpt_codex_responses.js";
+import { createInMemoryMultiagentRuntime, } from "../runtimeImplementation/runtime.multiagentPlane/index.js";
+import { resolveProviderModelMetadata } from "../modelAdapter/providerAccessLayer/modelMetadataRegistry.js";
 import { loadApplicationProject, } from "./applicationProject.js";
-const APPLICATION_SESSION_HISTORY_MAX_MESSAGES = 24;
 const APPLICATION_SESSION_HISTORY_KEEP_RECENT_MESSAGES = 12;
-const APPLICATION_SESSION_HISTORY_MAX_CHARS = 24_000;
-const APPLICATION_SESSION_HISTORY_MAX_MESSAGE_CHARS = 4_000;
+const APPLICATION_SESSION_HISTORY_MAX_MESSAGE_CHARS = 20_000;
 const APPLICATION_SESSION_SUMMARY_MAX_CHARS = 6_000;
 const APPLICATION_SESSION_PRE_TURN_KEEP_RECENT_MESSAGES = 6;
-const APPLICATION_SESSION_AUTO_COMPACT_THRESHOLD = 0.9;
+const APPLICATION_SESSION_AUTO_COMPACT_THRESHOLD = 0.95;
 function defaultNow() {
     return new Date().toISOString();
 }
+function initialConversationHistoryMap(conversations) {
+    const map = new Map();
+    for (const conversation of conversations ?? []) {
+        const sessionId = conversation.sessionId.trim();
+        if (sessionId.length === 0)
+            continue;
+        map.set(sessionId, conversation.messages.map((message) => ({
+            ...message,
+            text: truncateMiddle(message.text, APPLICATION_SESSION_HISTORY_MAX_MESSAGE_CHARS),
+        })));
+    }
+    return map;
+}
+function initialConversationSummaryMap(conversations) {
+    const map = new Map();
+    for (const conversation of conversations ?? []) {
+        const sessionId = conversation.sessionId.trim();
+        if (sessionId.length === 0 || conversation.summary === undefined)
+            continue;
+        map.set(sessionId, {
+            text: truncateMiddle(conversation.summary.text, APPLICATION_SESSION_SUMMARY_MAX_CHARS),
+            compactedMessages: Math.max(0, Math.floor(conversation.summary.compactedMessages)),
+            updatedAt: conversation.summary.updatedAt,
+            source: "application.history.autoCompact.v1",
+        });
+    }
+    return map;
+}
 function event(input) {
     return { ...input, publicSafe: true };
 }
@@ -58,18 +87,24 @@ function summarizeManifest(manifest) {
         storageKind: manifest.storage.kind ?? "unknown",
     };
 }
-function summarizeToolCatalog(manifest) {
-    const entries = praxis.inspection.createBaseToolRealityLedger();
+function summarizeToolCatalog(manifest, toolProfile) {
+    const profile = praxis.baseTool.profiles().find((entry) => entry.name === toolProfile)
+        ?? praxis.baseTool.profiles().find((entry) => entry.name === "agentCore");
+    const entries = praxis.baseTool.basetool.all({ profileName: profile.name });
     const byFamily = {};
     const byRiskLevel = {};
     const byReadiness = {};
     for (const entry of entries) {
         byFamily[entry.storageFamily] = (byFamily[entry.storageFamily] ?? 0) + 1;
         byRiskLevel[entry.riskLevel] = (byRiskLevel[entry.riskLevel] ?? 0) + 1;
-        byReadiness[entry.developerReadiness] = (byReadiness[entry.developerReadiness] ?? 0) + 1;
+        byReadiness.semanticCatalog = (byReadiness.semanticCatalog ?? 0) + 1;
     }
     const mountedToolIds = manifest?.harness.tools.map((tool) => tool.toolId).sort() ?? [];
     return {
+        profile: profile.name,
+        availableProfiles: praxis.baseTool.profiles().map((entry) => entry.name),
+        defaultPolicyProfile: profile.defaultPolicyProfile,
+        extensionSlots: profile.extensionSlots ?? [],
         total: entries.length,
         mounted: mountedToolIds.length,
         byFamily,
@@ -190,7 +225,7 @@ function flattenedToolArguments(argumentsRecord) {
     return target === undefined ? argumentsRecord : { ...argumentsRecord, ...target };
 }
 function formatPathList(paths, maxItems = 4) {
-    const cleanPaths = paths.map((item) => item.trim()).filter((item) => item.length > 0);
+    const cleanPaths = [...new Set(paths.map((item) => item.trim()).filter((item) => item.length > 0))];
     if (cleanPaths.length === 0)
         return "file";
     const shown = cleanPaths.slice(0, maxItems).join(", ");
@@ -264,6 +299,63 @@ function codeModifyDiffPreviewLines(input) {
         "... diff preview trimmed",
     ];
 }
+function patchApplyDiffPreviewLines(input) {
+    const patchBytes = Buffer.byteLength(input.patch);
+    if (patchBytes > CODE_MODIFY_DIFF_PREVIEW_MAX_BYTES) {
+        return [];
+    }
+    const lines = input.patch.replace(/\r\n/gu, "\n").replace(/\r/gu, "\n").split("\n");
+    const preview = [];
+    let currentPath = "patch";
+    const pushHeader = (path) => {
+        currentPath = path.trim() || currentPath;
+        const header = `@@ ${currentPath} @@`;
+        if (preview[preview.length - 1] !== header)
+            preview.push(header);
+    };
+    const pushDiff = (marker, content) => {
+        preview.push(`${marker}${"?".padStart(4, " ")} | ${content.length > 0 ? content : " "}`);
+    };
+    for (const line of lines) {
+        if (line === "*** End Patch")
+            break;
+        const pathMatch = line.match(/^\*\*\* (?:Add|Create|Create New|Update|Delete) File: (.+)$/u)
+            ?? line.match(/^\*\*\* File: (.+)$/u);
+        if (pathMatch !== null) {
+            pushHeader(pathMatch[1] ?? currentPath);
+            continue;
+        }
+        if (line.startsWith("+++ ")) {
+            const path = line.slice("+++ ".length).replace(/^b\//u, "");
+            if (path !== "/dev/null")
+                pushHeader(path);
+            continue;
+        }
+        if (line.startsWith("--- ")) {
+            const path = line.slice("--- ".length).replace(/^a\//u, "");
+            if (path !== "/dev/null")
+                pushHeader(path);
+            continue;
+        }
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            pushDiff("+", line.slice(1));
+            continue;
+        }
+        if (line.startsWith("-") && !line.startsWith("---")) {
+            pushDiff("-", line.slice(1));
+        }
+    }
+    if (!preview.some((line) => line.startsWith("+") || line.startsWith("-"))) {
+        return [];
+    }
+    if (preview.length <= CODE_MODIFY_DIFF_PREVIEW_MAX_LINES) {
+        return preview;
+    }
+    return [
+        ...preview.slice(0, CODE_MODIFY_DIFF_PREVIEW_MAX_LINES - 1),
+        "... diff preview trimmed",
+    ];
+}
 function textLineCount(value) {
     if (value === undefined)
         return undefined;
@@ -280,34 +372,22 @@ function rangeDeletedLineCount(value) {
     }
     return Math.floor(endLine - startLine + 1);
 }
-function codeChangeLineStats(toolCall) {
-    if (!toolCall.toolId.startsWith("code."))
-        return undefined;
+function fileChangeLineStats(toolCall) {
     const args = flattenedToolArguments(toolCall.arguments);
     const output = objectValue(toolCall.output);
     switch (toolCall.toolId) {
-        case "code.modify": {
-            const replacements = numberValue(output?.replacements);
-            const multiplier = replacements !== undefined && replacements > 0 ? Math.floor(replacements) : 1;
-            const replacementLines = textLineCount(rawStringValue(args.replacementText));
-            const searchLines = textLineCount(rawStringValue(args.searchText));
+        case "patch.apply": {
+            const additions = numberValue(output?.additions)
+                ?? numberValue(output?.addedLines)
+                ?? numberValue(output?.linesAdded);
+            const deletions = numberValue(output?.deletions)
+                ?? numberValue(output?.deletedLines)
+                ?? numberValue(output?.linesDeleted);
             return cleanRecord({
-                codeAdditions: replacementLines === undefined ? undefined : replacementLines * multiplier,
-                codeDeletions: searchLines === undefined ? undefined : searchLines * multiplier,
+                codeAdditions: additions,
+                codeDeletions: deletions,
             });
         }
-        case "code.overwrite":
-            return cleanRecord({
-                codeAdditions: textLineCount(rawStringValue(args.content)),
-            });
-        case "code.replaceFile":
-            return cleanRecord({
-                codeAdditions: textLineCount(rawStringValue(args.newContent)),
-            });
-        case "code.delete":
-            return cleanRecord({
-                codeDeletions: numberValue(output?.deletedLines) ?? rangeDeletedLineCount(args.range),
-            });
         default:
             return undefined;
     }
@@ -319,7 +399,8 @@ function summarizeCompactedMessages(messages) {
     return messages
         .map((message) => {
         const status = message.status ? `, ${message.status}` : "";
-        return `- ${message.role} (${message.turnId}${status}): ${truncateMiddle(message.text, 700)}`;
+        const causedBy = message.causedBy ? `, causedBy=${message.causedBy}` : "";
+        return `- ${message.role} (${message.turnId}${status}${causedBy}): ${truncateMiddle(message.text, 700)}`;
     })
         .join("\n");
 }
@@ -334,10 +415,7 @@ function compactConversationHistory(input) {
         ...message,
         text: truncateMiddle(message.text, APPLICATION_SESSION_HISTORY_MAX_MESSAGE_CHARS),
     }));
-    const totalChars = normalizedMessages.reduce((sum, message) => sum + message.text.length + message.role.length + message.turnId.length + 32, 0);
-    const overMessageBudget = normalizedMessages.length > APPLICATION_SESSION_HISTORY_MAX_MESSAGES;
-    const overCharBudget = totalChars > APPLICATION_SESSION_HISTORY_MAX_CHARS;
-    if (!input.force && !overMessageBudget && !overCharBudget) {
+    if (!input.force) {
         return { messages: normalizedMessages, summary: input.previousSummary, compacted: false };
     }
     const keepCount = Math.min(input.keepRecentMessages ?? APPLICATION_SESSION_HISTORY_KEEP_RECENT_MESSAGES, normalizedMessages.length);
@@ -369,6 +447,16 @@ function modelAutoCompactTokenLimit(model) {
         return undefined;
     return Math.max(1, Math.floor(baseLimit * APPLICATION_SESSION_AUTO_COMPACT_THRESHOLD));
 }
+function applicationCompressionLimitTokens(input) {
+    const compactWindow = input.compactContextWindowTokens;
+    if (typeof compactWindow === "number" && Number.isFinite(compactWindow) && compactWindow > 0) {
+        const ratio = typeof input.compactThresholdRatio === "number" && Number.isFinite(input.compactThresholdRatio)
+            ? Math.min(1, Math.max(0.01, input.compactThresholdRatio))
+            : APPLICATION_SESSION_AUTO_COMPACT_THRESHOLD;
+        return Math.max(1, Math.floor(compactWindow * ratio));
+    }
+    return modelAutoCompactTokenLimit(input.model);
+}
 function estimateTaskTextTokens(input) {
     return estimateContextTokens(buildTaskTextWithSessionHistory(input));
 }
@@ -420,18 +508,10 @@ function prepareHistoryForTurn(input) {
     };
 }
 function trimConversationHistory(messages) {
-    const recent = messages.slice(-APPLICATION_SESSION_HISTORY_MAX_MESSAGES);
-    const kept = [];
-    let totalChars = 0;
-    for (const message of [...recent].reverse()) {
-        const text = truncateMiddle(message.text, APPLICATION_SESSION_HISTORY_MAX_MESSAGE_CHARS);
-        const nextLength = text.length + message.role.length + message.turnId.length + 32;
-        if (kept.length > 0 && totalChars + nextLength > APPLICATION_SESSION_HISTORY_MAX_CHARS)
-            break;
-        kept.push({ ...message, text });
-        totalChars += nextLength;
-    }
-    return kept.reverse();
+    return messages.map((message) => ({
+        ...message,
+        text: truncateMiddle(message.text, APPLICATION_SESSION_HISTORY_MAX_MESSAGE_CHARS),
+    }));
 }
 function formatConversationHistory(messages, summary) {
     const trimmed = trimConversationHistory(messages);
@@ -449,7 +529,7 @@ function formatConversationHistory(messages, summary) {
             ].join("\n"),
         trimmed.length === 0 ? undefined : "",
         ...trimmed.map((message, index) => [
-            `[${index + 1}] ${message.role} (${message.turnId}${message.status ? `, ${message.status}` : ""}):`,
+            `[${index + 1}] ${message.role} (${message.turnId}${message.status ? `, ${message.status}` : ""}${message.causedBy ? `, causedBy=${message.causedBy}` : ""}):`,
             message.text,
         ].join("\n")),
     ].filter((section) => section !== undefined).join("\n\n");
@@ -465,16 +545,21 @@ function estimateConversationContext(input) {
     const lastRequestTotalTokens = input.usage?.lastTotalTokens ?? (input.usage === undefined
         ? undefined
         : usageContextTotalTokens(input.usage));
+    const promptPackTokens = input.usage?.lastPromptPackTokens;
     const hasProviderUsage = typeof lastRequestInputTokens === "number" && Number.isFinite(lastRequestInputTokens);
     const activeTokens = hasProviderUsage ? lastRequestInputTokens : historyEstimatedTokens;
+    const sessionContextTokens = Math.max(historyEstimatedTokens, hasProviderUsage ? lastRequestInputTokens : 0, typeof promptPackTokens === "number" && Number.isFinite(promptPackTokens) ? promptPackTokens : 0);
     return {
         activeTokens,
         promptTokens: activeTokens,
+        sessionContextTokens,
+        compressionLimitTokens: input.compressionLimitTokens ?? modelAutoCompactTokenLimit(input.model),
         transcriptTokens,
         summaryTokens,
         historyMessages: input.messages.length,
         lastRequestInputTokens: hasProviderUsage ? lastRequestInputTokens : undefined,
         lastRequestTotalTokens,
+        promptPackTokens,
         historyEstimatedTokens,
         contextSource: hasProviderUsage ? "provider.model-call.usage" : "application.history.estimate",
         usageSource: input.usage?.source,
@@ -501,8 +586,8 @@ function formatApplicationInputAttachments(attachments) {
         return undefined;
     const lines = [
         "Application input attachments for this user request.",
-        "If an image attachment has localPath, inspect it through omni.viewImage before answering image-specific questions.",
-        "If a file attachment has localPath, use the appropriate code/search/file baseTool before claiming its contents.",
+        "If an image attachment has localPath, inspect it through media.viewImage before answering image-specific questions.",
+        "If a file attachment has localPath, use the appropriate file/search baseTool before claiming its contents.",
         "",
         ...attachments.map(formatAttachmentForPrompt),
     ];
@@ -519,8 +604,177 @@ function buildTaskTextWithSessionHistory(input) {
     ].filter((section) => section !== undefined && section.trim().length > 0);
     return sections.join("\n\n---\n\n");
 }
-function summarizeCodeToolInput(toolCall) {
-    if (!toolCall.toolId.startsWith("code."))
+function buildCurrentTaskText(input) {
+    const attachmentText = formatApplicationInputAttachments(input.attachments);
+    return [
+        attachmentText,
+        "Current user request:",
+        input.currentUserText,
+    ].filter((section) => section !== undefined && section.trim().length > 0).join("\n\n---\n\n");
+}
+function applicationMessageToPromptContextMessage(message, index) {
+    return {
+        messageId: message.messageId ?? `${message.turnId}:${message.role}:${index + 1}`,
+        role: message.role,
+        text: message.text,
+        createdAt: message.createdAt,
+        artifactRefs: message.artifactRefs,
+        metadata: {
+            source: "application.conversationHistory",
+            turnId: message.turnId,
+            causedBy: message.causedBy,
+            status: message.status ?? "completed",
+            ...(message.metadata ?? {}),
+        },
+    };
+}
+function applicationHistoryToConversationWindow(messages) {
+    return trimConversationHistory(messages).map(applicationMessageToPromptContextMessage);
+}
+function applicationSummaryToPromptContextSummary(sessionId, summary) {
+    if (summary === undefined)
+        return undefined;
+    return {
+        summaryId: `${sessionId}:applicationHistorySummary`,
+        text: summary.text,
+        updatedAt: summary.updatedAt,
+        metadata: {
+            source: summary.source,
+            compactedMessages: summary.compactedMessages,
+        },
+    };
+}
+function stringFromMetadata(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function stringArrayFromMetadata(metadata, key) {
+    const value = metadata?.[key];
+    if (!Array.isArray(value))
+        return undefined;
+    const strings = value.filter((item) => typeof item === "string" && item.trim().length > 0);
+    return strings.length > 0 ? strings : undefined;
+}
+function artifactRefsFromToolMetadata(metadata) {
+    const refs = new Set(stringArrayFromMetadata(metadata, "artifactRefs") ?? []);
+    const resultMetadata = objectValue(metadata?.resultMetadata);
+    for (const key of [
+        "artifactRef",
+        "artifactId",
+        "stdoutArtifactRef",
+        "stderrArtifactRef",
+        "registryArtifactRef",
+        "diffArtifactRef",
+        "imagePath",
+    ]) {
+        const value = stringValue(resultMetadata?.[key]);
+        if (value !== undefined)
+            refs.add(value);
+    }
+    const artifact = objectValue(resultMetadata?.artifact);
+    const nestedArtifactId = stringValue(artifact?.artifactId) ?? stringValue(artifact?.id) ?? stringValue(artifact?.ref);
+    if (nestedArtifactId !== undefined)
+        refs.add(nestedArtifactId);
+    return refs.size > 0 ? [...refs] : undefined;
+}
+function compactEventPreview(value, maxLength = 1_500) {
+    if (value === undefined || value.trim().length === 0)
+        return undefined;
+    return truncateMiddle(value.trim(), maxLength);
+}
+function applicationLedgerMessagesFromEvents(input) {
+    const messages = [];
+    for (const item of input.events) {
+        if (item.turnId !== input.turnId)
+            continue;
+        if (item.kind === "model") {
+            const phase = stringFromMetadata(item.metadata, "modelPhase");
+            if (phase !== "completed" && phase !== "failed")
+                continue;
+            const invocationId = stringFromMetadata(item.metadata, "invocationId") ?? item.eventId;
+            const usagePreview = item.metadata?.usage === undefined ? undefined : compactEventPreview(previewUnknown(item.metadata.usage, 800));
+            messages.push({
+                role: "model",
+                text: [
+                    `Model call ${phase}: ${stringFromMetadata(item.metadata, "model") ?? stringFromMetadata(item.metadata, "carrierId") ?? "unknown model"}.`,
+                    usagePreview === undefined ? undefined : `usage: ${usagePreview}`,
+                    stringFromMetadata(item.metadata, "providerResponseId") === undefined ? undefined : `providerResponseId: ${stringFromMetadata(item.metadata, "providerResponseId")}`,
+                    stringFromMetadata(item.metadata, "previousProviderResponseId") === undefined ? undefined : `previousProviderResponseId: ${stringFromMetadata(item.metadata, "previousProviderResponseId")}`,
+                ].filter((line) => line !== undefined).join("\n"),
+                turnId: input.turnId,
+                createdAt: item.createdAt,
+                messageId: item.eventId,
+                causedBy: `${input.turnId}.submitted`,
+                metadata: {
+                    source: "application.ledger.model",
+                    eventId: item.eventId,
+                    invocationId,
+                    phase,
+                },
+                status: phase === "failed" ? "failed" : "completed",
+            });
+            continue;
+        }
+        if (item.kind === "tool") {
+            const toolStatus = stringFromMetadata(item.metadata, "toolStatus");
+            if (toolStatus !== "completed" && toolStatus !== "failed")
+                continue;
+            const toolCallId = stringFromMetadata(item.metadata, "toolCallId") ?? item.eventId;
+            const toolId = stringFromMetadata(item.metadata, "toolId") ?? item.message;
+            const inputSummary = compactEventPreview(stringFromMetadata(item.metadata, "inputSummary"), 1_000);
+            const argumentsPreview = compactEventPreview(stringFromMetadata(item.metadata, "argumentsPreview"), 2_000);
+            const outputPreview = compactEventPreview(stringFromMetadata(item.metadata, "outputPreview"), 4_000);
+            const errorPreview = compactEventPreview(stringFromMetadata(item.metadata, "errorPreview"), 2_000);
+            const humanResultSummary = item.metadata?.humanResultSummary === undefined
+                ? undefined
+                : compactEventPreview(previewUnknown(item.metadata.humanResultSummary, 2_000));
+            messages.push({
+                role: "tool",
+                text: [
+                    `Tool call ${toolStatus}: ${toolId}.`,
+                    inputSummary === undefined ? undefined : `intent: ${inputSummary}`,
+                    argumentsPreview === undefined ? undefined : `arguments: ${argumentsPreview}`,
+                    outputPreview === undefined ? undefined : `output: ${outputPreview}`,
+                    errorPreview === undefined ? undefined : `error: ${errorPreview}`,
+                    humanResultSummary === undefined ? undefined : `resultSummary: ${humanResultSummary}`,
+                ].filter((line) => line !== undefined).join("\n"),
+                turnId: input.turnId,
+                createdAt: item.createdAt,
+                messageId: item.eventId,
+                causedBy: `${input.turnId}.model`,
+                artifactRefs: artifactRefsFromToolMetadata(item.metadata),
+                metadata: {
+                    source: "application.ledger.tool",
+                    eventId: item.eventId,
+                    toolCallId,
+                    toolId,
+                    toolStatus,
+                    familyKey: stringFromMetadata(item.metadata, "familyKey"),
+                },
+                status: toolStatus === "failed" ? "failed" : "completed",
+            });
+            continue;
+        }
+        if (item.kind === "error") {
+            messages.push({
+                role: "runtime-summary",
+                text: `Runtime error: ${item.message}`,
+                turnId: input.turnId,
+                createdAt: item.createdAt,
+                messageId: item.eventId,
+                causedBy: `${input.turnId}.runtime`,
+                metadata: {
+                    source: "application.ledger.error",
+                    eventId: item.eventId,
+                },
+                status: "failed",
+            });
+        }
+    }
+    return messages;
+}
+function summarizeFileToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("file.") && !toolCall.toolId.startsWith("patch."))
         return undefined;
     const args = flattenedToolArguments(toolCall.arguments);
     const targetPath = stringValue(args.targetPath) ?? stringValue(args.path) ?? stringValue(args.filePath);
@@ -536,29 +790,16 @@ function summarizeCodeToolInput(toolCall) {
     const bytesSuffix = formatByteCount(contentBytes);
     const pathSummary = targetPaths.length > 0 ? formatPathList(targetPaths) : targetPath;
     switch (toolCall.toolId) {
-        case "code.scan": {
-            const depth = numberValue(args.depth);
-            const maxEntries = numberValue(args.maxEntries);
-            const detail = [
-                depth !== undefined ? `depth ${depth}` : undefined,
-                maxEntries !== undefined ? `up to ${maxEntries} entries` : undefined,
-            ].filter((item) => item !== undefined).join(", ");
-            return `Scanning ${directoryPath ?? "."}${detail ? ` (${detail})` : ""}`;
-        }
-        case "code.read":
+        case "file.read":
             return `Reading ${pathSummary ?? "file"}`;
-        case "code.search_Ripgrep":
+        case "file.search":
             return `Searching ${directoryPath ?? "."}${query ? ` for ${JSON.stringify(truncateMiddle(query, 80))}` : ""}`;
-        case "code.overwrite":
+        case "file.write":
             return `Writing ${targetPath ?? "file"}${bytesSuffix ? ` (${bytesSuffix})` : ""}`;
-        case "code.modify":
+        case "file.edit":
             return `Editing ${targetPath ?? "file"}`;
-        case "code.replaceFile":
-            return `Replacing ${targetPath ?? "file"}`;
-        case "code.delete":
-            return `Deleting from ${targetPath ?? "file"}`;
-        case "code.format":
-            return `Formatting ${targetPath ?? pathSummary ?? "file"}`;
+        case "patch.apply":
+            return `Applying patch${pathSummary ? ` to ${pathSummary}` : ""}`;
         default:
             if (pathSummary)
                 return `${toolCall.toolId} on ${pathSummary}`;
@@ -586,17 +827,19 @@ function summarizeShellToolInput(toolCall) {
     const { command, cwd } = shellCommandFromArguments(toolCall);
     const executionId = stringValue(args.executionId) ?? stringValue(args.launchId);
     if (command) {
-        const verb = toolCall.toolId === "shell.detachedExecution" || toolCall.toolId === "shell.backgroundExecution"
-            ? "Launching"
-            : "Running";
+        const verb = toolCall.toolId === "shell.serviceStartAndVerify"
+            ? "Starting and verifying"
+            : toolCall.toolId === "shell.detachedExecution" || toolCall.toolId === "shell.backgroundExecution"
+                ? "Launching"
+                : "Running";
         return `${verb} ${truncateMiddle(command, 180)}${cwd ? ` in ${cwd}` : ""}`;
     }
     if (executionId)
         return `${toolCall.toolId} for ${executionId}`;
     return undefined;
 }
-function summarizeCodeToolOutputForHumans(toolCall, output) {
-    if (!toolCall.toolId.startsWith("code."))
+function summarizeFileToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("file.") && !toolCall.toolId.startsWith("patch."))
         return undefined;
     const args = flattenedToolArguments(toolCall.arguments);
     const targetPath = stringValue(output?.targetPath) ?? stringValue(args.targetPath) ?? stringValue(args.path);
@@ -605,14 +848,15 @@ function summarizeCodeToolOutputForHumans(toolCall, output) {
         ...stringArrayValue(args.targetPaths),
     ];
     const directoryPath = stringValue(output?.directoryPath) ?? stringValue(args.directoryPath);
-    if (toolCall.toolId === "code.scan") {
+    if (toolCall.toolId === "file.search") {
         const entries = Array.isArray(output?.entries) ? output.entries : [];
+        const matches = Array.isArray(output?.matches) ? output.matches : [];
         const truncated = booleanValue(output?.truncated);
         return [
-            `Scanned ${directoryPath ?? "."}: ${entries.length} entr${entries.length === 1 ? "y" : "ies"}${truncated ? " (truncated)" : ""}`,
+            `Searched ${directoryPath ?? "."}: ${Math.max(entries.length, matches.length)} result${Math.max(entries.length, matches.length) === 1 ? "" : "s"}${truncated ? " (truncated)" : ""}`,
         ];
     }
-    if (toolCall.toolId === "code.read") {
+    if (toolCall.toolId === "file.read") {
         const bytes = numberValue(output?.bytes);
         const files = Array.isArray(output?.files) ? output.files : [];
         const count = files.length > 0 ? files.length : Math.max(targetPaths.length, targetPath ? 1 : 0);
@@ -621,7 +865,7 @@ function summarizeCodeToolOutputForHumans(toolCall, output) {
             `Read ${count > 1 ? `${count} files` : targetSummary}${formatByteCount(bytes) ? ` (${formatByteCount(bytes)})` : ""}`,
         ];
     }
-    if (toolCall.toolId === "code.overwrite") {
+    if (toolCall.toolId === "file.write") {
         const applied = booleanValue(output?.applied);
         const bytes = numberValue(output?.bytesWritten) ?? numberValue(output?.contentBytes);
         const verb = applied === false ? "Planned write" : "Wrote";
@@ -629,12 +873,18 @@ function summarizeCodeToolOutputForHumans(toolCall, output) {
             `${verb} ${targetPath ?? "file"}${formatByteCount(bytes) ? ` (${formatByteCount(bytes)})` : ""}`,
         ];
     }
-    if (toolCall.toolId === "code.modify" || toolCall.toolId === "code.replaceFile" || toolCall.toolId === "code.delete" || toolCall.toolId === "code.format") {
+    if (toolCall.toolId === "file.edit" || toolCall.toolId === "patch.apply") {
         const bytes = numberValue(output?.bytesWritten);
+        const changedFiles = [
+            ...stringArrayValue(output?.changedFiles),
+            ...stringArrayValue(output?.changed),
+            ...stringArrayValue(output?.committedFiles),
+        ];
+        const changedFileSummary = changedFiles.length > 0 ? ` for ${formatPathList(changedFiles)}` : targetPath ? ` for ${targetPath}` : "";
         const lines = [
-            `${toolCall.toolId} completed${targetPath ? ` for ${targetPath}` : ""}${formatByteCount(bytes) ? ` (${formatByteCount(bytes)})` : ""}`,
+            `${toolCall.toolId} completed${changedFileSummary}${formatByteCount(bytes) ? ` (${formatByteCount(bytes)})` : ""}`,
         ];
-        if (toolCall.toolId === "code.modify") {
+        if (toolCall.toolId === "file.edit") {
             const searchText = rawStringValue(args.searchText);
             const replacementText = rawStringValue(args.replacementText);
             if (searchText !== undefined && replacementText !== undefined) {
@@ -647,6 +897,23 @@ function summarizeCodeToolOutputForHumans(toolCall, output) {
                 }));
             }
         }
+        else {
+            const outputPreview = Array.isArray(output?.diffPreview)
+                ? output.diffPreview.flatMap((line) => typeof line === "string" ? [line] : [])
+                : [];
+            if (outputPreview.length > 0) {
+                lines.push(...outputPreview.slice(0, CODE_MODIFY_DIFF_PREVIEW_MAX_LINES));
+            }
+            else {
+                const patch = rawStringValue(args.patch);
+                if (patch !== undefined) {
+                    lines.push(...patchApplyDiffPreviewLines({ patch }));
+                }
+            }
+            const contextHint = stringValue(output?.contextHint);
+            if (contextHint !== undefined)
+                lines.push(contextHint);
+        }
         return lines;
     }
     return undefined;
@@ -659,14 +926,71 @@ function summarizeShellToolOutputForHumans(toolCall, output) {
     const command = stringValue(output?.command)
         ?? stringValue(target?.command)
         ?? shellCommandFromArguments(toolCall).command;
-    const exitCode = numberValue(output?.exitCode);
-    const stdout = stringValue(output?.stdout);
-    const stderr = stringValue(output?.stderr);
+    const exitCode = numberValue(output?.exitCode) ?? numberValue(resultEnvelope?.exitCode);
+    const stdout = stringValue(output?.stdout) ?? stringValue(resultEnvelope?.stdout);
+    const stderr = stringValue(output?.stderr) ?? stringValue(resultEnvelope?.stderr);
     const planned = booleanValue(resultEnvelope?.planned);
-    const handle = stringValue(resultEnvelope?.detachedHandle) ?? stringValue(target?.launchId);
+    const lifecycle = objectValue(resultEnvelope?.serviceLifecycle);
+    const statusSnapshot = objectValue(resultEnvelope?.statusSnapshot) ?? objectValue(output?.statusSnapshot);
+    const handle = stringValue(statusSnapshot?.handle)
+        ?? stringValue(resultEnvelope?.detachedHandle)
+        ?? stringValue(resultEnvelope?.backgroundHandle)
+        ?? stringValue(resultEnvelope?.spawnHandle)
+        ?? stringValue(resultEnvelope?.processHandle)
+        ?? stringValue(resultEnvelope?.serviceHandle)
+        ?? stringValue(lifecycle?.handle)
+        ?? stringValue(target?.serviceId)
+        ?? stringValue(target?.launchId)
+        ?? stringValue(target?.jobId);
+    const processState = stringValue(statusSnapshot?.processState) ?? stringValue(resultEnvelope?.serviceStatus);
+    const verificationStatus = stringValue(statusSnapshot?.verificationState) ?? stringValue(lifecycle?.verificationStatus);
+    const userReachability = stringValue(lifecycle?.userReachability);
+    const health = objectValue(resultEnvelope?.health);
+    const healthStatus = stringValue(health?.status);
+    const healthy = booleanValue(resultEnvelope?.healthy) ?? booleanValue(health?.healthy);
+    const failureReason = stringValue(resultEnvelope?.failureReason);
+    const stderrArtifactRef = stringValue(resultEnvelope?.stderrArtifactRef);
+    const snapshotVerified = booleanValue(statusSnapshot?.verified);
+    const verified = healthy === true || snapshotVerified === true || verificationStatus === "verified" || verificationStatus === "healthy" || userReachability === "verified";
+    const pid = numberValue(statusSnapshot?.pid) ?? numberValue(resultEnvelope?.pid) ?? numberValue(resultEnvelope?.processId) ?? numberValue(lifecycle?.processId);
+    const verification = objectValue(target?.verification);
+    const url = stringValue(statusSnapshot?.url) ?? stringValue(verification?.url);
     const lines = [];
-    if (toolCall.toolId === "shell.detachedExecution" || toolCall.toolId === "shell.backgroundExecution") {
-        lines.push(`${planned ? "Planned launch" : "Launched"}${command ? `: ${truncateMiddle(command, 160)}` : ""}${handle ? ` (${handle})` : ""}`);
+    if (toolCall.toolId === "shell.serviceStartAndVerify") {
+        const label = planned
+            ? "Planned service start"
+            : verified
+                ? "Service verified"
+                : failureReason !== undefined || healthStatus === "failed" || verificationStatus === "failed" || processState === "failed"
+                    ? "Service verification failed"
+                    : "Service verification pending";
+        lines.push(`${label}${command ? `: ${truncateMiddle(command, 160)}` : ""}${handle ? ` (${handle})` : ""}${url ? ` ${url}` : ""}`);
+        if (!planned && (pid !== undefined || verificationStatus !== undefined || processState !== undefined)) {
+            lines.push([
+                pid !== undefined ? `pid ${pid}` : undefined,
+                processState !== undefined ? `process ${processState}` : undefined,
+                healthStatus !== undefined ? `health ${healthStatus}` : verificationStatus !== undefined ? `verification ${verificationStatus}` : undefined,
+                failureReason !== undefined ? truncateMiddle(failureReason, 160) : undefined,
+            ].filter((item) => item !== undefined).join(", "));
+        }
+        if (!planned && stderrArtifactRef)
+            lines.push(`stderr artifact: ${truncateMiddle(stderrArtifactRef, 180)}`);
+    }
+    else if (toolCall.toolId === "shell.detachedExecution"
+        || toolCall.toolId === "shell.backgroundExecution"
+        || (toolCall.toolId === "shell.processSpawning" && stringValue(resultEnvelope?.status) === "started")
+        || verificationStatus !== undefined) {
+        const launchLabel = verificationStatus !== undefined && verificationStatus !== "verified"
+            ? "Launched, not verified"
+            : planned ? "Planned launch" : "Launched";
+        lines.push(`${launchLabel}${command ? `: ${truncateMiddle(command, 160)}` : ""}${handle ? ` (${handle})` : ""}`);
+        if (!planned && (verificationStatus !== undefined || userReachability !== undefined || pid !== undefined)) {
+            lines.push([
+                pid !== undefined ? `pid ${pid}` : undefined,
+                verificationStatus !== undefined ? `verification ${verificationStatus}` : undefined,
+                userReachability !== undefined ? `reachability ${userReachability}` : undefined,
+            ].filter((item) => item !== undefined).join(", "));
+        }
     }
     else if (exitCode !== undefined) {
         lines.push(`Command completed with exit ${exitCode}${command ? `: ${truncateMiddle(command, 120)}` : ""}`);
@@ -695,29 +1019,29 @@ function summarizeGitToolInput(toolCall) {
     ]);
     const scope = repositoryPath ? ` in ${repositoryPath}` : "";
     switch (toolCall.toolId) {
-        case "git.getRepositoryStatus":
+        case "git.status":
             return `Checking repository status${scope}`;
-        case "git.getWorkingTreeDiff":
+        case "git.diff":
             return `Inspecting working tree diff${pathSummary !== "file" ? ` for ${pathSummary}` : scope}`;
-        case "git.getCommitHistory":
+        case "git.log":
             return `Reading commit history${branch ? ` on ${branch}` : scope}`;
-        case "git.showGitObjectDetails":
+        case "git.show":
             return `Inspecting git object ${ref ?? "ref"}${scope}`;
-        case "git.traceLineOwnership":
+        case "git.blame":
             return `Tracing line ownership${pathSummary !== "file" ? ` for ${pathSummary}` : scope}`;
-        case "git.addToStaging":
+        case "git.add":
             return `Staging ${pathSummary}`;
-        case "git.resetStagingOrCommit":
+        case "git.reset":
             return `Resetting git state${ref ? ` from ${ref}` : scope}`;
-        case "git.restoreWorkingTree":
+        case "git.restore":
             return `Restoring ${pathSummary}`;
-        case "git.stashChanges":
+        case "git.stash":
             return `Stashing working tree changes${scope}`;
-        case "git.fetchRemoteUpdates":
+        case "git.fetch":
             return `Fetching remote updates${scope}`;
-        case "git.pullRemoteChanges":
+        case "git.pull":
             return `Pulling remote changes${branch ? ` for ${branch}` : scope}`;
-        case "git.pushLocalChanges":
+        case "git.push":
             return `Pushing local changes${branch ? ` for ${branch}` : scope}`;
         default:
             return repositoryPath ? `${toolCall.toolId} in ${repositoryPath}` : toolCall.toolId;
@@ -735,13 +1059,13 @@ function summarizeGitToolOutputForHumans(toolCall, output) {
     const behind = numberValue(envelope?.behind) ?? numberValue(output?.behindCount);
     const exitCode = numberValue(output?.exitCode);
     const lines = [];
-    if (toolCall.toolId === "git.getRepositoryStatus") {
+    if (toolCall.toolId === "git.status") {
         lines.push(`Repository status read${branch ? ` on ${branch}` : ""}`);
     }
-    else if (toolCall.toolId === "git.getWorkingTreeDiff") {
+    else if (toolCall.toolId === "git.diff") {
         lines.push("Working tree diff read");
     }
-    else if (toolCall.toolId === "git.getCommitHistory") {
+    else if (toolCall.toolId === "git.log") {
         lines.push("Commit history read");
     }
     else if (commitHash) {
@@ -756,19 +1080,19 @@ function summarizeGitToolOutputForHumans(toolCall, output) {
         lines.push(`ahead ${ahead ?? 0}, behind ${behind ?? 0}`);
     return lines.slice(0, 3);
 }
-function summarizeSearchToolInput(toolCall) {
-    if (!toolCall.toolId.startsWith("search."))
+function summarizeWebToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("web."))
         return undefined;
     const args = flattenedToolArguments(toolCall.arguments);
     const target = objectValue(args.target);
     const query = firstStringValue(target?.query, args.query, args.q);
     const url = firstStringValue(target?.url, args.url);
-    if (toolCall.toolId === "search.fetch")
+    if (toolCall.toolId === "web.fetch")
         return `Fetching ${url ?? query ?? "page"}`;
     return `Searching ${query ? truncateMiddle(query, 160) : "the web"}`;
 }
-function summarizeComputerUseToolInput(toolCall) {
-    if (!toolCall.toolId.startsWith("computeruse."))
+function summarizeComputerToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("computer."))
         return undefined;
     const args = flattenedToolArguments(toolCall.arguments);
     const target = objectValue(args.target);
@@ -778,15 +1102,15 @@ function summarizeComputerUseToolInput(toolCall) {
         return `Capturing screenshot${suffix}`;
     if (toolCall.toolId.includes("mouse"))
         return `Running mouse action${suffix}`;
-    if (toolCall.toolId === "computeruse.keyboardInputEmulation") {
+    if (toolCall.toolId === "computer.keyboardInputEmulation") {
         const text = firstStringValue(target?.text, args.text);
         return text ? `Typing ${JSON.stringify(truncateMiddle(text, 80))}${suffix}` : `Typing text${suffix}`;
     }
-    if (toolCall.toolId === "computeruse.keyboardSubmitInput") {
+    if (toolCall.toolId === "computer.keyboardSubmitInput") {
         const submitKey = firstStringValue(target?.submitKey, args.submitKey) ?? "Enter";
         return `Pressing ${submitKey}${suffix}`;
     }
-    if (toolCall.toolId === "computeruse.keyboardEmulation") {
+    if (toolCall.toolId === "computer.keyboardEmulation") {
         const actions = unknownArrayValue(target?.actions ?? args.actions);
         const firstAction = objectValue(actions[0]);
         const actionKind = firstStringValue(firstAction?.kind);
@@ -798,8 +1122,8 @@ function summarizeComputerUseToolInput(toolCall) {
         return `Using microphone${suffix}`;
     return targetHint ? `${toolCall.toolId} on ${targetHint}` : toolCall.toolId;
 }
-function summarizeComputerUseToolOutputForHumans(toolCall, output) {
-    if (!toolCall.toolId.startsWith("computeruse."))
+function summarizeComputerToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("computer."))
         return undefined;
     const target = objectValue(output?.target) ?? objectValue(toolCall.arguments.target);
     const artifactId = firstStringValue(output?.artifactId, output?.screenshotArtifactId, objectValue(output?.imageArtifact)?.artifactId, objectValue(output?.artifact)?.artifactId);
@@ -836,27 +1160,27 @@ function summarizeMcpToolInput(toolCall) {
     const serverId = firstStringValue(target?.serverId, target?.connectionId, args.serverId, args.connectionId);
     const toolName = firstStringValue(target?.toolName, target?.name, args.toolName, args.name);
     const resourceUri = firstStringValue(target?.resourceUri, target?.uri, args.resourceUri, args.uri);
-    if (toolCall.toolId === "mcp.listTools")
-        return `Listing MCP tools${serverId ? ` from ${serverId}` : ""}`;
-    if (toolCall.toolId === "mcp.call")
+    if (toolCall.toolId === "mcp.use")
         return `Calling MCP tool ${toolName ?? "tool"}${serverId ? ` on ${serverId}` : ""}`;
-    if (toolCall.toolId === "mcp.listResources")
-        return `Listing MCP resources${serverId ? ` from ${serverId}` : ""}`;
-    if (toolCall.toolId === "mcp.readResource")
-        return `Reading MCP resource ${resourceUri ?? "resource"}${serverId ? ` from ${serverId}` : ""}`;
+    if (toolCall.toolId === "mcp.resources") {
+        return resourceUri
+            ? `Reading MCP resource ${resourceUri}${serverId ? ` from ${serverId}` : ""}`
+            : `Listing MCP resources${serverId ? ` from ${serverId}` : ""}`;
+    }
     return `${toolCall.toolId}${serverId ? ` on ${serverId}` : ""}`;
 }
 function summarizeMcpToolOutputForHumans(toolCall, output) {
     if (!toolCall.toolId.startsWith("mcp."))
         return undefined;
     const envelope = objectValue(output?.resultEnvelope) ?? output;
+    const args = flattenedToolArguments(toolCall.arguments);
     const tools = unknownArrayValue(envelope?.tools ?? output?.tools);
     const resources = unknownArrayValue(envelope?.resources ?? output?.resources);
     const content = unknownArrayValue(envelope?.content ?? output?.content ?? objectValue(output?.resourceEnvelope)?.contents);
-    const target = objectValue(output?.target) ?? objectValue(toolCall.arguments.target);
-    const serverId = firstStringValue(target?.serverId, target?.connectionId, output?.serverId, output?.connectionId);
-    const toolName = firstStringValue(target?.toolName, target?.name, output?.toolName);
-    const resourceUri = firstStringValue(target?.resourceUri, target?.uri, objectValue(output?.resourceEnvelope)?.uri);
+    const target = objectValue(output?.target) ?? objectValue(args.target);
+    const serverId = firstStringValue(target?.serverId, target?.connectionId, output?.serverId, output?.connectionId, args.serverId, args.connectionId);
+    const toolName = firstStringValue(target?.toolName, target?.name, output?.toolName, args.toolName, args.name);
+    const resourceUri = firstStringValue(target?.resourceUri, target?.uri, objectValue(output?.resourceEnvelope)?.uri, args.uri);
     const lines = [`${toolCall.toolId} completed${serverId ? ` on ${serverId}` : ""}`];
     if (tools.length > 0)
         lines.push(`${tools.length} tool${tools.length === 1 ? "" : "s"}`);
@@ -912,16 +1236,16 @@ function summarizeSkillToolOutputForHumans(toolCall, output) {
         lines.push(`${matches.length} match${matches.length === 1 ? "" : "es"}`);
     return lines.slice(0, 3);
 }
-function summarizeOmniToolInput(toolCall) {
-    if (!toolCall.toolId.startsWith("omni."))
+function summarizeMediaToolInput(toolCall) {
+    if (!toolCall.toolId.startsWith("media."))
         return undefined;
     const args = flattenedToolArguments(toolCall.arguments);
     const target = objectValue(args.target);
     const imagePath = firstStringValue(target?.imagePath, args.imagePath, target?.imageRef, args.imageRef);
     const prompt = firstStringValue(target?.prompt, args.prompt, args.text);
-    if (toolCall.toolId === "omni.viewImage")
+    if (toolCall.toolId === "media.viewImage")
         return `Viewing image ${imagePath ?? "input"}`;
-    if (toolCall.toolId === "omni.generateImage")
+    if (toolCall.toolId === "media.generateImage")
         return `Generating image${prompt ? ` from ${JSON.stringify(truncateMiddle(prompt, 120))}` : ""}`;
     if (toolCall.toolId.includes("Audio"))
         return `${toolCall.toolId} audio`;
@@ -929,10 +1253,10 @@ function summarizeOmniToolInput(toolCall) {
         return `${toolCall.toolId} video`;
     return imagePath ? `${toolCall.toolId} for ${imagePath}` : toolCall.toolId;
 }
-function summarizeOmniToolOutputForHumans(toolCall, output) {
-    if (!toolCall.toolId.startsWith("omni."))
+function summarizeMediaToolOutputForHumans(toolCall, output) {
+    if (!toolCall.toolId.startsWith("media."))
         return undefined;
-    if (toolCall.toolId === "omni.viewImage") {
+    if (toolCall.toolId === "media.viewImage") {
         const providerMetadata = objectValue(output?.providerMetadata);
         const analysis = stringValue(providerMetadata?.analysis);
         const backend = stringValue(providerMetadata?.backend);
@@ -952,30 +1276,30 @@ function summarizeOmniToolOutputForHumans(toolCall, output) {
     return lines.slice(0, 3);
 }
 function summarizeToolInput(toolCall) {
-    const codeSummary = summarizeCodeToolInput(toolCall);
-    if (codeSummary !== undefined)
-        return codeSummary;
+    const fileSummary = summarizeFileToolInput(toolCall);
+    if (fileSummary !== undefined)
+        return fileSummary;
     const shellSummary = summarizeShellToolInput(toolCall);
     if (shellSummary !== undefined)
         return shellSummary;
     const gitSummary = summarizeGitToolInput(toolCall);
     if (gitSummary !== undefined)
         return gitSummary;
-    const searchSummary = summarizeSearchToolInput(toolCall);
-    if (searchSummary !== undefined)
-        return searchSummary;
-    const computerUseSummary = summarizeComputerUseToolInput(toolCall);
-    if (computerUseSummary !== undefined)
-        return computerUseSummary;
+    const webSummary = summarizeWebToolInput(toolCall);
+    if (webSummary !== undefined)
+        return webSummary;
+    const computerSummary = summarizeComputerToolInput(toolCall);
+    if (computerSummary !== undefined)
+        return computerSummary;
     const mcpSummary = summarizeMcpToolInput(toolCall);
     if (mcpSummary !== undefined)
         return mcpSummary;
     const skillSummary = summarizeSkillToolInput(toolCall);
     if (skillSummary !== undefined)
         return skillSummary;
-    const omniSummary = summarizeOmniToolInput(toolCall);
-    if (omniSummary !== undefined)
-        return omniSummary;
+    const mediaSummary = summarizeMediaToolInput(toolCall);
+    if (mediaSummary !== undefined)
+        return mediaSummary;
     const target = toolCall.arguments.target;
     if (target && typeof target === "object" && !Array.isArray(target)) {
         const targetRecord = target;
@@ -992,24 +1316,28 @@ function summarizeToolInput(toolCall) {
     return command ?? query ?? url ?? previewUnknown(toolCall.arguments, 180);
 }
 function familyForToolId(toolId) {
+    if (toolId === "patch.apply") {
+        return { familyKey: "code", familyTitle: "Code" };
+    }
     const [prefix] = toolId.split(".");
     switch (prefix) {
-        case "search":
+        case "web":
             return { familyKey: "websearch", familyTitle: "WebSearch" };
+        case "file":
+        case "patch":
+            return { familyKey: "file", familyTitle: "File" };
         case "shell":
             return { familyKey: "shell", familyTitle: "Shell" };
         case "git":
             return { familyKey: "git", familyTitle: "Git" };
-        case "code":
-            return { familyKey: "code", familyTitle: "Code" };
-        case "computeruse":
-            return { familyKey: "browser", familyTitle: "Computer Use" };
+        case "computer":
+            return { familyKey: "computer", familyTitle: "Computer" };
         case "mcp":
             return { familyKey: "mcp", familyTitle: "MCP" };
         case "skill":
             return { familyKey: "skill", familyTitle: "Skill" };
-        case "omni":
-            return { familyKey: "docs", familyTitle: "Omni" };
+        case "media":
+            return { familyKey: "media", familyTitle: "Media" };
         default:
             return { familyKey: prefix || "capability", familyTitle: prefix ? `${prefix.slice(0, 1).toUpperCase()}${prefix.slice(1)}` : "Capability" };
     }
@@ -1020,32 +1348,32 @@ function summarizeToolOutputForHumans(toolCall) {
         const message = stringValue(errorRecord?.message) ?? stringValue(toolCall.error);
         const code = stringValue(errorRecord?.code);
         return [
-            message ? `失败：${message}` : `失败：${toolCall.toolId} did not complete.`,
+            message ? `失败：${toolCall.toolId}: ${message}` : `失败：${toolCall.toolId} did not complete.`,
             ...(code ? [`原因码：${code}`] : []),
         ].slice(0, 3);
     }
     const output = objectValue(toolCall.output);
-    const codeSummary = summarizeCodeToolOutputForHumans(toolCall, output);
-    if (codeSummary !== undefined)
-        return codeSummary;
+    const fileSummary = summarizeFileToolOutputForHumans(toolCall, output);
+    if (fileSummary !== undefined)
+        return fileSummary;
     const shellSummary = summarizeShellToolOutputForHumans(toolCall, output);
     if (shellSummary !== undefined)
         return shellSummary;
     const gitSummary = summarizeGitToolOutputForHumans(toolCall, output);
     if (gitSummary !== undefined)
         return gitSummary;
-    const computerUseSummary = summarizeComputerUseToolOutputForHumans(toolCall, output);
-    if (computerUseSummary !== undefined)
-        return computerUseSummary;
+    const computerSummary = summarizeComputerToolOutputForHumans(toolCall, output);
+    if (computerSummary !== undefined)
+        return computerSummary;
     const mcpSummary = summarizeMcpToolOutputForHumans(toolCall, output);
     if (mcpSummary !== undefined)
         return mcpSummary;
     const skillSummary = summarizeSkillToolOutputForHumans(toolCall, output);
     if (skillSummary !== undefined)
         return skillSummary;
-    const omniSummary = summarizeOmniToolOutputForHumans(toolCall, output);
-    if (omniSummary !== undefined)
-        return omniSummary;
+    const mediaSummary = summarizeMediaToolOutputForHumans(toolCall, output);
+    if (mediaSummary !== undefined)
+        return mediaSummary;
     const envelope = objectValue(output?.resultEnvelope);
     const query = stringValue(envelope?.query);
     const answer = stringValue(envelope?.answer);
@@ -1055,18 +1383,11 @@ function summarizeToolOutputForHumans(toolCall) {
     const pageTitle = stringValue(output?.pageTitle);
     const finalUrl = stringValue(output?.finalUrl);
     const status = numberValue(output?.status);
-    if (toolCall.toolId === "search.searchEngine") {
+    if (toolCall.toolId === "web.search") {
         const firstTitles = results
             .map((item) => objectValue(item))
             .flatMap((item) => stringValue(item?.title) ?? [])
             .slice(0, 2);
-        return [
-            query ? `搜索：${query}` : undefined,
-            `结果：找到 ${results.length} 条网页结果`,
-            ...firstTitles.map((title) => `来源：${title}`),
-        ].filter((line) => line !== undefined).slice(0, 4);
-    }
-    if (toolCall.toolId === "search.nativeSearch") {
         const sourceTitles = [...sources, ...citations]
             .map((item) => objectValue(item))
             .flatMap((item) => stringValue(item?.title) ?? [])
@@ -1074,12 +1395,14 @@ function summarizeToolOutputForHumans(toolCall) {
         const hasRealSources = sources.length + citations.length > 0;
         return [
             query ? `搜索：${query}` : undefined,
+            results.length > 0 ? `结果：找到 ${results.length} 条网页结果` : undefined,
             answer && hasRealSources ? `摘要：${answer}` : undefined,
-            hasRealSources ? `来源：${sources.length + citations.length} 条` : "未返回可引用来源",
+            hasRealSources ? `来源：${sources.length + citations.length} 条` : results.length === 0 ? "未返回可引用来源" : undefined,
+            ...firstTitles.map((title) => `结果：${title}`),
             ...sourceTitles.map((title) => `来源：${title}`),
         ].filter((line) => line !== undefined).slice(0, 4);
     }
-    if (toolCall.toolId === "search.fetch") {
+    if (toolCall.toolId === "web.fetch") {
         return [
             finalUrl ? `页面：${finalUrl}` : undefined,
             pageTitle ? `标题：${pageTitle}` : undefined,
@@ -1099,6 +1422,13 @@ function createToolResultMetadata(toolCall) {
     const outputTarget = objectValue(output?.target);
     const envelope = objectValue(output?.resultEnvelope) ?? output;
     const providerMetadata = objectValue(output?.providerMetadata);
+    const serviceLifecycle = objectValue(envelope?.serviceLifecycle);
+    const health = objectValue(envelope?.health);
+    const error = objectValue(toolCall.error);
+    const contextAuditMetadata = objectValue(objectValue(args.context)?.auditMetadata);
+    const workspacePathNormalization = objectValue(output?.workspacePathNormalization)
+        ?? objectValue(contextAuditMetadata?.workspacePathNormalization)
+        ?? error;
     const targetPaths = [
         ...stringArrayValue(args.targetPaths),
         ...stringArrayValue(args.paths),
@@ -1113,7 +1443,7 @@ function createToolResultMetadata(toolCall) {
         ?? (actionCount > 0 ? actionCount : undefined);
     const resultCount = countFromArrays(output?.hits, output?.matches, output?.results);
     const changedFileCount = countFromArrays(envelope?.entries, envelope?.changedFiles, output?.changedFiles, output?.committedFiles);
-    const changeLineStats = codeChangeLineStats(toolCall);
+    const changeLineStats = fileChangeLineStats(toolCall);
     return cleanRecord({
         targetPaths,
         pathCount: targetPaths.length > 0 ? targetPaths.length : undefined,
@@ -1131,11 +1461,43 @@ function createToolResultMetadata(toolCall) {
         matchCount: countFromArrays(output?.matches, envelope?.matches),
         outputCount: countFromArrays(output?.documents, objectValue(output?.preparedInvocation)?.resources),
         mountCount: countFromArrays(objectValue(output?.activation)?.mounts),
+        processId: numberValue(envelope?.pid) ?? numberValue(envelope?.processId) ?? numberValue(serviceLifecycle?.processId),
+        processStatus: stringValue(envelope?.status),
+        processHandle: firstStringValue(envelope?.detachedHandle, envelope?.backgroundHandle, envelope?.spawnHandle, envelope?.processHandle),
+        alive: booleanValue(envelope?.alive),
+        serviceStatus: firstStringValue(envelope?.serviceStatus, serviceLifecycle?.status, envelope?.status, health?.status),
+        healthy: booleanValue(envelope?.healthy) ?? booleanValue(health?.healthy),
+        verificationStatus: firstStringValue(envelope?.verificationStatus, serviceLifecycle?.verificationStatus, health?.status),
+        serviceHandle: firstStringValue(envelope?.serviceHandle, serviceLifecycle?.handle, envelope?.detachedHandle, envelope?.backgroundHandle, envelope?.spawnHandle, envelope?.processHandle),
+        nextRequiredAction: firstStringValue(envelope?.nextRequiredAction, serviceLifecycle?.nextRequiredAction),
+        serviceLifecyclePhase: stringValue(serviceLifecycle?.phase),
+        serviceProcessState: stringValue(serviceLifecycle?.processState),
+        serviceVerificationStatus: stringValue(serviceLifecycle?.verificationStatus),
+        serviceReachability: stringValue(serviceLifecycle?.userReachability),
+        failureReason: stringValue(envelope?.failureReason),
+        stdoutArtifactRef: stringValue(envelope?.stdoutArtifactRef),
+        stderrArtifactRef: stringValue(envelope?.stderrArtifactRef),
+        registryArtifactRef: stringValue(envelope?.registryArtifactRef),
+        recommendedNextActions: stringArrayValue(envelope?.recommendedNextActions),
+        workspaceRoot: firstStringValue(workspacePathNormalization?.workspaceRoot, error?.workspaceRoot, output?.workspaceRoot, args.workspaceRoot, objectValue(args.context)?.workspaceRoot),
+        allowedRoots: unknownArrayValue(workspacePathNormalization?.allowedRoots).length > 0
+            ? unknownArrayValue(workspacePathNormalization?.allowedRoots)
+            : undefined,
+        requestedCwd: firstStringValue(workspacePathNormalization?.requestedCwd, error?.requestedCwd, output?.requestedCwd),
+        normalizedCwd: firstStringValue(workspacePathNormalization?.normalizedCwd, error?.normalizedCwd, output?.normalizedCwd),
+        requestedPath: firstStringValue(workspacePathNormalization?.requestedPath, error?.requestedPath, output?.requestedPath),
+        normalizedPath: firstStringValue(workspacePathNormalization?.normalizedPath, error?.normalizedPath, output?.normalizedPath),
+        cwdWasMapped: typeof workspacePathNormalization?.cwdWasMapped === "boolean" ? workspacePathNormalization.cwdWasMapped : output?.cwdWasMapped,
+        pathWasMapped: typeof workspacePathNormalization?.pathWasMapped === "boolean" ? workspacePathNormalization.pathWasMapped : output?.pathWasMapped,
+        mappingSource: firstStringValue(workspacePathNormalization?.mappingSource, output?.mappingSource),
+        suggestedCwd: firstStringValue(workspacePathNormalization?.suggestedCwd, output?.suggestedCwd),
+        serviceOwnership: firstStringValue(output?.serviceOwnership, providerMetadata?.serviceOwnership),
+        staleServiceRisk: typeof output?.staleServiceRisk === "boolean" ? output.staleServiceRisk : providerMetadata?.staleServiceRisk,
         imageCount: toolCall.toolId.includes("Image") || toolCall.toolId.includes("Screenshot") || firstStringValue(output?.imagePath, output?.artifactId) ? 1 : undefined,
         mimeType: firstStringValue(output?.mimeType, objectValue(output?.artifact)?.mimeType),
         codeAdditions: changeLineStats?.codeAdditions,
         codeDeletions: changeLineStats?.codeDeletions,
-        errorCode: stringValue(objectValue(toolCall.error)?.code),
+        errorCode: stringValue(error?.code),
     });
 }
 function toolCallRecordFromProgress(progress) {
@@ -1183,6 +1545,9 @@ function createToolProgressEvent(input) {
         },
     };
 }
+export const applicationRuntimeTestHooks = {
+    createToolProgressEvent,
+};
 function toolProgressKey(progress) {
     const callId = progress.phase === "started" ? progress.callId : progress.record.callId;
     return `${callId}:${progress.phase}`;
@@ -1191,6 +1556,9 @@ function createModelProgressEvent(input) {
     const usage = input.progress.phase === "started" ? undefined : input.progress.usage;
     const contextInputTokens = usage?.inputTokens;
     const contextTotalTokens = usage === undefined ? undefined : usageContextTotalTokens(usage);
+    const promptPackTokens = input.progress.phase === "started"
+        ? undefined
+        : input.progress.cacheDebug?.promptPack.totalEstimatedTokens;
     return {
         eventId: `${input.turnId}.model.${input.progress.invocationId}.${input.progress.phase}`,
         kind: "model",
@@ -1228,13 +1596,18 @@ function createModelProgressEvent(input) {
                     usageSource: usage?.source ?? "provider.model-call.usage",
                     activeTokens: contextInputTokens,
                     promptTokens: contextInputTokens,
+                    sessionContextTokens: Math.max(promptPackTokens ?? 0, contextInputTokens, input.conversationContext?.historyEstimatedTokens ?? 0, input.conversationContext?.transcriptTokens ?? 0),
+                    compressionLimitTokens: input.compressionLimitTokens
+                        ?? input.conversationContext?.compressionLimitTokens
+                        ?? modelAutoCompactTokenLimit(input.model),
                     lastRequestInputTokens: contextInputTokens,
                     lastRequestTotalTokens: contextTotalTokens,
-                    transcriptTokens: 0,
-                    summaryTokens: 0,
-                    historyMessages: 0,
+                    promptPackTokens,
+                    transcriptTokens: input.conversationContext?.transcriptTokens ?? 0,
+                    summaryTokens: input.conversationContext?.summaryTokens ?? 0,
+                    historyMessages: input.conversationContext?.historyMessages ?? 0,
                     estimated: usage?.estimated ?? false,
-                    compacted: false,
+                    compacted: input.conversationContext?.compacted ?? false,
                 },
             errorMessage: input.progress.phase === "failed" ? input.progress.error?.message : undefined,
         },
@@ -1456,16 +1829,161 @@ function readResponseSources(raw) {
     }
     return dedupeSources(sources);
 }
-function openAIResponsesCallerFor(liveProvider) {
+function openAIResponsesRouteFor(liveProvider) {
     if (liveProvider === undefined)
         return undefined;
     const provider = liveProvider.provider?.trim();
     const endpointShape = liveProvider.endpointShape?.trim();
     if (provider !== undefined && provider !== "openai")
         return undefined;
-    if (endpointShape !== undefined && endpointShape !== "responses")
+    if (endpointShape !== undefined && endpointShape !== "responses" && endpointShape !== "chatgpt_codex_responses")
         return undefined;
-    return liveProvider.openaiResponsesCaller ?? liveProvider.providerCaller;
+    const providerCaller = liveProvider.openaiResponsesCaller ?? liveProvider.providerCaller;
+    if (providerCaller === undefined)
+        return undefined;
+    const providerRoute = liveProvider.providerRoute?.trim();
+    const kind = providerRoute === "chatgpt_codex_responses" ||
+        endpointShape === "chatgpt_codex_responses" ||
+        liveProvider.auth?.credentialRef?.credentialType === "chatgpt_codex_oauth"
+        ? "chatgpt_codex_responses"
+        : "openai_responses";
+    return {
+        kind,
+        providerCaller,
+        baseURL: liveProvider.baseURL,
+    };
+}
+function responsesBaseRoute(input) {
+    const base = input.baseURL?.trim().replace(/\/+$/u, "");
+    if (base === undefined || base.length === 0) {
+        return { endpointPath: input.defaultEndpointPath };
+    }
+    if (base.endsWith("/v1/responses")) {
+        return { baseUrl: base.slice(0, -"/v1/responses".length) || undefined, endpointPath: "/v1/responses" };
+    }
+    if (base.endsWith("/responses")) {
+        return { baseUrl: base.slice(0, -"/responses".length) || undefined, endpointPath: "/responses" };
+    }
+    if (base.endsWith("/v1")) {
+        return { baseUrl: base, endpointPath: "/responses" };
+    }
+    return { baseUrl: base, endpointPath: input.defaultEndpointPath };
+}
+function adapterRequiredScopes(route, extraScopes = []) {
+    const routeScope = route.kind === "chatgpt_codex_responses" ? "chatgpt.codex.responses" : "openai.responses";
+    return ["model.invoke", routeScope, ...extraScopes];
+}
+function adapterBackend(route, suffix) {
+    return route.kind === "chatgpt_codex_responses"
+        ? `chatgpt-codex-responses-${suffix}`
+        : `openai-responses-${suffix}`;
+}
+function isChatGPTCodexAuth(auth) {
+    return auth.credentialRef?.credentialType === "chatgpt_codex_oauth";
+}
+function effectiveOpenAIResponsesApplicationRoute(route, auth) {
+    return isChatGPTCodexAuth(auth)
+        ? { ...route, kind: "chatgpt_codex_responses" }
+        : route;
+}
+function adapterRouteScopes(route, requestedScopes) {
+    return adapterRequiredScopes(route, requestedScopes.filter((scope) => scope !== "model.invoke" && scope !== "openai.responses" && scope !== "chatgpt.codex.responses"));
+}
+export function invokeOpenAIResponsesApplicationAdapter(input) {
+    const effectiveRoute = effectiveOpenAIResponsesApplicationRoute(input.route, input.auth);
+    const requiredScopes = adapterRouteScopes(effectiveRoute, input.requiredScopes);
+    if (effectiveRoute.kind === "chatgpt_codex_responses") {
+        const route = responsesBaseRoute({ baseURL: effectiveRoute.baseURL, defaultEndpointPath: "/responses" });
+        return invokeChatGPTCodexResponses({
+            operation: "create",
+            method: "POST",
+            auth: input.auth,
+            caller: effectiveRoute.providerCaller,
+            runtime: {
+                runtimeId: input.runtimeId,
+                invocationId: input.invocationId,
+                callerId: input.callerId,
+            },
+            requiredScopes,
+            governance: { accepted: true },
+            contract: { accepted: true },
+            dryRun: false,
+            headers: { "content-type": "application/json" },
+            expectResponseObject: false,
+            baseUrl: route.baseUrl,
+            endpointPath: route.endpointPath,
+            body: input.body,
+        });
+    }
+    const route = responsesBaseRoute({ baseURL: effectiveRoute.baseURL, defaultEndpointPath: "/v1/responses" });
+    return invokeOpenAIV1Responses({
+        operation: "create",
+        method: "POST",
+        auth: input.auth,
+        caller: effectiveRoute.providerCaller,
+        runtime: {
+            runtimeId: input.runtimeId,
+            invocationId: input.invocationId,
+            callerId: input.callerId,
+        },
+        requiredScopes,
+        governance: { accepted: true },
+        contract: { accepted: true },
+        dryRun: false,
+        headers: { "content-type": "application/json" },
+        expectResponseObject: false,
+        baseUrl: route.baseUrl,
+        endpointPath: route.endpointPath,
+        body: input.body,
+    });
+}
+function authEnvelopeWithPrivateMaterial(auth, privateMaterial) {
+    if (privateMaterial?.headers === undefined)
+        return auth;
+    return {
+        ...auth,
+        headerPlan: Object.entries(privateMaterial.headers).map(([name, value]) => ({
+            name: name.trim().toLowerCase(),
+            value,
+            redacted: true,
+        })),
+    };
+}
+function liveProviderHasAuthSource(liveProvider) {
+    return liveProvider?.auth !== undefined ||
+        (liveProvider?.runtimeAuthResolver !== undefined && liveProvider.authSelection !== undefined);
+}
+function liveProviderAuthSupplier(liveProvider) {
+    let cachedResolvedAuth;
+    return async () => {
+        if (liveProvider?.auth !== undefined)
+            return liveProvider.auth;
+        if (liveProvider?.runtimeAuthResolver === undefined || liveProvider.authSelection === undefined) {
+            return undefined;
+        }
+        cachedResolvedAuth ??= liveProvider.runtimeAuthResolver.resolve(liveProvider.authSelection).then((resolved) => {
+            if (!resolved.ok)
+                return undefined;
+            return authEnvelopeWithPrivateMaterial(resolved.value.auth, resolved.value.resolved.privateMaterial);
+        });
+        return await cachedResolvedAuth;
+    };
+}
+async function requireAdapterAuth(authSupplier, adapterLabel) {
+    const auth = await authSupplier();
+    if (auth?.present === true)
+        return { ok: true, auth };
+    return {
+        ok: false,
+        result: {
+            ok: false,
+            error: {
+                code: "AUTH_REQUIRED",
+                message: `${adapterLabel} requires resolved provider auth material`,
+                publicSafe: true,
+            },
+        },
+    };
 }
 function createProviderNativeSearchAdapter(input) {
     return async (request) => {
@@ -1479,22 +1997,17 @@ function createProviderNativeSearchAdapter(input) {
                 },
             };
         }
-        const result = await invokeChatGPTCodexResponses({
-            operation: "create",
-            method: "POST",
-            auth: input.auth,
-            caller: input.providerCaller,
-            runtime: {
-                runtimeId: input.runtimeId,
-                invocationId: `native-web-search:${Date.now()}`,
-                callerId: "raxode.application.nativeWebSearch",
-            },
-            requiredScopes: ["model.invoke", "chatgpt.codex.responses"],
-            governance: { accepted: true },
-            contract: { accepted: true },
-            dryRun: false,
-            headers: { "content-type": "application/json" },
-            expectResponseObject: false,
+        const resolvedAuth = await requireAdapterAuth(input.auth, "provider-native search adapter");
+        if (!resolvedAuth.ok)
+            return resolvedAuth.result;
+        const route = effectiveOpenAIResponsesApplicationRoute(input.route, resolvedAuth.auth);
+        const result = await invokeOpenAIResponsesApplicationAdapter({
+            route,
+            auth: resolvedAuth.auth,
+            runtimeId: input.runtimeId,
+            invocationId: `native-web-search:${Date.now()}`,
+            callerId: "raxode.application.nativeWebSearch",
+            requiredScopes: adapterRequiredScopes(route),
             body: {
                 model: request.model ?? "gpt-5.5",
                 input: request.query,
@@ -1536,7 +2049,7 @@ function createProviderNativeSearchAdapter(input) {
                 })),
                 providerMetadata: {
                     provider: request.provider,
-                    backend: "openai-web-search",
+                    backend: adapterBackend(route, "web-search"),
                     sourceCount: sources.length,
                 },
             },
@@ -1663,7 +2176,7 @@ function resolveImageAttachment(input) {
 function createOpenAIResponsesImageVisionAdapter(input) {
     return async (request) => {
         const parameters = request.parameters ?? {};
-        if (request.operation === "omni.generateImage.generateimage") {
+        if (request.operation === "media.generateImage.generateimage") {
             const prompt = stringValue(parameters.prompt);
             const outputPath = stringValue(parameters.outputPath);
             if (prompt === undefined || outputPath === undefined) {
@@ -1671,7 +2184,7 @@ function createOpenAIResponsesImageVisionAdapter(input) {
                     ok: false,
                     error: {
                         code: "PROVIDER_REJECTED",
-                        message: "omni.generateImage requires target.prompt and target.outputPath for Responses image_generation",
+                        message: "media.generateImage requires target.prompt and target.outputPath for Responses image_generation",
                         publicSafe: true,
                     },
                 };
@@ -1691,22 +2204,17 @@ function createOpenAIResponsesImageVisionAdapter(input) {
                 imageTool.quality = quality;
             if (outputFormat !== undefined)
                 imageTool.output_format = outputFormat;
-            const result = await invokeChatGPTCodexResponses({
-                operation: "create",
-                method: "POST",
-                auth: input.auth,
-                caller: input.providerCaller,
-                runtime: {
-                    runtimeId: input.runtimeId,
-                    invocationId: `omni-generate-image:${Date.now()}`,
-                    callerId: "raxode.application.omniGenerateImage",
-                },
-                requiredScopes: ["model.invoke", "chatgpt.codex.responses", "omni.image.generate"],
-                governance: { accepted: true },
-                contract: { accepted: true },
-                dryRun: false,
-                headers: { "content-type": "application/json" },
-                expectResponseObject: false,
+            const resolvedAuth = await requireAdapterAuth(input.auth, "media.generateImage OpenAI Responses adapter");
+            if (!resolvedAuth.ok)
+                return resolvedAuth.result;
+            const route = effectiveOpenAIResponsesApplicationRoute(input.route, resolvedAuth.auth);
+            const result = await invokeOpenAIResponsesApplicationAdapter({
+                route,
+                auth: resolvedAuth.auth,
+                runtimeId: input.runtimeId,
+                invocationId: `media-generate-image:${Date.now()}`,
+                callerId: "raxode.application.mediaGenerateImage",
+                requiredScopes: adapterRequiredScopes(route, ["media.image.generate"]),
                 body: {
                     model: input.model,
                     input: prompt,
@@ -1733,7 +2241,7 @@ function createOpenAIResponsesImageVisionAdapter(input) {
                     ok: false,
                     error: {
                         code: "RESPONSE_FORMAT_DRIFT",
-                        message: "omni.generateImage Responses image_generation did not return an image_generation_call result",
+                        message: "media.generateImage Responses image_generation did not return an image_generation_call result",
                         publicSafe: true,
                     },
                     events: result.events,
@@ -1751,7 +2259,7 @@ function createOpenAIResponsesImageVisionAdapter(input) {
                 },
                 metadata: {
                     provider: "openai",
-                    backend: "chatgpt-codex-responses-image-generation",
+                    backend: adapterBackend(route, "image-generation"),
                     model: input.model,
                     outputPath,
                     mimeType,
@@ -1759,7 +2267,7 @@ function createOpenAIResponsesImageVisionAdapter(input) {
                     ...(generated.revisedPrompt ? { revisedPrompt: generated.revisedPrompt } : {}),
                     ...(generated.imageCallId ? { imageCallId: generated.imageCallId } : {}),
                 },
-                events: ["raxode.application.omniGenerateImage.openai.called"],
+                events: ["raxode.application.mediaGenerateImage.openai.called"],
             };
         }
         const imageRef = stringValue(parameters.imageRef) ?? request.inputArtifactId;
@@ -1774,8 +2282,8 @@ function createOpenAIResponsesImageVisionAdapter(input) {
                 error: {
                     code: "PROVIDER_UNAVAILABLE",
                     message: imageRef
-                        ? `omni.viewImage OpenAI vision adapter could not resolve imageRef to a local imagePath: ${imageRef}`
-                        : "omni.viewImage OpenAI vision adapter requires a local imagePath or an application image attachment reference",
+                        ? `media.viewImage OpenAI vision adapter could not resolve imageRef to a local imagePath: ${imageRef}`
+                        : "media.viewImage OpenAI vision adapter requires a local imagePath or an application image attachment reference",
                     publicSafe: true,
                 },
             };
@@ -1790,7 +2298,7 @@ function createOpenAIResponsesImageVisionAdapter(input) {
                 ok: false,
                 error: {
                     code: "PROVIDER_UNAVAILABLE",
-                    message: `omni.viewImage OpenAI vision adapter could not read imagePath: ${imagePath}`,
+                    message: `media.viewImage OpenAI vision adapter could not read imagePath: ${imagePath}`,
                     publicSafe: true,
                 },
             };
@@ -1800,29 +2308,24 @@ function createOpenAIResponsesImageVisionAdapter(input) {
                 ok: false,
                 error: {
                     code: "PROVIDER_REJECTED",
-                    message: `omni.viewImage image exceeds maxBytes (${bytes.byteLength} > ${maxBytes})`,
+                    message: `media.viewImage image exceeds maxBytes (${bytes.byteLength} > ${maxBytes})`,
                     publicSafe: true,
                 },
             };
         }
         const mimeType = imageMimeTypeFromPath(imagePath, stringValue(parameters.mediaType) ?? attachment?.mimeType);
         const detail = responsesImageDetail(stringValue(parameters.detail));
-        const result = await invokeChatGPTCodexResponses({
-            operation: "create",
-            method: "POST",
-            auth: input.auth,
-            caller: input.providerCaller,
-            runtime: {
-                runtimeId: input.runtimeId,
-                invocationId: `omni-view-image:${Date.now()}`,
-                callerId: "raxode.application.omniViewImage",
-            },
-            requiredScopes: ["model.invoke", "chatgpt.codex.responses"],
-            governance: { accepted: true },
-            contract: { accepted: true },
-            dryRun: false,
-            headers: { "content-type": "application/json" },
-            expectResponseObject: false,
+        const resolvedAuth = await requireAdapterAuth(input.auth, "media.viewImage OpenAI Responses adapter");
+        if (!resolvedAuth.ok)
+            return resolvedAuth.result;
+        const route = effectiveOpenAIResponsesApplicationRoute(input.route, resolvedAuth.auth);
+        const result = await invokeOpenAIResponsesApplicationAdapter({
+            route,
+            auth: resolvedAuth.auth,
+            runtimeId: input.runtimeId,
+            invocationId: `media-view-image:${Date.now()}`,
+            callerId: "raxode.application.mediaViewImage",
+            requiredScopes: adapterRequiredScopes(route),
             body: {
                 model: input.model,
                 input: [{
@@ -1866,14 +2369,14 @@ function createOpenAIResponsesImageVisionAdapter(input) {
             },
             metadata: {
                 provider: "openai",
-                backend: "chatgpt-codex-responses-vision",
+                backend: adapterBackend(route, "vision"),
                 model: input.model,
                 imagePath,
                 mimeType,
                 detail,
                 ...(analysis ? { analysis } : {}),
             },
-            events: ["raxode.application.omniViewImage.openai.called"],
+            events: ["raxode.application.mediaViewImage.openai.called"],
         };
     };
 }
@@ -1923,10 +2426,10 @@ function approvalFeatureKey(envelope) {
     return envelope.source;
 }
 function approvalFeatureLabel(featureKey) {
-    if (featureKey.startsWith("computeruse."))
-        return "computer_use";
-    if (featureKey.startsWith("omni."))
-        return "omni";
+    if (featureKey.startsWith("computer."))
+        return "computer";
+    if (featureKey.startsWith("media."))
+        return "media";
     if (featureKey.startsWith("shell."))
         return "shell";
     if (featureKey.startsWith("git."))
@@ -2040,13 +2543,44 @@ function summarizeRunUsage(result) {
     if (lastTotalTokens !== undefined) {
         summary.lastTotalTokens = lastTotalTokens;
     }
+    const lastPromptPack = [...result.modelCalls].reverse().find((call) => typeof call.cacheDebug?.promptPack.totalEstimatedTokens === "number" &&
+        Number.isFinite(call.cacheDebug.promptPack.totalEstimatedTokens));
+    if (lastPromptPack?.cacheDebug?.promptPack.totalEstimatedTokens !== undefined) {
+        summary.lastPromptPackTokens = lastPromptPack.cacheDebug.promptPack.totalEstimatedTokens;
+    }
     return summary.modelCalls > 0 ? summary : undefined;
 }
+function createApplicationMcpModule(options) {
+    if (options.mcpModule !== undefined)
+        return options.mcpModule;
+    const nativeServers = (options.mcpServers ?? []).map((server) => ({
+        ...server,
+        mode: server.mode ?? "native",
+    }));
+    const plusServers = (options.mcpPlusServers ?? []).map((server) => ({
+        ...server,
+        mode: "mcp-plus",
+    }));
+    const servers = [...nativeServers, ...plusServers];
+    if (servers.length === 0)
+        return undefined;
+    return {
+        kind: "praxis.mcp.module",
+        version: "praxis.mcp.v1",
+        servers,
+        recommended: true,
+        metadata: { source: "application.mcp.options" },
+    };
+}
+function applicationMcpServerProfiles(module) {
+    return (module?.servers ?? []).map(toMcpRuntimeServerProfile);
+}
 export function createPraxisApplicationRuntime(options) {
     const now = options.now ?? defaultNow;
     const listeners = new Set();
     const project = options.project;
     const applicationId = options.applicationId ?? project.applicationId;
+    const applicationMcpModule = createApplicationMcpModule(options);
     const state = {
         status: "idle",
         sessionId: options.sessionId ?? `session.${applicationId}.default`,
@@ -2062,7 +2596,8 @@ export function createPraxisApplicationRuntime(options) {
             providerRoute: options.providerRoute,
             maxOutputTokens: options.maxOutputTokens,
         }),
-        permissionProfile: options.permissionProfile ?? "standard",
+        permissionProfile: options.permissionProfile ?? "permissive",
+        toolProfile: options.toolProfile ?? "codingCore",
         turns: 0,
         modelCalls: 0,
         toolCalls: 0,
@@ -2072,14 +2607,64 @@ export function createPraxisApplicationRuntime(options) {
         approvals: new Map(),
         pendingApprovalResolvers: new Map(),
         cancelledAuxiliaryTasks: new Set(),
-        conversationHistory: new Map(),
-        conversationSummaries: new Map(),
+        conversationHistory: initialConversationHistoryMap(options.initialConversations),
+        conversationSummaries: initialConversationSummaryMap(options.initialConversations),
         modelCacheDebugBySession: new Map(),
         lastProviderResponseBySession: new Map(),
         toolContextSelections: new Map(),
         toolContextUsage: new Map(),
         alwaysApprovedApprovalKeys: new Set(),
+        foundationProject: options.foundationProject,
+        multiagentRuntime: createInMemoryMultiagentRuntime({
+            projectId: project.projectId,
+            workspaceRoot: path.resolve(options.cwd ?? project.projectRoot),
+            defaultModel: options.model,
+            initialSessions: [{
+                    sessionId: options.sessionId ?? `session.${applicationId}.default`,
+                    agentId: project.agentEntries.primary?.agentId ?? `agent.${project.projectId}.primary`,
+                    workingDirectory: path.resolve(options.cwd ?? project.projectRoot),
+                    status: "idle",
+                }],
+        }),
+        multiagentActiveSessions: 1,
+        multiagentBackgroundRuns: new Set(),
+        auth: undefined,
+        mcp: createMcpApplicationStateView(applicationMcpModule),
     };
+    async function refreshAuthState() {
+        const next = await options.authStateProvider?.({
+            sessionId: state.sessionId,
+            runtimeId: state.runtimeId,
+            manifest: state.manifest,
+            model: state.model,
+        });
+        if (next !== undefined) {
+            state.auth = next;
+        }
+    }
+    async function safeRefreshAuthState() {
+        try {
+            await refreshAuthState();
+        }
+        catch (error) {
+            state.auth = {
+                profiles: [],
+                lastAuditEventKind: "application.auth.state.failed",
+                lastAuditAt: now(),
+                publicSafe: true,
+            };
+            publish({
+                eventId: "application.auth.state.failed",
+                kind: "error",
+                status: state.status,
+                message: "Application auth state provider failed",
+                metadata: { code: "AUTH_STATE_PROVIDER_FAILED" },
+            });
+        }
+    }
+    function commandSessionId(command) {
+        return "sessionId" in command ? command.sessionId : undefined;
+    }
     function publish(input) {
         const output = event({
             ...input,
@@ -2109,6 +2694,30 @@ export function createPraxisApplicationRuntime(options) {
             lastActiveAt: now(),
             turns: state.turns,
         });
+        void state.multiagentRuntime.ensureSession({
+            sessionId: state.sessionId,
+            agentId: state.manifest?.identity.id ?? project.agentEntries.primary?.agentId ?? `agent.${project.projectId}.primary`,
+            name: current?.name ?? state.sessionId.split(".").at(-1),
+            workingDirectory: state.cwd,
+            status: state.status === "running" ? "running" : "idle",
+            metadata: {
+                applicationId,
+                runtimeId: state.runtimeId,
+                source: "application.session",
+            },
+            now: now(),
+        }).catch((error) => {
+            state.events.push(event({
+                eventId: `${state.sessionId}.multiagent.ensure.failed`,
+                kind: "runtime",
+                status: state.status,
+                message: error instanceof Error ? error.message : "multiagent session ensure failed",
+                sessionId: state.sessionId,
+                runtimeId: state.runtimeId,
+                createdAt: now(),
+                metadata: { code: "MULTIAGENT_SESSION_ENSURE_FAILED" },
+            }));
+        });
     }
     function approvalResolverForRun() {
         return async (envelope) => {
@@ -2160,12 +2769,202 @@ export function createPraxisApplicationRuntime(options) {
             });
         };
     }
+    function multiagentAgentAdapter() {
+        const scheduleSpawnedAgentRun = (spawned) => {
+            const childSession = spawned.session;
+            const initialMessage = spawned.initialMessage;
+            if (state.multiagentBackgroundRuns.has(childSession.sessionId))
+                return;
+            state.multiagentBackgroundRuns.add(childSession.sessionId);
+            state.multiagentActiveSessions = Math.max(state.multiagentActiveSessions, state.multiagentBackgroundRuns.size + 1);
+            state.sessions.set(childSession.sessionId, {
+                sessionId: childSession.sessionId,
+                name: childSession.name ?? childSession.sessionId.split(".").at(-1),
+                workspaceRoot: childSession.workingDirectory,
+                status: "running",
+                lastActiveAt: now(),
+                turns: 1,
+            });
+            publish({
+                eventId: `${childSession.sessionId}.multiagent.spawned`,
+                kind: "runtime",
+                status: state.status,
+                message: childSession.name ?? childSession.sessionId,
+                sessionId: state.sessionId,
+                metadata: {
+                    childSessionId: childSession.sessionId,
+                    childAgentId: childSession.agentId,
+                    childName: childSession.name,
+                    childDescription: childSession.description,
+                    childLifecycle: childSession.lifecycle,
+                    initialMessageId: initialMessage.messageId,
+                    workingDirectory: childSession.workingDirectory,
+                },
+            });
+            void (async () => {
+                let replyText = "";
+                try {
+                    const compiled = await compileManifest("primary", { updateState: false });
+                    if (!compiled.ok) {
+                        replyText = `Child agent failed to compile: ${compiled.message}`;
+                        return;
+                    }
+                    let liveProvider;
+                    if (state.mode === "live") {
+                        liveProvider = await options.liveProviderResolver?.(compiled.manifest, {
+                            sessionId: childSession.sessionId,
+                            runtimeId: `${state.runtimeId}.multiagent.${safeSessionName(childSession.sessionId)}`,
+                            turnId: initialMessage.messageId,
+                        });
+                    }
+                    const runtime = praxis.runtime.createPraxisRuntimeKernel({
+                        runtimeId: `${state.runtimeId}.multiagent.${safeSessionName(childSession.sessionId)}`,
+                    });
+                    const result = await runtime.runManifest(compiled.manifest, initialMessage.text, {
+                        runtimeId: `${state.runtimeId}.multiagent.${safeSessionName(childSession.sessionId)}`,
+                        sessionId: childSession.sessionId,
+                        dryRun: state.mode !== "live",
+                        allowProviderCall: state.mode === "live",
+                        allowToolExecution: state.mode === "live",
+                        auth: liveProvider?.auth,
+                        runtimeAuthResolver: liveProvider?.runtimeAuthResolver,
+                        authSelection: liveProvider?.authSelection,
+                        providerCaller: liveProvider?.providerCaller,
+                        openaiResponsesCaller: liveProvider?.openaiResponsesCaller,
+                        openaiChatCompletionsCaller: liveProvider?.openaiChatCompletionsCaller,
+                        anthropicMessagesCaller: liveProvider?.anthropicMessagesCaller,
+                        geminiGenerateContentTransport: liveProvider?.geminiGenerateContentTransport,
+                        exposeProviderTools: true,
+                        approvalResolver: approvalResolverForRun(),
+                        agentReviewResolver: options.agentReviewResolver,
+                        mcpServers: applicationMcpServerProfiles(applicationMcpModule),
+                        mcpModule: applicationMcpModule,
+                        storage: {
+                            cwd: childSession.workingDirectory,
+                            workspaceRoot: path.join(project.projectRoot, ".raxode"),
+                            initMode: "on-run",
+                        },
+                        sandbox: { cwd: childSession.workingDirectory, provider: options.sandboxProvider },
+                        baseToolAdapters: {
+                            agent: multiagentAgentAdapter(),
+                            ...(options.contextArtifactAdapters ?? {}),
+                            ...(options.baseToolAdapters ?? {}),
+                        },
+                        now,
+                    });
+                    if (result.ok) {
+                        replyText = result.finalOutput || "Child agent completed without a final message.";
+                    }
+                    else {
+                        replyText = `Child agent failed: ${result.error.message}`;
+                    }
+                }
+                catch (error) {
+                    replyText = `Child agent failed: ${error instanceof Error ? error.message : String(error)}`;
+                }
+                finally {
+                    state.multiagentBackgroundRuns.delete(childSession.sessionId);
+                    state.multiagentActiveSessions = Math.max(1, state.multiagentBackgroundRuns.size + 1);
+                    const existingChildSession = state.sessions.get(childSession.sessionId);
+                    state.sessions.set(childSession.sessionId, {
+                        sessionId: childSession.sessionId,
+                        name: existingChildSession?.name ?? childSession.name ?? childSession.sessionId.split(".").at(-1),
+                        workspaceRoot: childSession.workingDirectory,
+                        status: "idle",
+                        lastActiveAt: now(),
+                        turns: existingChildSession?.turns ?? 1,
+                    });
+                    if (replyText.trim().length > 0) {
+                        await state.multiagentRuntime.message({
+                            fromSessionId: childSession.sessionId,
+                            toSessionId: initialMessage.fromSessionId,
+                            text: replyText,
+                            replyToMessageId: initialMessage.messageId,
+                            now: now(),
+                            metadata: {
+                                source: "application.multiagent.backgroundRun",
+                                childSessionId: childSession.sessionId,
+                            },
+                        });
+                    }
+                    publish({
+                        eventId: `${childSession.sessionId}.multiagent.completed`,
+                        kind: "runtime",
+                        status: state.status,
+                        message: childSession.name ?? childSession.sessionId,
+                        sessionId: state.sessionId,
+                        metadata: {
+                            childSessionId: childSession.sessionId,
+                            childAgentId: childSession.agentId,
+                            childName: childSession.name,
+                            childDescription: childSession.description,
+                            childLifecycle: childSession.lifecycle,
+                            initialMessageId: initialMessage.messageId,
+                        },
+                    });
+                }
+            })();
+        };
+        const wrap = async (operation) => {
+            try {
+                await state.multiagentRuntime.ensureSession({
+                    sessionId: state.sessionId,
+                    agentId: state.manifest?.identity.id ?? project.agentEntries.primary?.agentId ?? `agent.${project.projectId}.primary`,
+                    workingDirectory: state.cwd,
+                    status: state.status === "running" ? "running" : "idle",
+                    metadata: {
+                        applicationId,
+                        runtimeId: state.runtimeId,
+                        source: "application.basetool",
+                    },
+                    now: now(),
+                });
+                const output = await operation();
+                const maybeSessionStatus = objectValue(output?.session)?.status;
+                if (maybeSessionStatus === "idle" || maybeSessionStatus === "running") {
+                    state.multiagentActiveSessions = Math.max(state.multiagentActiveSessions, 2);
+                }
+                return { ok: true, output, value: output };
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    error: {
+                        code: "MULTIAGENT_RUNTIME_FAILED",
+                        message: error instanceof Error ? error.message : "multiagent runtime failed",
+                        publicSafe: true,
+                    },
+                };
+            }
+        };
+        return {
+            spawn: (request) => wrap(async () => {
+                const spawned = await state.multiagentRuntime.spawn(request);
+                scheduleSpawnedAgentRun(spawned);
+                return spawned;
+            }),
+            message: (request) => wrap(() => state.multiagentRuntime.message(request)),
+            inbox: (request) => wrap(() => state.multiagentRuntime.inbox(request)),
+            list: (request) => wrap(() => state.multiagentRuntime.list(request)),
+            inspect: (request) => wrap(() => state.multiagentRuntime.inspect(request)),
+            wait: (request) => wrap(() => state.multiagentRuntime.wait(request)),
+            stop: (request) => wrap(() => state.multiagentRuntime.stop(request)),
+            kill: (request) => wrap(() => state.multiagentRuntime.kill(request)),
+        };
+    }
     function view() {
         const agentId = state.manifest?.identity.id ?? project.descriptor.agent?.id ?? "agent.unknown";
+        const compressionLimitTokens = applicationCompressionLimitTokens({
+            model: state.model,
+            compactContextWindowTokens: options.compactContextWindowTokens,
+            compactThresholdRatio: options.compactThresholdRatio,
+        });
         const context = estimateConversationContext({
             messages: state.conversationHistory.get(state.sessionId) ?? [],
             summary: state.conversationSummaries.get(state.sessionId),
             usage: state.usage,
+            model: state.model,
+            compressionLimitTokens,
         });
         const lines = [
             `application: ${applicationId}`,
@@ -2176,8 +2975,10 @@ export function createPraxisApplicationRuntime(options) {
                 ? `input budget: ${state.model.usableInputTokens}/${state.model.maxInputTokens} tokens @ ${Math.round((state.model.inputBudgetThreshold ?? 1) * 100)}%`
                 : "input budget: unknown",
             `permission: ${state.permissionProfile}`,
+            `tool profile: ${state.toolProfile}`,
+            `mcp servers: ${state.mcp.servers.length}`,
             `workspace: ${state.cwd}`,
-            `tools: ${summarizeToolCatalog(state.manifest).mounted}/${summarizeToolCatalog(state.manifest).total}`,
+            `tools: ${summarizeToolCatalog(state.manifest, state.toolProfile).mounted}/${summarizeToolCatalog(state.manifest, state.toolProfile).total}`,
             state.finalOutput ? `final: ${state.finalOutput}` : `status: ${state.status}`,
         ];
         return {
@@ -2187,15 +2988,26 @@ export function createPraxisApplicationRuntime(options) {
             sessionId: state.sessionId,
             agentId,
             agentEntries: summarizeAgentEntries(project),
+            agents: { active: state.multiagentActiveSessions },
             status: state.status,
             workspaceRoot: state.cwd,
             mode: state.mode,
             model: state.model,
+            auth: state.auth,
             permissionProfile: state.permissionProfile,
+            toolProfile: state.toolProfile,
+            foundationProject: state.foundationProject === undefined ? undefined : {
+                projectId: state.foundationProject.project.projectId,
+                kind: state.foundationProject.project.kind,
+                workspaceRoot: state.foundationProject.project.mainWorkspaceRoot,
+                sessionSqlitePath: state.foundationProject.paths.sessionSqlitePath,
+                locked: state.foundationProject.lease !== undefined,
+            },
             sessions: [...state.sessions.values()].sort((left, right) => right.lastActiveAt.localeCompare(left.lastActiveAt)),
             approvals: [...state.approvals.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)),
             manifest: summarizeManifest(state.manifest),
-            tools: summarizeToolCatalog(state.manifest),
+            tools: summarizeToolCatalog(state.manifest, state.toolProfile),
+            mcp: state.mcp,
             counters: {
                 turns: state.turns,
                 events: state.events.length,
@@ -2211,7 +3023,7 @@ export function createPraxisApplicationRuntime(options) {
             events: state.events,
         };
     }
-    async function compileManifest(agentKey = "primary", options = {}) {
+    async function compileManifest(agentKey = "primary", compileOptions = {}) {
         try {
             const entry = project.agentEntries[agentKey];
             if (!entry) {
@@ -2223,6 +3035,7 @@ export function createPraxisApplicationRuntime(options) {
             });
             const defaultAgentOptions = {
                 policyProfile: state.permissionProfile,
+                toolProfile: state.toolProfile,
                 provider: state.model.provider,
                 endpointShape: state.model.endpointShape,
                 baseURL: state.model.baseURL,
@@ -2231,9 +3044,15 @@ export function createPraxisApplicationRuntime(options) {
                 reasoningEffort: state.model.reasoningEffort,
                 maxOutputTokens: state.model.maxOutputTokens,
             };
-            const agentOptions = typeof options.agentOptions === "object" && options.agentOptions !== null
-                ? { ...defaultAgentOptions, ...options.agentOptions }
-                : defaultAgentOptions;
+            const runtimeAgentOptions = typeof options.agentOptions === "object" && options.agentOptions !== null
+                ? options.agentOptions
+                : {};
+            const commandAgentOptions = typeof compileOptions.agentOptions === "object" && compileOptions.agentOptions !== null
+                ? compileOptions.agentOptions
+                : {};
+            const agentOptions = Object.keys(commandAgentOptions).length > 0
+                ? { ...defaultAgentOptions, ...runtimeAgentOptions, ...commandAgentOptions }
+                : { ...defaultAgentOptions, ...runtimeAgentOptions };
             const source = typeof loadedSource === "function"
                 ? new loadedSource(agentOptions)
                 : loadedSource;
@@ -2245,7 +3064,7 @@ export function createPraxisApplicationRuntime(options) {
             if (!validation.ok) {
                 return { ok: false, code: "AGENT_MANIFEST_INVALID", message: validation.error.message };
             }
-            if (options.updateState ?? agentKey === "primary") {
+            if (compileOptions.updateState ?? agentKey === "primary") {
                 state.manifest = validation.manifest;
             }
             return { ok: true, manifest: validation.manifest };
@@ -2363,18 +3182,27 @@ export function createPraxisApplicationRuntime(options) {
                     allowProviderCall: (command.mode ?? state.mode) === "live",
                     allowToolExecution: false,
                     auth: liveProvider?.auth,
+                    runtimeAuthResolver: liveProvider?.runtimeAuthResolver,
+                    authSelection: liveProvider?.authSelection,
                     providerCaller: liveProvider?.providerCaller,
                     openaiResponsesCaller: liveProvider?.openaiResponsesCaller,
                     openaiChatCompletionsCaller: liveProvider?.openaiChatCompletionsCaller,
                     anthropicMessagesCaller: liveProvider?.anthropicMessagesCaller,
+                    geminiGenerateContentTransport: liveProvider?.geminiGenerateContentTransport,
                     exposeProviderTools: false,
                     approvalResolver: approvalResolverForRun(),
+                    agentReviewResolver: options.agentReviewResolver,
+                    baseToolAdapters: {
+                        agent: multiagentAgentAdapter(),
+                        ...(options.contextArtifactAdapters ?? {}),
+                        ...(options.baseToolAdapters ?? {}),
+                    },
                     storage: {
                         cwd: state.cwd,
                         workspaceRoot: path.join(project.projectRoot, ".raxode"),
                         initMode: "on-run",
                     },
-                    sandbox: { cwd: state.cwd },
+                    sandbox: { cwd: state.cwd, provider: options.sandboxProvider },
                     now,
                 }),
                 timeoutMs,
@@ -2480,12 +3308,13 @@ export function createPraxisApplicationRuntime(options) {
                 },
             });
         }
-        const taskText = buildTaskTextWithSessionHistory({
+        const taskText = buildCurrentTaskText({
             currentUserText: command.input.text,
-            history: preparedHistory.history,
-            summary: preparedHistory.summary,
             attachments: command.input.attachments,
         });
+        const conversationWindow = applicationHistoryToConversationWindow(preparedHistory.history);
+        const sessionSummary = applicationSummaryToPromptContextSummary(state.sessionId, preparedHistory.summary);
+        const turnEventStartIndex = state.events.length;
         publish({
             eventId: `${turnId}.submitted`,
             kind: "conversation",
@@ -2513,6 +3342,7 @@ export function createPraxisApplicationRuntime(options) {
             });
             return { ok: false, view: view(), events: [failed], error: state.error };
         }
+        await safeRefreshAuthState();
         publish({
             eventId: `${turnId}.manifest.ready`,
             kind: "runtime",
@@ -2603,6 +3433,9 @@ export function createPraxisApplicationRuntime(options) {
         }
         const runtime = praxis.runtime.createPraxisRuntimeKernel({ runtimeId: state.runtimeId });
         const emittedToolProgress = new Set();
+        const openAIResponsesRoute = openAIResponsesRouteFor(liveProvider);
+        const nativeAdapterAuth = liveProviderAuthSupplier(liveProvider);
+        const mountOpenAIResponsesNativeAdapters = openAIResponsesRoute !== undefined && liveProviderHasAuthSource(liveProvider);
         const result = await runtime.runManifest(compiled.manifest, taskText, {
             runtimeId: state.runtimeId,
             sessionId: state.sessionId,
@@ -2610,41 +3443,62 @@ export function createPraxisApplicationRuntime(options) {
             allowProviderCall: state.mode === "live",
             allowToolExecution: state.mode === "live",
             auth: liveProvider?.auth,
+            runtimeAuthResolver: liveProvider?.runtimeAuthResolver,
+            authSelection: liveProvider?.authSelection,
             providerCaller: liveProvider?.providerCaller,
             openaiResponsesCaller: liveProvider?.openaiResponsesCaller,
             openaiChatCompletionsCaller: liveProvider?.openaiChatCompletionsCaller,
             anthropicMessagesCaller: liveProvider?.anthropicMessagesCaller,
+            geminiGenerateContentTransport: liveProvider?.geminiGenerateContentTransport,
+            allowPreviousResponseId: false,
             previousProviderResponse: state.lastProviderResponseBySession.get(state.sessionId),
             exposeProviderTools: true,
             toolContextSelection: state.toolContextSelections.get(state.sessionId),
             toolContextUsage: state.toolContextUsage.get(state.sessionId),
+            conversationWindow,
+            sessionSummary,
+            compactExecutor: options.compactExecutor,
+            preCompactGovernanceExecutor: options.preCompactGovernanceExecutor,
+            preCompactGovernanceEnabled: options.preCompactGovernanceEnabled,
+            compactContextWindowTokens: options.compactContextWindowTokens,
+            compactThresholdRatio: options.compactThresholdRatio,
             approvalResolver: approvalResolverForRun(),
+            agentReviewResolver: options.agentReviewResolver,
+            mcpServers: applicationMcpServerProfiles(applicationMcpModule),
+            mcpModule: applicationMcpModule,
             storage: {
                 cwd: state.cwd,
                 workspaceRoot: path.join(project.projectRoot, ".raxode"),
                 initMode: "on-run",
             },
-            sandbox: { cwd: state.cwd },
-            baseToolAdapters: openAIResponsesCallerFor(liveProvider)
-                ? {
-                    network: {
-                        nativeWebSearch: createProviderNativeSearchAdapter({
-                            auth: liveProvider.auth,
-                            providerCaller: openAIResponsesCallerFor(liveProvider),
-                            runtimeId: state.runtimeId,
-                        }),
-                    },
-                    omni: {
-                        transformMedia: createOpenAIResponsesImageVisionAdapter({
-                            auth: liveProvider.auth,
-                            providerCaller: openAIResponsesCallerFor(liveProvider),
-                            runtimeId: state.runtimeId,
-                            model: state.model.model,
-                            attachments: command.input.attachments,
-                        }),
-                    },
-                }
-                : undefined,
+            sandbox: { cwd: state.cwd, provider: options.sandboxProvider },
+            baseToolAdapters: {
+                agent: multiagentAgentAdapter(),
+                ...(options.contextArtifactAdapters ?? {}),
+                ...(options.baseToolAdapters ?? {}),
+                ...(mountOpenAIResponsesNativeAdapters
+                    ? {
+                        network: {
+                            ...(options.baseToolAdapters?.network ?? {}),
+                            nativeWebSearch: createProviderNativeSearchAdapter({
+                                auth: nativeAdapterAuth,
+                                route: openAIResponsesRoute,
+                                runtimeId: state.runtimeId,
+                            }),
+                        },
+                        media: {
+                            ...(options.baseToolAdapters?.media ?? {}),
+                            transformMedia: createOpenAIResponsesImageVisionAdapter({
+                                auth: nativeAdapterAuth,
+                                route: openAIResponsesRoute,
+                                runtimeId: state.runtimeId,
+                                model: state.model.model,
+                                attachments: command.input.attachments,
+                            }),
+                        },
+                    }
+                    : {}),
+            },
             onModelCallProgress: (progress) => {
                 const comparedProgress = progressWithSessionCacheComparison(state, progress);
                 rememberProviderResponseForSession(state, comparedProgress);
@@ -2653,21 +3507,54 @@ export function createPraxisApplicationRuntime(options) {
                     turnId,
                     status: "running",
                     model: state.model,
+                    compressionLimitTokens: applicationCompressionLimitTokens({
+                        model: state.model,
+                        compactContextWindowTokens: options.compactContextWindowTokens,
+                        compactThresholdRatio: options.compactThresholdRatio,
+                    }),
+                    conversationContext: estimateConversationContext({
+                        messages: state.conversationHistory.get(state.sessionId) ?? preparedHistory.history,
+                        summary: state.conversationSummaries.get(state.sessionId) ?? preparedHistory.summary,
+                        model: state.model,
+                        compressionLimitTokens: applicationCompressionLimitTokens({
+                            model: state.model,
+                            compactContextWindowTokens: options.compactContextWindowTokens,
+                            compactThresholdRatio: options.compactThresholdRatio,
+                        }),
+                    }),
                 }));
             },
             onToolCallProgress: (progress) => {
                 emittedToolProgress.add(toolProgressKey(progress));
-                publish(createToolProgressEvent({
+                const event = publish(createToolProgressEvent({
                     progress,
                     turnId,
                     status: "running",
                 }));
+                void options.onApplicationToolEvent?.(event);
             },
             onTextDelta: emitTextDelta,
             now,
         });
         applyRunResult(state, result);
         rememberToolContextFromRun(state, result);
+        if (result.ok && result.toolCalls.length > 0) {
+            for (const toolCall of result.toolCalls) {
+                const phase = toolCall.ok ? "completed" : "failed";
+                const progress = { phase, record: toolCall };
+                if (emittedToolProgress.has(toolProgressKey(progress)))
+                    continue;
+                publish(createToolProgressEvent({
+                    progress,
+                    turnId,
+                    status: state.status,
+                }));
+            }
+        }
+        const turnLedgerMessages = applicationLedgerMessagesFromEvents({
+            events: state.events.slice(turnEventStartIndex),
+            turnId,
+        });
         const compactedHistory = compactConversationHistory({
             messages: [
                 ...preparedHistory.history,
@@ -2676,12 +3563,22 @@ export function createPraxisApplicationRuntime(options) {
                     text: command.input.text,
                     turnId,
                     createdAt: now(),
+                    messageId: `${turnId}.user`,
+                    metadata: {
+                        source: "application.ledger.user",
+                    },
                 },
+                ...turnLedgerMessages,
                 {
                     role: "assistant",
                     text: result.ok ? result.finalOutput : result.error.message,
                     turnId,
                     createdAt: now(),
+                    messageId: `${turnId}.assistant.final`,
+                    causedBy: turnLedgerMessages.length > 0 ? turnLedgerMessages.at(-1)?.messageId : `${turnId}.submitted`,
+                    metadata: {
+                        source: "application.ledger.assistantFinal",
+                    },
                     status: result.ok ? "completed" : "failed",
                 },
             ],
@@ -2695,19 +3592,6 @@ export function createPraxisApplicationRuntime(options) {
         else {
             state.conversationSummaries.delete(state.sessionId);
         }
-        if (result.ok && result.toolCalls.length > 0) {
-            for (const toolCall of result.toolCalls) {
-                const phase = toolCall.ok ? "completed" : "failed";
-                const progress = { phase, record: toolCall };
-                if (emittedToolProgress.has(toolProgressKey(progress)))
-                    continue;
-                publish(createToolProgressEvent({
-                    progress,
-                    turnId,
-                    status: state.status,
-                }));
-            }
-        }
         const done = publish({
             eventId: `${turnId}.${result.ok ? "completed" : "failed"}`,
             kind: result.ok ? "final" : "error",
@@ -2721,8 +3605,14 @@ export function createPraxisApplicationRuntime(options) {
             },
         });
         return result.ok
-            ? { ok: true, view: view(), events: [done] }
-            : { ok: false, view: view(), events: [done], error: state.error ?? { code: "RUNTIME_FAILED", message: "runtime failed" } };
+            ? { ok: true, view: view(), events: [done], output: { text: result.finalOutput } }
+            : {
+                ok: false,
+                view: view(),
+                events: [done],
+                output: { text: result.error.message },
+                error: state.error ?? { code: "RUNTIME_FAILED", message: "runtime failed" },
+            };
     }
     return {
         applicationId,
@@ -2733,6 +3623,10 @@ export function createPraxisApplicationRuntime(options) {
             return () => listeners.delete(listener);
         },
         async dispatch(command) {
+            if (command.type !== "application.createSession") {
+                applyCommandSession(commandSessionId(command));
+            }
+            await safeRefreshAuthState();
             switch (command.type) {
                 case "application.start": {
                     applyCommandSession(command.sessionId);
@@ -2752,6 +3646,7 @@ export function createPraxisApplicationRuntime(options) {
                         return { ok: false, view: view(), events: [failed], error: state.error };
                     }
                     state.status = "ready";
+                    await safeRefreshAuthState();
                     const ready = publish({
                         eventId: "application.ready",
                         kind: "lifecycle",
@@ -2807,6 +3702,7 @@ export function createPraxisApplicationRuntime(options) {
                             maxOutputTokens: command.maxOutputTokens ?? state.model.maxOutputTokens,
                         }),
                     };
+                    await safeRefreshAuthState();
                     const changed = publish({
                         eventId: "application.model.changed",
                         kind: "model",
@@ -2826,6 +3722,17 @@ export function createPraxisApplicationRuntime(options) {
                     });
                     return { ok: true, view: view(), events: [changed] };
                 }
+                case "application.changeToolProfile": {
+                    applyCommandSession(command.sessionId);
+                    state.toolProfile = command.profile;
+                    const changed = publish({
+                        eventId: "application.toolProfile.changed",
+                        kind: "tool",
+                        status: state.status,
+                        message: command.profile,
+                    });
+                    return { ok: true, view: view(), events: [changed] };
+                }
                 case "application.interrupt": {
                     applyCommandSession(command.sessionId);
                     state.status = "ready";
@@ -2863,6 +3770,15 @@ export function createPraxisApplicationRuntime(options) {
                         lastActiveAt: now(),
                         turns: state.turns,
                     });
+                    if (state.foundationProject !== undefined) {
+                        await praxis.runtime.session.createPraxisSessionManager(state.foundationProject).create({
+                            sessionId: state.sessionId,
+                            title: command.name,
+                            now: now(),
+                            metadata: { source: "application.createSession" },
+                        });
+                    }
+                    await safeRefreshAuthState();
                     const created = publish({
                         eventId: "application.session.created",
                         kind: "lifecycle",
@@ -2966,6 +3882,7 @@ export function createPraxisApplicationRuntime(options) {
                 case "application.close": {
                     applyCommandSession(command.sessionId);
                     state.status = "closed";
+                    await state.foundationProject?.release();
                     const closed = publish({
                         eventId: "application.closed",
                         kind: "lifecycle",
@@ -2982,11 +3899,34 @@ export async function createApplicationProjectRuntime(projectRoot, options = {})
     const loaded = await loadApplicationProject(projectRoot);
     if (!loaded.ok)
         return loaded;
+    const foundationProject = options.foundationProject ?? (options.openFoundationProject === true
+        ? (await praxis.runtime.project.open({
+            cwd: loaded.project.projectRoot,
+            kind: "chat",
+            mode: "open-or-create",
+            runtimeId: options.runtimeId,
+            ownerId: options.applicationId ?? loaded.project.applicationId,
+        }))
+        : undefined);
+    if (foundationProject !== undefined && !("kind" in foundationProject)) {
+        if (!foundationProject.ok) {
+            return {
+                ok: false,
+                error: foundationProject.error,
+            };
+        }
+    }
     return {
         ok: true,
         runtime: createPraxisApplicationRuntime({
             ...options,
             project: loaded.project,
+            cwd: options.cwd ?? loaded.project.projectRoot,
+            foundationProject: foundationProject === undefined
+                ? undefined
+                : "kind" in foundationProject
+                    ? foundationProject
+                    : foundationProject.runtime,
         }),
     };
 }