@praxis-ai/praxis 0.1.0 → 0.1.2

package/dist/agentCore/agent_runtimeImplementation/praxisRuntimeKernel.js

@@ -1,4146 +0,0 @@
-/*
- * 文件定位：Agent 运行态实现层 / PraxisRuntimeKernel。
- * 核心目的：执行已编译 AgentManifest，把 text IO、codex responses、BaseTool mount 和 session/event 记录串成第一条可用 agent 链。
- * 能力要求1：runtime 执行 manifest，不直接执行 Agent class 内部逻辑，run(agent) 只作为 compile 后的语法糖。
- * 能力要求2：支持 codex_responses 模型调用、一次工具调用回填、BaseToolExecutorPort 注入和最小 session/state/event 记录。
- * 边界：不设计 promptPack 终局语义，不加厚 mainLoop/coreLogic 动作原语，不吞并 baseTool storage 语义。
- * 对接：需要服务 OAO compile、runtime.modelAdapter、runtime.execEngine、IOTransceiver 和后续 inspection/debug。
- * 实现提示：先提供可测试纵向闭环，再由用户监督 promptPack 与 mainLoop/coreLogic 的正式设计。
- */
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { mkdir, stat } from "node:fs/promises";
-import path from "node:path";
-import { isDeepSeekV4Model, mapDeepSeekV4ReasoningEffort, } from "../agent_modelAdapter/providerAccessLayer/modelMetadataRegistry.js";
-import { createProviderToolMappings, lowerProviderToolResult, lowerPraxisToolsForProvider, providerToolName, } from "../agent_modelAdapter/bridgingLayer/toolSchemaCompatibilityLayer.js";
-import { receiveTextInput } from "../agent_executionEngine/IOTransceiver/inputReceiver/textReceiver.js";
-import { exposeTextOutput } from "../agent_executionEngine/IOTransceiver/outputExposer/textExposer.js";
-import { createMainLoopStepRecord, decideMainLoopFinalAcceptance, planFrameworkMainLoopHandoff, runMainLoop, runMainLoopRunner, } from "../agent_executionEngine/coreLogic/mainLoop.js";
-import { interpretModelDecision, } from "../agent_executionEngine/coreLogic/modelDecision.js";
-import { createObservationMaterial, DEFAULT_OBSERVATION_TURN_INLINE_BUDGET_BYTES, } from "../agent_executionEngine/coreLogic/observationIntegrator.js";
-import { createRuntimeBaseToolExecutorPort, listRuntimeBaseToolImplementedPortPaths, } from "./runtime.execEngine/baseToolExecutorPortFactory.js";
-import { evaluateBaseToolRuntimeGovernance } from "./runtime.execEngine/baseToolRuntimeGovernance.js";
-import { preflightBaseToolDependencies, } from "./runtime.execEngine/baseToolDependencyRuntime.js";
-import { applyBaseToolContextUsage, createBaseToolContextHeatState, createBaseToolContextTree, } from "./runtime.execEngine/baseToolContextFolding.js";
-import { invokeMountedBaseTool } from "./runtime.execEngine/baseToolRuntimeMount.js";
-import { evaluateBaseToolRuntimeReadiness } from "./runtime.execEngine/baseToolSupportCatalog.js";
-import { invokeModelThroughRuntime } from "./runtime.modelAdapter/modelInvocationRuntime.js";
-import { lowerPromptForModelAdapter, } from "./runtime.modelAdapter/promptLoweringRuntime.js";
-import { compileAgent, } from "./runtimeAgentManifest.js";
-import { approvalInterfaceEnvelope, } from "../agent_interfaceAdapter/interfaceEnvelope.js";
-import { createInMemorySessionStateEventStore, createSqliteSessionStateEventStore, } from "./runtimeSessionStateEventStore.js";
-import { applyRaxStorageInitPlan, createStoragePlaneRuntime, } from "./runtime.storagePlane/storagePlaneRuntime.js";
-import { prepareSandboxRuntime, } from "./runtime.sandboxPlane/sandboxRuntimeProvider.js";
-import { describeShellWorkspaceWrite, shellWorkspaceWriteGuardMessage, } from "../../storagePool/baseToolStorage/shellBase/_shared/workspaceWriteGuard.js";
-async function inferFilesystemActionForTool(input) {
-    if (input.toolId === "code.delete")
-        return "delete";
-    if (!["code.overwrite", "code.replaceFile", "code.modify", "code.format"].includes(input.toolId))
-        return undefined;
-    const rawPath = input.args.targetPath ?? input.args.path;
-    if (typeof rawPath !== "string" || rawPath.trim() === "" || input.workspaceRoot === undefined) {
-        return ["code.overwrite", "code.replaceFile"].includes(input.toolId) ? "overwrite" : "modify";
-    }
-    const normalized = rawPath.trim();
-    const absoluteTarget = path.isAbsolute(normalized) ? normalized : path.resolve(input.workspaceRoot, normalized);
-    const relative = path.relative(input.workspaceRoot, absoluteTarget);
-    if (relative.startsWith("..") || path.isAbsolute(relative))
-        return "out-of-scope";
-    try {
-        await stat(absoluteTarget);
-        return ["code.overwrite", "code.replaceFile"].includes(input.toolId) ? "overwrite" : "modify";
-    }
-    catch (error) {
-        if (typeof error === "object" && error !== null && error.code === "ENOENT")
-            return "create";
-        return undefined;
-    }
-}
-function hasText(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function defaultNow() {
-    return new Date().toISOString();
-}
-function runtimeIdFor(manifest) {
-    return `runtime:${manifest.identity.id}`;
-}
-function sessionIdFor(runtimeId, manifest) {
-    return `${runtimeId}:session:${manifest.manifestHash.slice(0, 12)}`;
-}
-function event(sessionId, eventId, type, createdAt, payload = {}) {
-    return { sessionId, eventId, type, createdAt, payload };
-}
-function state(sessionId, stateId, phase, createdAt, metadata = {}) {
-    return { sessionId, stateId, phase, createdAt, metadata };
-}
-function storageSessionMetadata(storageRuntime, sessionSqlitePath) {
-    return {
-        kind: storageRuntime.kind,
-        protocolVersion: storageRuntime.layout.protocolVersion,
-        initMode: storageRuntime.initMode,
-        homeRef: storageRuntime.layout.refs.homeRef,
-        workspaceRef: storageRuntime.layout.refs.workspaceRef,
-        sessionStoreRef: storageRuntime.layout.refs.sessionStoreRef,
-        artifactRootRef: storageRuntime.layout.refs.artifactRootRef,
-        cacheRootRef: storageRuntime.layout.refs.cacheRootRef,
-        sandboxRootRef: storageRuntime.layout.refs.sandboxRootRef,
-        homeRoot: storageRuntime.layout.home.root,
-        workspaceRoot: storageRuntime.layout.workspace.root,
-        sessionSqlitePath,
-        writesSecrets: storageRuntime.initPlan.writesSecrets,
-    };
-}
-function invocation(sessionId, invocationId, kind, target, ok, createdAt, summary = {}) {
-    return { sessionId, invocationId, kind, target, ok, createdAt, summary };
-}
-function readString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function readPositiveInteger(value) {
-    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
-}
-function readStringArray(value) {
-    if (!Array.isArray(value))
-        return [];
-    const values = [];
-    for (const item of value) {
-        const text = readString(item);
-        if (text !== undefined && !values.includes(text))
-            values.push(text);
-    }
-    return values;
-}
-function procedureShellStepCommandSource(step) {
-    if (!step.baseToolId.startsWith("shell."))
-        return undefined;
-    const target = isRecord(step.input.target) ? step.input.target : {};
-    const command = readString(step.input.command)
-        ?? readString(target.command)
-        ?? readString(step.input.script)
-        ?? readString(target.script);
-    const args = [
-        ...readStringArray(step.input.args),
-        ...readStringArray(target.args),
-    ];
-    if (command !== undefined) {
-        return [command, ...args].join(" ");
-    }
-    try {
-        return JSON.stringify(step.input);
-    }
-    catch {
-        return undefined;
-    }
-}
-function procedureShellWorkspaceWriteViolation(plan) {
-    for (const step of plan.steps) {
-        const source = procedureShellStepCommandSource(step);
-        if (source === undefined)
-            continue;
-        const reason = describeShellWorkspaceWrite(source);
-        if (reason === undefined)
-            continue;
-        return {
-            step,
-            reason,
-            message: `EphemeralProcedure step ${step.stepId} uses ${step.baseToolId} to write workspace files. ${shellWorkspaceWriteGuardMessage(reason)}`,
-        };
-    }
-    return undefined;
-}
-function mergeStringLists(...lists) {
-    const merged = [];
-    for (const list of lists) {
-        if (list === undefined)
-            continue;
-        for (const item of list) {
-            const text = readString(item);
-            if (text !== undefined && !merged.includes(text))
-                merged.push(text);
-        }
-    }
-    return merged;
-}
-function omniProviderPermissionsCanDefault(profile) {
-    return profile === "bapr" || profile === "yolo" || profile === "permissive";
-}
-function runtimeTapApprovalCanDefault(profile) {
-    return profile === "bapr" || profile === "yolo" || profile === "permissive";
-}
-const shellRuntimeBasePermissions = ["shell:execute", "shell:observe", "shell:validate"];
-const shellRuntimePermissionHintsByToolId = {
-    "shell.argumentAssembly": ["shell:generate"],
-    "shell.backgroundExecution": ["shell:process:background"],
-    "shell.capabilityDetection": ["shell:detect"],
-    "shell.commandGeneration": ["shell:generate"],
-    "shell.detachedExecution": ["shell:process:detached"],
-    "shell.environmentInspection": ["shell:environment:inspect"],
-    "shell.executionGuard": ["shell:generate"],
-    "shell.executionMonitoring": ["shell:execution:monitor"],
-    "shell.interactiveControl": ["shell:interactive:control"],
-    "shell.invocationConstruction": ["shell:generate"],
-    "shell.outputCapture": ["shell:output:capture"],
-    "shell.processTermination": ["shell:process:terminate"],
-    "shell.promptHandling": ["shell:prompt:handle"],
-    "shell.sandboxEnforcement": ["shell:sandbox"],
-    "shell.scriptGeneration": ["shell:script:generate"],
-    "shell.sessionDetection": ["shell:session:detect", "shell:process:read"],
-    "shell.shellLifecycleManagement": ["shell:lifecycle:manage"],
-    "shell.shellProcessManagement": ["shell:process:manage"],
-    "shell.shellResourceManagement": [
-        "shell:resource:inspect",
-        "shell:resource:reserve",
-        "shell:resource:release",
-        "shell:resource:limit",
-    ],
-    "shell.shellSessionManagement": [
-        "shell:session:inspect",
-        "shell:session:create",
-        "shell:session:attach",
-        "shell:session:close",
-    ],
-    "shell.stdinFeeding": ["shell:stdin:feed"],
-    "shell.typeDetection": ["shell:detect"],
-};
-function approvedRuntimeTapApproval(input) {
-    if (input.force !== true && !runtimeTapApprovalCanDefault(input.profile))
-        return undefined;
-    const rawApproval = isRecord(input.rawApproval) ? input.rawApproval : {};
-    return {
-        ...rawApproval,
-        accepted: true,
-        approvalId: readString(rawApproval.approvalId) ?? `runtime-profile-${input.profile}`,
-        reason: readString(rawApproval.reason) ?? input.reason,
-    };
-}
-function runtimeGrantedPermissionsForTool(toolId, profile) {
-    if (toolId.startsWith("git."))
-        return ["git:read", "filesystem:read"];
-    if (toolId.startsWith("code."))
-        return ["filesystem:read", "filesystem:write"];
-    if (toolId.startsWith("skill."))
-        return ["skill:read", "skill:write", "filesystem:read", "filesystem:write"];
-    if (toolId.startsWith("search."))
-        return ["network:read", "search:fetch", "network:egress", "network:search", "search:native"];
-    if (toolId.startsWith("shell."))
-        return mergeStringLists(shellRuntimeBasePermissions, shellRuntimePermissionHintsByToolId[toolId]);
-    if (toolId.startsWith("mcp.")) {
-        return [
-            "mcp:connect",
-            "mcp:auth",
-            "mcp:read",
-            "mcp:write",
-            "mcp:cache:invalidate",
-            "mcp:disconnect",
-            "mcp:subscription:write",
-            "mcp:call",
-            "mcp:service",
-            "mcp:stream",
-            "mcp:cancel",
-            "mcp:control",
-            "mcp:native-execute",
-            "mcp:raw",
-            "mcp:tool:read",
-            "mcp:tool:write",
-            "mcp:connection:read",
-            "mcp:resource:list",
-            "mcp:resource:read",
-            "mcp:resource:create",
-            "mcp:resource:write",
-            "mcp:resource:delete",
-            "mcp:ping",
-            "mcp:monitor:read",
-        ];
-    }
-    if (toolId === "omni.viewImage")
-        return ["filesystem:read", "omni:image:view"];
-    if (toolId.startsWith("omni.")) {
-        const basePermissions = ["filesystem:read", "filesystem:write", "omni:media:transform"];
-        if (!omniProviderPermissionsCanDefault(profile))
-            return basePermissions;
-        return [
-            ...basePermissions,
-            "provider:invoke",
-            "omni:image:read",
-            "omni:image:write",
-            "omni:image:generate",
-            "omni:audio:read",
-            "omni:audio:write",
-            "omni:audio:generate",
-            "omni:video:read",
-            "omni:video:write",
-            "omni:video:generate",
-        ];
-    }
-    if (toolId.startsWith("computeruse."))
-        return ["computeruse:read", "computeruse:device:read", "computeruse:screenshot"];
-    return ["tool.execute"];
-}
-function safeRuntimePathSegment(value) {
-    return value.replace(/[^a-zA-Z0-9_.-]/gu, "_").slice(0, 96) || "runtime";
-}
-function imageExtensionFromTarget(target) {
-    const declared = readString(target.outputFormat)
-        ?? readString(target.targetFormat)
-        ?? readString(target.format)
-        ?? readString(target.mimeType);
-    if (declared === "image/jpeg" || declared === "jpeg" || declared === "jpg")
-        return "jpg";
-    if (declared === "image/webp" || declared === "webp")
-        return "webp";
-    return "png";
-}
-function autoOutputTargetForTool(input) {
-    if (input.toolId !== "omni.generateImage")
-        return input.target;
-    if (readString(input.target.outputPath) !== undefined || readString(input.target.outputRef) !== undefined) {
-        return input.target;
-    }
-    if (input.workspaceRoot === undefined)
-        return input.target;
-    const extension = imageExtensionFromTarget(input.target);
-    return {
-        ...input.target,
-        outputPath: path.join(input.workspaceRoot, ".rax_workspace", "artifacts", safeRuntimePathSegment(input.sessionId), `generated-image-${safeRuntimePathSegment(input.invocationId)}.${extension}`),
-    };
-}
-function grantedPermissionsForTool(toolId, rawPermissions, profile) {
-    const merged = mergeStringLists(readStringArray(rawPermissions), runtimeGrantedPermissionsForTool(toolId, profile));
-    if (toolId === "omni.viewImage") {
-        return merged.filter((permission) => permission === "filesystem:read" || permission === "omni:image:view");
-    }
-    return merged;
-}
-function withApprovedRuntimePermissions(toolId, args) {
-    const rawContext = isRecord(args.context) ? args.context : {};
-    const approvedPermissions = runtimeGrantedPermissionsForTool(toolId, "bapr");
-    const approval = approvedRuntimeTapApproval({
-        rawApproval: rawContext.approval,
-        profile: "bapr",
-        force: true,
-        reason: "runtime approval was granted by the application approval surface",
-    });
-    return {
-        ...args,
-        context: {
-            ...rawContext,
-            grantedPermissions: mergeStringLists(readStringArray(rawContext.grantedPermissions), approvedPermissions),
-            guard: isRecord(rawContext.guard)
-                ? { accepted: true, allowed: true, ...rawContext.guard }
-                : { accepted: true, allowed: true },
-            governance: isRecord(rawContext.governance)
-                ? { accepted: true, allowed: true, ...rawContext.governance }
-                : { accepted: true, allowed: true },
-            contract: isRecord(rawContext.contract)
-                ? { accepted: true, allowed: true, ...rawContext.contract }
-                : { accepted: true, allowed: true },
-            ...(approval === undefined ? {} : { approval }),
-        },
-    };
-}
-function defaultMcpServerId(toolId, args) {
-    if (!toolId.startsWith("mcp."))
-        return undefined;
-    return readString(args.serverId) ?? "local-mcp";
-}
-function providerToolMappings(manifest) {
-    return createProviderToolMappings(manifest.harness.tools);
-}
-function providerToolSchemaFamilyForModel(model) {
-    if (model.provider === "anthropic" || model.endpointShape === "messages")
-        return "anthropicMessages";
-    if (model.endpointShape === "chat_completions")
-        return "openaiChatCompletions";
-    return "openaiResponses";
-}
-function providerRouteForModel(model) {
-    const route = model.metadata?.providerRoute;
-    return typeof route === "string" && route.trim().length > 0 ? route.trim() : undefined;
-}
-function modelInvocationCapabilityForModel(model) {
-    if (model.provider === "anthropic" || model.endpointShape === "messages") {
-        return { capabilityId: "anthropic-messages", kind: "messages" };
-    }
-    if (model.endpointShape === "chat_completions") {
-        return { capabilityId: "openai-chat-completions", kind: "chat_completions" };
-    }
-    if (providerRouteForModel(model) === "openai_responses" || model.credentialRef?.credentialType === "openai_api_key") {
-        return { capabilityId: "openai-responses", kind: "responses" };
-    }
-    return { capabilityId: "codex-responses", kind: "responses" };
-}
-function enrichToolArguments(manifest, toolId, args, runtimeContext) {
-    const rawContext = isRecord(args.context) ? args.context : {};
-    const workspaceRoot = readString(args.workspaceRoot) ?? manifest.harness.policy.workspaceRoot ?? runtimeContext.workspaceRoot;
-    const allowedRoots = Array.isArray(args.allowedRoots)
-        ? args.allowedRoots
-        : manifest.harness.policy.allowedRoots ?? runtimeContext.allowedRoots;
-    const grantedPermissions = grantedPermissionsForTool(toolId, rawContext.grantedPermissions, manifest.toolPolicy.profile);
-    const requestedScopes = mergeStringLists(readStringArray(rawContext.requestedScopes), ["tool.execute", `tool.${toolId}`]);
-    const allowedScopes = mergeStringLists(readStringArray(rawContext.allowedScopes), manifest.harness.policy.scopes, ["tool.execute", `tool.${toolId}`, toolId]);
-    const allowedRepositoryRoots = Array.isArray(rawContext.allowedRepositoryRoots)
-        ? rawContext.allowedRepositoryRoots
-        : [workspaceRoot, ...(allowedRoots ?? [])].filter((root) => typeof root === "string" && root.trim().length > 0);
-    const defaultServerId = defaultMcpServerId(toolId, args);
-    const allowedServerIds = mergeStringLists(readStringArray(rawContext.allowedServerIds), defaultServerId === undefined ? undefined : [defaultServerId]);
-    const approval = approvedRuntimeTapApproval({
-        rawApproval: rawContext.approval,
-        profile: manifest.toolPolicy.profile,
-        reason: `${manifest.toolPolicy.profile} profile auto-approves runtime TAP approval fields`,
-    });
-    const rawTarget = isRecord(args.target) ? args.target : {};
-    let target = rawTarget;
-    if (toolId.startsWith("git.") && workspaceRoot !== undefined) {
-        const rawRepositoryPath = readString(rawTarget.repositoryPath);
-        const repositoryPath = rawRepositoryPath === undefined
-            ? workspaceRoot
-            : path.isAbsolute(rawRepositoryPath)
-                ? rawRepositoryPath
-                : path.resolve(workspaceRoot, rawRepositoryPath);
-        target = { ...rawTarget, repositoryPath };
-    }
-    target = autoOutputTargetForTool({
-        toolId,
-        target,
-        workspaceRoot,
-        sessionId: runtimeContext.sessionId,
-        invocationId: runtimeContext.invocationId,
-    });
-    if (defaultServerId !== undefined) {
-        target = { serverId: defaultServerId, ...target };
-    }
-    return {
-        ...args,
-        ...(Object.keys(target).length === 0 ? {} : { target }),
-        ...(args.dryRun === undefined ? { dryRun: false } : {}),
-        ...(workspaceRoot === undefined ? {} : { workspaceRoot }),
-        context: {
-            ...rawContext,
-            runtimeId: readString(rawContext.runtimeId) ?? runtimeContext.runtimeId,
-            sessionId: readString(rawContext.sessionId) ?? runtimeContext.sessionId,
-            invocationId: readString(rawContext.invocationId) ?? runtimeContext.invocationId,
-            dryRun: rawContext.dryRun ?? args.dryRun ?? false,
-            guard: isRecord(rawContext.guard)
-                ? { accepted: true, allowed: true, ...rawContext.guard }
-                : { accepted: true, allowed: true },
-            governance: isRecord(rawContext.governance)
-                ? { accepted: true, allowed: true, ...rawContext.governance }
-                : { accepted: true, allowed: true },
-            contract: isRecord(rawContext.contract)
-                ? { accepted: true, allowed: true, ...rawContext.contract }
-                : { accepted: true, allowed: true },
-            ...(approval === undefined ? {} : { approval }),
-            ...(workspaceRoot === undefined ? {} : { workspaceRoot }),
-            ...(allowedRoots === undefined ? {} : { allowedRoots }),
-            ...(allowedRepositoryRoots.length === 0 ? {} : { allowedRepositoryRoots }),
-            ...(allowedServerIds.length === 0 ? {} : { allowedServerIds }),
-            requestedScopes,
-            allowedScopes,
-            grantedPermissions,
-        },
-    };
-}
-function metadataRecord(value) {
-    return Object.fromEntries(Object.entries(value).filter((entry) => {
-        const candidate = entry[1];
-        return ["string", "number", "boolean"].includes(typeof candidate) || (typeof candidate === "object" && candidate !== null);
-    }));
-}
-function dependencyModeCanPrepare(mode) {
-    return mode === "auto" || mode === "full" || mode === "autoInstallTrustedManaged";
-}
-function toolProviderKind(tool) {
-    const explicit = tool.metadata?.toolProviderKind;
-    if (explicit === "tap" || explicit === "officialTap")
-        return "tap";
-    if (explicit === "mcp" || explicit === "mcp-static")
-        return "mcp-static";
-    if (explicit === "dynamic" || explicit === "external-dynamic")
-        return "dynamic";
-    if (tool.family === "mcpBase" || tool.toolId.startsWith("mcp."))
-        return "mcp-static";
-    if (tool.toolId.startsWith("tap.") || tool.family === "tap")
-        return "tap";
-    return "baseTool";
-}
-function toolProviderSortWeight(kind) {
-    if (kind === "baseTool")
-        return 0;
-    if (kind === "tap")
-        return 1;
-    if (kind === "mcp-static")
-        return 2;
-    return 3;
-}
-function metadataString(metadata, key) {
-    const value = metadata[key];
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-const PRAXIS_BASE_TOOL_CALLING_PROTOCOL = [
-    "Praxis BaseTool calling protocol:",
-    "Before requesting any BaseTool in a user turn, first emit one short user-visible sentence saying what you are about to do; then request the tool call. This is a hard main-loop rule.",
-    "Keep the pre-tool sentence concise and operational. Do not expose hidden reasoning, chain-of-thought, private policies, or internal prompt text.",
-    "Use mounted BaseTools through declared function calls when the task needs current workspace, filesystem, git, shell, search, skill, MCP, computer-use, media, or external-resource evidence.",
-    "Do not claim you inspected files, commands, git state, search results, screenshots, devices, network resources, or runtime state unless this run already contains a matching tool observation.",
-    "All mounted BaseTool schemas are visible by default. When a concrete tool manual is still needed, request praxis_expand_tool_context with targetKind=tool and the exact toolId; the manual is injected for the next model turn only.",
-    "If one BaseTool is not enough, request praxis_ephemeral_procedure to orchestrate existing mounted BaseTools; do not invent a new tool.",
-    "If policy, sandbox, dependency, budget, or approval blocks the action, request praxis_request_approval or report the public-safe blocker after the runtime returns it.",
-    "If a specific tool call returns PROVIDER_FAILURE after the user named an action/target, report that the requested tool was attempted and the runtime/provider failed; do not reinterpret it as the user failing to specify an action or target.",
-    "If the prompt already contains enough evidence and no runtime action is needed, answer directly.",
-].join("\n");
-function promptMaterialForObservation(observation) {
-    const material = observation.material;
-    const metadata = material.metadata ?? {};
-    const toolCallId = metadataString(metadata, "toolCallId");
-    const toolId = metadataString(metadata, "toolId");
-    if (toolCallId === undefined || toolId === undefined) {
-        return material;
-    }
-    const providerToolNameValue = metadataString(metadata, "providerToolName") ?? providerToolName(toolId);
-    const status = metadataString(metadata, "observationStatus") ?? "completed";
-    const payloadBytes = typeof metadata.payloadBytes === "number" ? metadata.payloadBytes : undefined;
-    const artifactUri = metadataString(metadata, "artifactUri");
-    const artifactPath = metadataString(metadata, "artifactPath");
-    const text = [
-        `${material.text.split("\n", 1)[0] ?? `Tool observation ${toolCallId}`}`,
-        `nativeToolResult: call_id=${toolCallId} toolId=${toolId} providerToolName=${providerToolNameValue} status=${status}`,
-        payloadBytes === undefined ? "" : `payloadBytes: ${payloadBytes}`,
-        artifactUri === undefined ? "" : `payloadArtifact: ${artifactUri}`,
-        artifactPath === undefined ? "" : `payloadArtifactPath: ${artifactPath}`,
-        "payloadDelivery: full tool result is supplied separately as provider-native function_call_output; this PromptPack item is only an index.",
-        "reuseRule: use the native tool result already in this model input; do not call the same tool again unless a new missing fact is explicitly required.",
-    ].filter(Boolean).join("\n");
-    return {
-        ...material,
-        id: `${material.id ?? observation.observationId}:prompt-index`,
-        text,
-        metadata: {
-            ...metadata,
-            providerNativeToolResult: true,
-            originalObservationId: observation.observationId,
-            promptPayloadMode: "native-tool-result-index",
-        },
-    };
-}
-function promptMaterialsForTurn(input) {
-    const manifestPromptMaterials = promptPackMaterialsForManifest(input.manifest);
-    const observationUsage = input.observations
-        .map((observation) => {
-        const toolId = typeof observation.material.metadata?.toolId === "string"
-            ? observation.material.metadata.toolId
-            : undefined;
-        return toolId === undefined ? undefined : { toolId };
-    })
-        .filter((usage) => usage !== undefined);
-    const toolContext = createBaseToolContextTree(input.manifest.harness.tools, {
-        mode: "intelligent",
-        manual: input.toolContextSelection,
-        usage: input.toolContextUsage ?? observationUsage,
-        keepExpandedScore: 15,
-    });
-    const toolMaterials = toolContext.materials.map((materialDraft, index) => {
-        const toolId = typeof materialDraft.metadata?.toolId === "string" ? materialDraft.metadata.toolId : undefined;
-        const providerName = toolId === undefined
-            ? undefined
-            : input.toolMappings.find((mapping) => mapping.toolId === toolId)?.providerName ?? providerToolName(toolId);
-        const providerKind = toolId === undefined
-            ? undefined
-            : toolProviderKind(input.manifest.harness.tools.find((tool) => tool.toolId === toolId) ?? { toolId });
-        return {
-            ...materialDraft,
-            priority: materialDraft.priority ?? 80 - index,
-            metadata: {
-                ...(materialDraft.metadata ?? {}),
-                ...(providerKind === undefined ? {} : { toolProviderKind: providerKind }),
-                ...(providerName === undefined ? {} : { toolName: providerName }),
-            },
-        };
-    });
-    const observationMaterials = input.observations.map((observation) => promptMaterialForObservation(observation));
-    const observationAnswerGuard = input.observations.length === 0
-        ? []
-        : [{
-                id: `runtime:observation-answer-guard:${input.turnIndex}`,
-                kind: "command-injection",
-                text: [
-                    "Runtime already contains tool observations from earlier turns in this same agent run.",
-                    "Use those observations to answer the user now.",
-                    "Do not repeat a tool call that already produced the requested evidence unless a new missing fact is explicitly required.",
-                    "If the available observation is enough, return final text instead of another tool call.",
-                ].join("\n"),
-                source: "runtime.observationAnswerGuard",
-                priority: 101,
-                trusted: true,
-                scope: "runtime.mainLoop",
-                promptSegmentKind: "userTurn",
-                metadata: {
-                    promptSegmentKind: "userTurn",
-                    turnIndex: input.turnIndex,
-                    observationCount: input.observations.length,
-                },
-            }];
-    return [
-        ...manifestPromptMaterials,
-        {
-            id: `task:${input.turnIndex}`,
-            kind: "user",
-            text: input.task,
-            source: "runtime.input.text",
-            priority: 100,
-            trusted: false,
-            scope: "user.task",
-            promptSegmentKind: "userTurn",
-            metadata: { turnIndex: input.turnIndex },
-        },
-        {
-            id: "runtime:base-tool-protocol",
-            kind: "runtime",
-            text: PRAXIS_BASE_TOOL_CALLING_PROTOCOL,
-            source: "runtime.baseToolCallingProtocol",
-            priority: 95,
-            trusted: true,
-            scope: "runtime.toolCalling",
-            promptSegmentKind: "stableSystemCore",
-            metadata: {
-                promptSegmentKind: "stableSystemCore",
-                mountedToolCount: input.manifest.harness.tools.length,
-            },
-        },
-        {
-            id: `runtime:${input.turnIndex}`,
-            kind: "runtime",
-            text: [
-                `turnIndex=${input.turnIndex}`,
-                `runtime mounted BaseTools=${input.manifest.harness.tools.map((tool) => tool.toolId).join(", ") || "none"}`,
-                `baseTool context mode=${toolContext.mode}`,
-                `baseTool context expanded=${toolContext.expandedNodeIds.join(", ") || "none"}`,
-                `recent events=${input.events.slice(-8).join(", ") || "none"}`,
-            ].join("\n"),
-            source: "runtime.stateProjection",
-            priority: 60,
-            trusted: true,
-            scope: "runtime.state",
-            metadata: {
-                promptSegmentKind: "observations",
-                turnIndex: input.turnIndex,
-                maxModelTurns: input.manifest.harness.loop.maxModelTurns ?? 2,
-                maxToolCalls: input.manifest.harness.loop.maxToolCalls ?? 4,
-            },
-        },
-        ...toolMaterials,
-        ...observationMaterials,
-        ...observationAnswerGuard,
-    ];
-}
-function promptMaterialSourceText(material, fallbackRef) {
-    if (material.kind === "markdown")
-        return material.text;
-    if (material.kind === "materialRef")
-        return `Prompt material reference declared as ${material.ref || fallbackRef}.`;
-    try {
-        return readFileSync(path.resolve(material.path), "utf8");
-    }
-    catch {
-        return `Prompt markdown file declared at ${material.path}.`;
-    }
-}
-function promptMaterialSourceRef(material, fallbackRef) {
-    if (material.kind === "markdown")
-        return material.ref || fallbackRef;
-    if (material.kind === "markdownFile")
-        return material.ref || material.path;
-    return material.ref || fallbackRef;
-}
-function promptPackMaterialsForManifest(manifest) {
-    const materials = [];
-    const promptPack = manifest.promptPack;
-    if (promptPack.base !== undefined) {
-        materials.push({
-            id: promptMaterialSourceRef(promptPack.base, `${promptPack.promptPackId}:base`),
-            kind: "system",
-            text: promptMaterialSourceText(promptPack.base, `${promptPack.promptPackId}:base`),
-            source: "manifest.promptPack.base",
-            priority: 900,
-            trusted: true,
-            scope: "manifest.promptPack",
-            promptSegmentKind: "stableSystemCore",
-            metadata: {
-                promptPackId: promptPack.promptPackId,
-                promptRole: "base",
-            },
-        });
-    }
-    for (const [index, inherited] of promptPack.inherits.entries()) {
-        materials.push({
-            id: `promptPack.inherits:${inherited}`,
-            kind: "runtime",
-            text: `PromptPack inherits ${inherited}.`,
-            source: "manifest.promptPack.inherits",
-            priority: 880 - index,
-            trusted: true,
-            scope: "manifest.promptPack",
-            promptSegmentKind: "projectContext",
-            metadata: {
-                promptPackId: promptPack.promptPackId,
-                promptRole: "inherit",
-            },
-        });
-    }
-    for (const [index, patch] of [...promptPack.patches, ...promptPack.stateMachineMutations].entries()) {
-        materials.push({
-            id: patch.patchId,
-            kind: "system",
-            text: promptMaterialSourceText(patch.material, patch.patchId),
-            source: `manifest.promptPack.${patch.operation}`,
-            priority: 870 - index,
-            trusted: true,
-            scope: "manifest.promptPack.patch",
-            promptSegmentKind: "declaredRuntimeContext",
-            metadata: {
-                promptPackId: promptPack.promptPackId,
-                promptRole: "patch",
-                patchId: patch.patchId,
-                operation: patch.operation,
-                targetRef: patch.targetRef,
-                sceneTrigger: patch.sceneTrigger ?? "",
-            },
-        });
-    }
-    for (const [index, materialRef] of promptPack.materials.entries()) {
-        materials.push({
-            id: `promptPack.material:${materialRef}`,
-            kind: "runtime",
-            text: `PromptPack material reference ${materialRef}.`,
-            source: "manifest.promptPack.materials",
-            priority: 830 - index,
-            trusted: true,
-            scope: "manifest.promptPack.materials",
-            promptSegmentKind: "projectContext",
-            metadata: {
-                promptPackId: promptPack.promptPackId,
-                promptRole: "materialRef",
-            },
-        });
-    }
-    return materials;
-}
-function observationPayloadText(observation) {
-    if (observation.artifactRef !== undefined) {
-        return observation.material.text;
-    }
-    if (typeof observation.payload === "string")
-        return observation.payload;
-    try {
-        return JSON.stringify(observation.payload);
-    }
-    catch {
-        return observation.material.text;
-    }
-}
-function compactToolResultHistoryPayload(input) {
-    const summary = input.observation.material.text
-        .split(/\r?\n/u)
-        .filter((line) => !/^\s*payload\s*:/iu.test(line))
-        .slice(0, 3)
-        .join("\n");
-    return JSON.stringify({
-        kind: "praxis.compactedToolResultHistoryPayload",
-        observationId: input.observation.observationId,
-        originalPayloadBytes: input.payloadBytes,
-        originalPayloadSha256: sha256Hex(input.payloadText),
-        budgetBytes: input.budgetBytes,
-        summary,
-        note: "Older tool result payload was compacted before provider history replay to keep dynamic context within the aggregate observation budget. Re-run the tool or inspect an artifact ref if exact content is needed.",
-    });
-}
-function providerToolResultHistoryFromObservations(observations, budgetBytes = DEFAULT_OBSERVATION_TURN_INLINE_BUDGET_BYTES) {
-    const candidates = observations
-        .map((observation, index) => {
-        const metadata = observation.material.metadata ?? {};
-        const toolCallId = typeof metadata.toolCallId === "string" && metadata.toolCallId.trim().length > 0
-            ? metadata.toolCallId.trim()
-            : undefined;
-        const toolId = typeof metadata.toolId === "string" && metadata.toolId.trim().length > 0
-            ? metadata.toolId.trim()
-            : undefined;
-        if (toolCallId === undefined || toolId === undefined)
-            return undefined;
-        const providerName = typeof metadata.providerToolName === "string" && metadata.providerToolName.trim().length > 0
-            ? metadata.providerToolName.trim()
-            : providerToolName(toolId);
-        const status = typeof metadata.observationStatus === "string" ? metadata.observationStatus : "completed";
-        const payloadText = observationPayloadText(observation);
-        const payloadBytes = Buffer.byteLength(payloadText, "utf8");
-        return {
-            observationIndex: index,
-            callId: toolCallId,
-            toolId,
-            providerName,
-            isError: status !== "completed",
-            content: [{
-                    type: "text",
-                    text: payloadText.length === 0 ? observation.material.text : payloadText,
-                }],
-            metadata: {
-                observationId: observation.observationId,
-                observationStatus: status,
-            },
-            originalContentBytes: payloadBytes,
-            replayedContentBytes: payloadBytes,
-            compactedForHistory: false,
-        };
-    })
-        .filter((result) => result !== undefined);
-    let remainingBytes = budgetBytes;
-    let fullToolResults = 0;
-    let compactedToolResults = 0;
-    const replayedByIndex = new Map();
-    for (const candidate of [...candidates].reverse()) {
-        const canInlineFull = candidate.originalContentBytes <= remainingBytes;
-        if (canInlineFull) {
-            remainingBytes -= candidate.originalContentBytes;
-            fullToolResults += 1;
-            replayedByIndex.set(candidate.observationIndex, candidate);
-            continue;
-        }
-        compactedToolResults += 1;
-        const observation = observations[candidate.observationIndex];
-        const fullText = candidate.content.map((part) => part.type === "text" ? part.text : "").join("\n");
-        const compactedText = observation === undefined
-            ? JSON.stringify({
-                kind: "praxis.compactedToolResultHistoryPayload",
-                originalPayloadBytes: candidate.originalContentBytes,
-                budgetBytes,
-            })
-            : compactToolResultHistoryPayload({
-                observation,
-                payloadText: fullText,
-                payloadBytes: candidate.originalContentBytes,
-                budgetBytes,
-            });
-        replayedByIndex.set(candidate.observationIndex, {
-            ...candidate,
-            content: [{ type: "text", text: compactedText }],
-            replayedContentBytes: Buffer.byteLength(compactedText, "utf8"),
-            compactedForHistory: true,
-        });
-    }
-    const results = candidates
-        .map((candidate) => replayedByIndex.get(candidate.observationIndex))
-        .filter((result) => result !== undefined);
-    return {
-        results,
-        budget: {
-            budgetBytes,
-            originalToolResultBytes: candidates.reduce((sum, result) => sum + result.originalContentBytes, 0),
-            replayedToolResultBytes: results.reduce((sum, result) => sum + result.replayedContentBytes, 0),
-            fullToolResults,
-            compactedToolResults,
-        },
-    };
-}
-function providerToolResultsFromObservations(observations) {
-    return providerToolResultHistoryFromObservations(observations).results;
-}
-function stablePromptCacheKey(manifest, sessionId) {
-    const hash = createHash("sha256")
-        .update([
-        "praxis.promptCache.v1",
-        manifest.identity.id,
-        manifest.harness.promptPack.promptPackId ?? "",
-        sessionId,
-    ].join("\n"))
-        .digest("hex")
-        .slice(0, 32);
-    return `praxis-${hash}`;
-}
-function kernelSseDataObjects(text) {
-    const objects = [];
-    for (const line of text.split(/\r?\n/u)) {
-        if (!line.startsWith("data:"))
-            continue;
-        const payload = line.slice("data:".length).trim();
-        if (payload.length === 0 || payload === "[DONE]")
-            continue;
-        try {
-            objects.push(JSON.parse(payload));
-        }
-        catch {
-            // Ignore non-JSON stream payloads.
-        }
-    }
-    return objects;
-}
-function outputItemKey(item, index) {
-    const callId = typeof item.call_id === "string" && item.call_id.trim().length > 0 ? item.call_id.trim() : undefined;
-    const id = typeof item.id === "string" && item.id.trim().length > 0 ? item.id.trim() : undefined;
-    const type = typeof item.type === "string" && item.type.trim().length > 0 ? item.type.trim() : "item";
-    return callId ?? id ?? `${type}:${index}`;
-}
-const MAX_PROVIDER_FUNCTION_CALL_ARGUMENT_HISTORY_BYTES = 4 * 1024;
-const MAX_COMPACT_ARGUMENT_STRING_CHARS = 240;
-const MAX_COMPACT_ARGUMENT_ARRAY_ITEMS = 16;
-const MAX_COMPACT_ARGUMENT_OBJECT_KEYS = 48;
-function sha256Hex(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-function compactLargeStringForFunctionCallHistory(value) {
-    return {
-        kind: "praxis.compactedLargeString",
-        bytes: Buffer.byteLength(value, "utf8"),
-        chars: value.length,
-        lines: value.split(/\r?\n/u).length,
-        sha256: sha256Hex(value),
-    };
-}
-function shouldCompactFunctionCallString(key, value) {
-    if (Buffer.byteLength(value, "utf8") > MAX_PROVIDER_FUNCTION_CALL_ARGUMENT_HISTORY_BYTES)
-        return true;
-    if (!/content|source|code|html|css|script|body|stdout|stderr|output/iu.test(key ?? ""))
-        return false;
-    return value.length > MAX_COMPACT_ARGUMENT_STRING_CHARS;
-}
-function compactFunctionCallArgumentValue(value, key, depth = 0) {
-    if (typeof value === "string") {
-        return shouldCompactFunctionCallString(key, value) ? compactLargeStringForFunctionCallHistory(value) : value;
-    }
-    if (value === null || typeof value !== "object") {
-        return value;
-    }
-    if (depth >= 8) {
-        return {
-            kind: "praxis.compactedDeepValue",
-            valueType: Array.isArray(value) ? "array" : "object",
-        };
-    }
-    if (Array.isArray(value)) {
-        const visible = value.slice(0, MAX_COMPACT_ARGUMENT_ARRAY_ITEMS).map((item) => compactFunctionCallArgumentValue(item, key, depth + 1));
-        return value.length <= MAX_COMPACT_ARGUMENT_ARRAY_ITEMS
-            ? visible
-            : {
-                kind: "praxis.compactedArray",
-                itemCount: value.length,
-                visibleItems: visible,
-                omittedItems: value.length - MAX_COMPACT_ARGUMENT_ARRAY_ITEMS,
-            };
-    }
-    const record = value;
-    const keys = Object.keys(record).sort();
-    const visibleKeys = keys.slice(0, MAX_COMPACT_ARGUMENT_OBJECT_KEYS);
-    const compacted = {};
-    for (const childKey of visibleKeys) {
-        compacted[childKey] = compactFunctionCallArgumentValue(record[childKey], childKey, depth + 1);
-    }
-    if (keys.length > MAX_COMPACT_ARGUMENT_OBJECT_KEYS) {
-        compacted.__praxisOmittedKeys = keys.length - MAX_COMPACT_ARGUMENT_OBJECT_KEYS;
-    }
-    return compacted;
-}
-function compactProviderFunctionCallArgumentsForHistory(input) {
-    const argumentBytes = Buffer.byteLength(input.argumentsText, "utf8");
-    if (argumentBytes <= MAX_PROVIDER_FUNCTION_CALL_ARGUMENT_HISTORY_BYTES) {
-        return input.argumentsText;
-    }
-    let parsedArguments;
-    try {
-        parsedArguments = JSON.parse(input.argumentsText);
-    }
-    catch {
-        parsedArguments = input.argumentsText;
-    }
-    return JSON.stringify({
-        kind: "praxis.compactedFunctionCallArguments",
-        toolName: input.toolName,
-        callId: input.callId,
-        originalArgumentsBytes: argumentBytes,
-        originalArgumentsSha256: sha256Hex(input.argumentsText),
-        note: "The runtime executed the original full arguments. This compact form is only replayed to the provider as call history.",
-        arguments: compactFunctionCallArgumentValue(parsedArguments),
-    });
-}
-function normalizeOpenAIResponseOutputItemForInput(item) {
-    const type = typeof item.type === "string" ? item.type : undefined;
-    if (type !== "function_call") {
-        return undefined;
-    }
-    const name = typeof item.name === "string" && item.name.trim().length > 0 ? item.name.trim() : undefined;
-    const callId = typeof item.call_id === "string" && item.call_id.trim().length > 0 ? item.call_id.trim() : undefined;
-    if (name === undefined || callId === undefined) {
-        return undefined;
-    }
-    const args = typeof item.arguments === "string" ? item.arguments : "{}";
-    const status = typeof item.status === "string" && item.status.trim().length > 0 ? item.status.trim() : "completed";
-    const historyArgs = compactProviderFunctionCallArgumentsForHistory({
-        toolName: name,
-        callId,
-        argumentsText: args,
-    });
-    return {
-        type: "function_call",
-        name,
-        call_id: callId,
-        arguments: historyArgs,
-        status,
-    };
-}
-function stringifyProviderArguments(value) {
-    if (typeof value === "string")
-        return value;
-    if (value === undefined)
-        return "{}";
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return "{}";
-    }
-}
-function normalizeOpenAIChatCompletionToolCallForInput(item) {
-    const functionRecord = isRecord(item.function) ? item.function : undefined;
-    const name = readString(functionRecord?.name) ?? readString(item.name);
-    const callId = readString(item.id) ?? readString(item.call_id);
-    if (name === undefined || callId === undefined)
-        return undefined;
-    const argumentsText = stringifyProviderArguments(functionRecord?.arguments ?? item.arguments ?? item.input);
-    return {
-        id: callId,
-        type: "function",
-        function: {
-            name,
-            arguments: compactProviderFunctionCallArgumentsForHistory({
-                toolName: name,
-                callId,
-                argumentsText,
-            }),
-        },
-    };
-}
-function normalizeOpenAIChatCompletionMessageForInput(message) {
-    if (message.role !== "assistant")
-        return undefined;
-    const rawToolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-    const toolCalls = rawToolCalls
-        .filter((toolCall) => isRecord(toolCall))
-        .map(normalizeOpenAIChatCompletionToolCallForInput)
-        .filter((toolCall) => toolCall !== undefined);
-    if (toolCalls.length === 0)
-        return undefined;
-    return {
-        role: "assistant",
-        content: typeof message.content === "string" ? message.content : null,
-        tool_calls: toolCalls,
-    };
-}
-function assembleOpenAIChatCompletionMessageFromSse(raw) {
-    const contentChunks = [];
-    const fragments = new Map();
-    let nextIndex = 0;
-    for (const object of kernelSseDataObjects(raw)) {
-        if (!isRecord(object))
-            continue;
-        const choices = Array.isArray(object.choices) ? object.choices : [];
-        for (const choice of choices) {
-            if (!isRecord(choice))
-                continue;
-            const delta = isRecord(choice.delta) ? choice.delta : undefined;
-            const content = delta?.content;
-            if (typeof content === "string") {
-                contentChunks.push(content);
-            }
-            const toolCalls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : [];
-            for (const toolCall of toolCalls) {
-                if (!isRecord(toolCall))
-                    continue;
-                const functionRecord = isRecord(toolCall.function) ? toolCall.function : undefined;
-                const index = typeof toolCall.index === "number" ? toolCall.index : nextIndex;
-                const key = `index:${index}`;
-                const previous = fragments.get(key) ?? { argumentsText: "", index };
-                const argumentsDelta = typeof functionRecord?.arguments === "string"
-                    ? functionRecord.arguments
-                    : typeof toolCall.arguments === "string"
-                        ? toolCall.arguments
-                        : "";
-                fragments.set(key, {
-                    id: readString(toolCall.id) ?? readString(toolCall.call_id) ?? previous.id,
-                    type: readString(toolCall.type) ?? previous.type,
-                    name: readString(functionRecord?.name) ?? readString(toolCall.name) ?? previous.name,
-                    argumentsText: `${previous.argumentsText}${argumentsDelta}`,
-                    index,
-                });
-                nextIndex += 1;
-            }
-        }
-    }
-    const toolCalls = [...fragments.values()]
-        .sort((left, right) => left.index - right.index)
-        .filter((fragment) => fragment.name !== undefined)
-        .map((fragment) => ({
-        id: fragment.id ?? `chat-tool-call-${fragment.index}`,
-        type: fragment.type ?? "function",
-        function: {
-            name: fragment.name ?? "",
-            arguments: fragment.argumentsText,
-        },
-    }));
-    const content = contentChunks.join("");
-    if (toolCalls.length === 0 && content.length === 0) {
-        return undefined;
-    }
-    return {
-        role: "assistant",
-        content: content.length > 0 ? content : null,
-        ...(toolCalls.length === 0 ? {} : { tool_calls: toolCalls }),
-    };
-}
-function extractOpenAIResponseId(raw) {
-    if (typeof raw === "string") {
-        let responseId;
-        for (const object of kernelSseDataObjects(raw)) {
-            const candidate = extractOpenAIResponseId(object);
-            if (candidate !== undefined)
-                responseId = candidate;
-        }
-        return responseId;
-    }
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-        return undefined;
-    }
-    const record = raw;
-    const directId = typeof record.id === "string" && record.id.trim().length > 0 ? record.id.trim() : undefined;
-    if (directId !== undefined && (directId.startsWith("resp_") || directId.startsWith("resp-"))) {
-        return directId;
-    }
-    const response = record.response;
-    if (response !== null && typeof response === "object" && !Array.isArray(response)) {
-        return extractOpenAIResponseId(response);
-    }
-    return directId;
-}
-function extractOpenAIChatCompletionOutputItems(raw) {
-    if (typeof raw === "string") {
-        const assembled = assembleOpenAIChatCompletionMessageFromSse(raw);
-        const items = [
-            assembled === undefined ? undefined : normalizeOpenAIChatCompletionMessageForInput(assembled),
-            ...kernelSseDataObjects(raw).flatMap(extractOpenAIChatCompletionOutputItems),
-        ].filter((item) => item !== undefined);
-        const seen = new Set();
-        return items.filter((item, index) => {
-            const key = outputItemKey(item, index);
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
-    }
-    if (!isRecord(raw))
-        return [];
-    const choices = Array.isArray(raw.choices) ? raw.choices : [];
-    return choices
-        .map((choice) => isRecord(choice) && isRecord(choice.message)
-        ? normalizeOpenAIChatCompletionMessageForInput(choice.message)
-        : undefined)
-        .filter((item) => item !== undefined);
-}
-function extractOpenAIResponseOutputItems(raw) {
-    if (typeof raw === "string") {
-        const responseItems = kernelSseDataObjects(raw).flatMap((object) => {
-            if (object === null || typeof object !== "object" || Array.isArray(object))
-                return [];
-            const record = object;
-            const eventType = typeof record.type === "string" ? record.type : undefined;
-            const fromResponse = record.response === undefined ? [] : extractOpenAIResponseOutputItems(record.response);
-            const fromItem = eventType === "response.output_item.done" &&
-                record.item !== null &&
-                typeof record.item === "object" &&
-                !Array.isArray(record.item)
-                ? [record.item]
-                : [];
-            return [...fromResponse, ...fromItem];
-        }).map(normalizeOpenAIResponseOutputItemForInput)
-            .filter((item) => item !== undefined);
-        const items = [
-            ...extractOpenAIChatCompletionOutputItems(raw),
-            ...responseItems,
-        ];
-        const seen = new Set();
-        return items.filter((item, index) => {
-            const key = outputItemKey(item, index);
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
-    }
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-        return [];
-    }
-    const output = raw.output;
-    if (!Array.isArray(output)) {
-        return extractOpenAIChatCompletionOutputItems(raw);
-    }
-    return output
-        .filter((item) => {
-        return item !== null && typeof item === "object" && !Array.isArray(item);
-    })
-        .map(normalizeOpenAIResponseOutputItemForInput)
-        .filter((item) => item !== undefined);
-}
-function parseJsonRecordForKernel(text) {
-    try {
-        const parsed = JSON.parse(text);
-        return isRecord(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function assembleAnthropicContentBlocksFromSse(raw) {
-    const blocks = new Map();
-    const blockForIndex = (index) => {
-        const existing = blocks.get(index);
-        if (existing !== undefined)
-            return existing;
-        const draft = { index, inputJsonText: "", text: "", thinking: "", signature: "" };
-        blocks.set(index, draft);
-        return draft;
-    };
-    for (const object of kernelSseDataObjects(raw)) {
-        if (!isRecord(object))
-            continue;
-        const eventType = readString(object.type);
-        const index = typeof object.index === "number" && Number.isInteger(object.index) ? object.index : blocks.size;
-        if (eventType === "content_block_start" && isRecord(object.content_block)) {
-            const sourceBlock = object.content_block;
-            const draft = blockForIndex(index);
-            draft.type = readString(sourceBlock.type) ?? draft.type;
-            if (draft.type === "tool_use") {
-                draft.id = readString(sourceBlock.id) ?? draft.id;
-                draft.name = readString(sourceBlock.name) ?? draft.name;
-                if (isRecord(sourceBlock.input) && Object.keys(sourceBlock.input).length > 0) {
-                    draft.input = sourceBlock.input;
-                }
-            }
-            if (draft.type === "text" && typeof sourceBlock.text === "string") {
-                draft.text += sourceBlock.text;
-            }
-            if (draft.type === "thinking") {
-                if (typeof sourceBlock.thinking === "string")
-                    draft.thinking += sourceBlock.thinking;
-                if (typeof sourceBlock.signature === "string")
-                    draft.signature += sourceBlock.signature;
-            }
-            if (draft.type === "redacted_thinking" && typeof sourceBlock.data === "string") {
-                draft.redactedData = sourceBlock.data;
-            }
-            continue;
-        }
-        if (eventType === "content_block_delta" && isRecord(object.delta)) {
-            const delta = object.delta;
-            const draft = blockForIndex(index);
-            if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
-                draft.type = draft.type ?? "tool_use";
-                draft.inputJsonText += delta.partial_json;
-            }
-            if (delta.type === "text_delta" && typeof delta.text === "string") {
-                draft.type = draft.type ?? "text";
-                draft.text += delta.text;
-            }
-            if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
-                draft.type = draft.type ?? "thinking";
-                draft.thinking += delta.thinking;
-            }
-            if (delta.type === "signature_delta" && typeof delta.signature === "string") {
-                draft.type = draft.type ?? "thinking";
-                draft.signature += delta.signature;
-            }
-        }
-    }
-    return [...blocks.values()]
-        .sort((left, right) => left.index - right.index)
-        .flatMap((draft) => {
-        if (draft.type === "tool_use" && draft.id !== undefined && draft.name !== undefined) {
-            return [{
-                    type: "tool_use",
-                    id: draft.id,
-                    name: draft.name,
-                    input: draft.inputJsonText.trim().length > 0
-                        ? parseJsonRecordForKernel(draft.inputJsonText) ?? draft.input ?? {}
-                        : draft.input ?? {},
-                }];
-        }
-        if (draft.type === "text" && draft.text.length > 0) {
-            return [{ type: "text", text: draft.text }];
-        }
-        if (draft.type === "thinking" && (draft.thinking.length > 0 || draft.signature.length > 0)) {
-            return [{
-                    type: "thinking",
-                    thinking: draft.thinking,
-                    ...(draft.signature.length === 0 ? {} : { signature: draft.signature }),
-                }];
-        }
-        if (draft.type === "redacted_thinking" && draft.redactedData !== undefined) {
-            return [{ type: "redacted_thinking", data: draft.redactedData }];
-        }
-        return [];
-    });
-}
-function extractAnthropicMessagesOutputItems(raw) {
-    if (typeof raw === "string") {
-        const streamContent = assembleAnthropicContentBlocksFromSse(raw);
-        const nestedMessages = kernelSseDataObjects(raw).flatMap((object) => isRecord(object) && object.message !== undefined
-            ? extractAnthropicMessagesOutputItems(object.message)
-            : []);
-        const messages = [
-            ...(streamContent.length === 0 ? [] : [{ role: "assistant", content: streamContent }]),
-            ...nestedMessages,
-        ];
-        const seen = new Set();
-        return messages.filter((item, index) => {
-            const key = outputItemKey(item, index);
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
-    }
-    if (!isRecord(raw) || !Array.isArray(raw.content) || raw.content.length === 0)
-        return [];
-    return [{ role: "assistant", content: raw.content }];
-}
-function extractProviderOutputItems(raw, providerFamily) {
-    if (providerFamily === "anthropicMessages") {
-        return extractAnthropicMessagesOutputItems(raw);
-    }
-    return extractOpenAIResponseOutputItems(raw);
-}
-function renderPromptPackProviderMaterials(materials) {
-    return materials
-        .map((material) => [`<${material.kind} id="${material.id}">`, material.text, `</${material.kind}>`].join("\n"))
-        .join("\n\n");
-}
-function splitPromptPackForProvider(promptPack) {
-    const segmentPolicies = new Map(promptPack.cachePlan.segments.map((segment) => [segment.segmentKind, segment.cachePolicy]));
-    const instructionMaterials = promptPack.materials.filter((material) => segmentPolicies.get(material.promptSegmentKind) !== "dynamic-no-cache");
-    const dynamicMaterials = promptPack.materials.filter((material) => segmentPolicies.get(material.promptSegmentKind) === "dynamic-no-cache");
-    const instructionSegmentKinds = [...new Set(instructionMaterials.map((material) => material.promptSegmentKind))];
-    const dynamicSegmentKinds = [...new Set(dynamicMaterials.map((material) => material.promptSegmentKind))];
-    return {
-        instructionText: renderPromptPackProviderMaterials(instructionMaterials),
-        dynamicInputText: renderPromptPackProviderMaterials(dynamicMaterials),
-        instructionSegmentKinds,
-        dynamicSegmentKinds,
-        instructionEstimatedTokens: instructionMaterials.reduce((sum, material) => sum + material.estimatedTokens, 0),
-        dynamicEstimatedTokens: dynamicMaterials.reduce((sum, material) => sum + material.estimatedTokens, 0),
-    };
-}
-function estimateSerializedTokens(value) {
-    const serialized = typeof value === "string" ? value : JSON.stringify(value);
-    return Math.max(0, Math.ceil((serialized?.length ?? 0) / 4));
-}
-function recordArrayLength(value) {
-    return Array.isArray(value) ? value.length : 0;
-}
-function stableJsonForHash(value) {
-    if (value === undefined) {
-        return "undefined";
-    }
-    if (value === null || typeof value !== "object") {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((item) => stableJsonForHash(item)).join(",")}]`;
-    }
-    const record = value;
-    return `{${Object.keys(record)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${stableJsonForHash(record[key])}`)
-        .join(",")}}`;
-}
-function hashDebugValue(value) {
-    return createHash("sha256").update(stableJsonForHash(value)).digest("hex");
-}
-function ratioOrZero(numerator, denominator) {
-    if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator <= 0)
-        return 0;
-    return Math.round((numerator / denominator) * 10_000) / 10_000;
-}
-function headerValueForKernel(headers, name) {
-    const lowerName = name.toLowerCase();
-    for (const [key, value] of Object.entries(headers ?? {})) {
-        if (key.toLowerCase() === lowerName && value.trim().length > 0) {
-            return value;
-        }
-    }
-    return undefined;
-}
-function providerRoutingDebug(headers) {
-    if (headers === undefined)
-        return undefined;
-    return {
-        publicSafe: true,
-        responseHeaderNames: Object.keys(headers).map((key) => key.toLowerCase()).sort(),
-        responseCodexTurnState: headerValueForKernel(headers, "x-codex-turn-state") === undefined ? "absent" : "present",
-        responseRequestId: headerValueForKernel(headers, "x-request-id") ?? headerValueForKernel(headers, "x-oai-request-id"),
-        responseOpenAIModel: headerValueForKernel(headers, "openai-model"),
-    };
-}
-function providerResponseHeadersForKernel(providerResult) {
-    if (!isRecord(providerResult) || providerResult.ok !== true || !isRecord(providerResult.response))
-        return undefined;
-    const headers = providerResult.response.headers;
-    if (!isRecord(headers))
-        return undefined;
-    return Object.fromEntries(Object.entries(headers).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string"));
-}
-function normalizeToolContext(value) {
-    if (!isRecord(value))
-        return value;
-    const normalized = {};
-    for (const [key, child] of Object.entries(value)) {
-        if (["invocationId", "toolCallId", "callId"].includes(key))
-            continue;
-        normalized[key] = normalizeToolContext(child);
-    }
-    return normalized;
-}
-function stringValueForKernel(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function firstStringValueForKernel(...values) {
-    for (const value of values) {
-        const candidate = stringValueForKernel(value);
-        if (candidate !== undefined)
-            return candidate;
-    }
-    return undefined;
-}
-function stringArrayValueForKernel(value) {
-    return Array.isArray(value)
-        ? value.map((item) => stringValueForKernel(item)).filter((item) => item !== undefined)
-        : [];
-}
-function codeReadTargetPaths(args) {
-    const target = isRecord(args.target) ? args.target : undefined;
-    const values = [
-        ...stringArrayValueForKernel(args.targetPaths),
-        ...stringArrayValueForKernel(args.paths),
-        ...stringArrayValueForKernel(args.files),
-        ...stringArrayValueForKernel(target?.targetPaths),
-        ...stringArrayValueForKernel(target?.paths),
-        ...[
-            firstStringValueForKernel(args.targetPath, args.path, args.filePath, target?.targetPath, target?.path, target?.filePath),
-        ].filter((item) => item !== undefined),
-    ];
-    return values.map((item) => item.trim()).filter((item, index, array) => item.length > 0 && array.indexOf(item) === index).sort();
-}
-function codeReadHasRange(args) {
-    return isRecord(args.range) || isRecord(isRecord(args.target) ? args.target.range : undefined);
-}
-function codeReadCacheKey(toolId, args) {
-    if (toolId !== "code.read")
-        return undefined;
-    const paths = codeReadTargetPaths(args);
-    if (paths.length === 0)
-        return undefined;
-    return `${toolId}:${stableJsonForHash({
-        paths,
-        includeLineNumbers: args.includeLineNumbers,
-        encoding: args.encoding,
-        context: normalizeToolContext(args.context),
-    })}`;
-}
-function isCodeMutationTool(toolId) {
-    return ["code.overwrite", "code.modify", "code.replaceFile", "code.delete", "code.format"].includes(toolId);
-}
-function duplicateCodeReadRecord(input) {
-    const paths = codeReadTargetPaths(input.args);
-    const payload = {
-        kind: "agentCore.basicTool.code.read.cachedObservation",
-        duplicateOfToolCallId: input.previousCallId,
-        targetPaths: paths,
-        content: "",
-        files: [],
-        bytes: 0,
-        truncated: false,
-        unsafeSideEffects: false,
-        note: "This code.read request repeats content already returned earlier in the same model turn. Use the previous observation instead of rereading the file.",
-    };
-    const record = {
-        callId: input.toolCallId,
-        toolId: input.toolId,
-        arguments: input.args,
-        ok: true,
-        output: payload,
-    };
-    const observation = createObservationMaterial({
-        observationId: `${input.sessionId}:observation:${input.toolCallId}:cached-read`,
-        source: "runtime",
-        status: "completed",
-        title: `BaseTool ${input.toolId} cached`,
-        summary: `duplicate code.read skipped; previous observation ${input.previousCallId} already contains ${paths.join(", ") || "the requested file"}`,
-        refs: [input.toolCallId, input.toolId, input.previousCallId],
-        payload,
-        metadata: metadataRecord({
-            toolCallId: input.toolCallId,
-            toolId: input.toolId,
-            providerToolName: input.providerToolName ?? "",
-            duplicateOfToolCallId: input.previousCallId,
-            duplicateObservationReuse: true,
-            createdAt: input.now,
-        }),
-    });
-    return { record, observation };
-}
-function providerBodyFingerprints(input) {
-    const providerInput = Array.isArray(input.providerBody.input) ? input.providerBody.input : [];
-    const dynamicInputItem = providerInput.find((item) => item !== null &&
-        typeof item === "object" &&
-        !Array.isArray(item) &&
-        item.role === "user");
-    return {
-        bodyHash: hashDebugValue(input.providerBody),
-        toolsHash: hashDebugValue(input.providerBody.tools),
-        inputHash: hashDebugValue(input.providerBody.input),
-        instructionsHash: hashDebugValue(input.providerBody.instructions),
-        developerHash: hashDebugValue(input.providerBody.instructions ?? providerInput[0]),
-        promptPackUserHash: hashDebugValue(dynamicInputItem ?? providerInput[1]),
-        previousItemsHash: hashDebugValue(input.previousProviderOutputItems),
-        toolResultsHash: hashDebugValue(input.toolResultInputs),
-    };
-}
-function providerItemCallId(item) {
-    if (!isRecord(item))
-        return undefined;
-    const callId = item.call_id;
-    return typeof callId === "string" && callId.trim().length > 0 ? callId.trim() : undefined;
-}
-function composeOpenAIResponsesInput(input) {
-    const toolResultsByCallId = new Map();
-    for (const toolResult of input.toolResultInputs) {
-        const callId = providerItemCallId(toolResult);
-        if (callId === undefined)
-            continue;
-        toolResultsByCallId.set(callId, [...(toolResultsByCallId.get(callId) ?? []), toolResult]);
-    }
-    const providerInput = [];
-    const consumedToolResults = new Set();
-    for (const previousItem of input.previousProviderOutputItems) {
-        providerInput.push(previousItem);
-        const callId = providerItemCallId(previousItem);
-        if (callId === undefined)
-            continue;
-        for (const toolResult of toolResultsByCallId.get(callId) ?? []) {
-            providerInput.push(toolResult);
-            consumedToolResults.add(toolResult);
-        }
-    }
-    providerInput.push(...input.toolResultInputs.filter((toolResult) => !consumedToolResults.has(toolResult)), {
-        role: "user",
-        content: [{
-                type: "input_text",
-                text: input.dynamicInputText,
-            }],
-    });
-    return providerInput;
-}
-function chatToolCallIds(message) {
-    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-    return toolCalls
-        .map((toolCall) => isRecord(toolCall) ? readString(toolCall.id) : undefined)
-        .filter((toolCallId) => toolCallId !== undefined);
-}
-function composeOpenAIChatCompletionsMessages(input) {
-    const toolMessagesByCallId = new Map();
-    for (const toolMessage of input.toolResultMessages) {
-        const callId = readString(toolMessage.tool_call_id);
-        if (callId === undefined)
-            continue;
-        toolMessagesByCallId.set(callId, [...(toolMessagesByCallId.get(callId) ?? []), toolMessage]);
-    }
-    const messages = [];
-    const consumedToolMessages = new Set();
-    for (const previousItem of input.previousProviderOutputItems) {
-        messages.push(previousItem);
-        for (const callId of chatToolCallIds(previousItem)) {
-            for (const toolMessage of toolMessagesByCallId.get(callId) ?? []) {
-                messages.push(toolMessage);
-                consumedToolMessages.add(toolMessage);
-            }
-        }
-    }
-    messages.push(...input.toolResultMessages.filter((toolMessage) => !consumedToolMessages.has(toolMessage)), { role: "user", content: input.dynamicInputText });
-    return messages;
-}
-function anthropicToolUseIds(message) {
-    const content = Array.isArray(message.content) ? message.content : [];
-    return content
-        .map((block) => isRecord(block) && block.type === "tool_use" ? readString(block.id) : undefined)
-        .filter((toolUseId) => toolUseId !== undefined);
-}
-function anthropicToolResultIds(message) {
-    const content = Array.isArray(message.content) ? message.content : [];
-    return content
-        .map((block) => isRecord(block) && block.type === "tool_result" ? readString(block.tool_use_id) : undefined)
-        .filter((toolUseId) => toolUseId !== undefined);
-}
-function anthropicToolResultBlocksForId(message, toolUseId) {
-    const content = Array.isArray(message.content) ? message.content : [];
-    return content.filter((block) => isRecord(block) &&
-        block.type === "tool_result" &&
-        block.tool_use_id === toolUseId);
-}
-function appendAnthropicUserText(messages, dynamicInputText) {
-    const textBlock = { type: "text", text: dynamicInputText };
-    const last = messages[messages.length - 1];
-    if (last !== undefined && last.role === "user" && Array.isArray(last.content)) {
-        messages[messages.length - 1] = {
-            ...last,
-            content: [...last.content, textBlock],
-        };
-        return messages;
-    }
-    messages.push({ role: "user", content: dynamicInputText });
-    return messages;
-}
-function composeAnthropicMessages(input) {
-    const toolMessagesByToolUseId = new Map();
-    for (const toolMessage of input.toolResultMessages) {
-        for (const toolUseId of anthropicToolResultIds(toolMessage)) {
-            toolMessagesByToolUseId.set(toolUseId, [...(toolMessagesByToolUseId.get(toolUseId) ?? []), toolMessage]);
-        }
-    }
-    const messages = [];
-    const consumedToolMessages = new Set();
-    for (const previousItem of input.previousProviderOutputItems) {
-        messages.push(previousItem);
-        const toolUseIds = anthropicToolUseIds(previousItem);
-        if (toolUseIds.length === 0)
-            continue;
-        const toolResultBlocks = [];
-        for (const toolUseId of toolUseIds) {
-            for (const toolMessage of toolMessagesByToolUseId.get(toolUseId) ?? []) {
-                const blocks = anthropicToolResultBlocksForId(toolMessage, toolUseId);
-                if (blocks.length === 0)
-                    continue;
-                toolResultBlocks.push(...blocks);
-                consumedToolMessages.add(toolMessage);
-            }
-        }
-        if (toolResultBlocks.length > 0) {
-            messages.push({ role: "user", content: toolResultBlocks });
-        }
-    }
-    messages.push(...input.toolResultMessages.filter((toolMessage) => !consumedToolMessages.has(toolMessage)));
-    return appendAnthropicUserText(messages, input.dynamicInputText);
-}
-function normalizedSelection(values) {
-    return [...new Set((values ?? []).map((value) => value.trim()).filter(Boolean))].sort();
-}
-function buildPromptPackCacheDebug(input) {
-    const segments = input.promptPack.cachePlan.segments.map((segment) => ({
-        segmentKind: segment.segmentKind,
-        cachePolicy: segment.cachePolicy,
-        stability: segment.stability,
-        estimatedTokens: segment.estimatedTokens,
-        segmentHash: segment.segmentHash,
-        materialCount: segment.materialRefs.length,
-        materialRefs: segment.materialRefs,
-        providerHints: segment.providerHints,
-    }));
-    const cacheablePrefixEstimatedTokens = input.promptPack.cachePlan.cacheablePrefixSegmentKinds
-        .reduce((sum, segmentKind) => sum + (input.promptPack.cachePlan.segments.find((segment) => segment.segmentKind === segmentKind)?.estimatedTokens ?? 0), 0);
-    const dynamicEstimatedTokens = input.promptPack.cachePlan.dynamicSegmentKinds
-        .reduce((sum, segmentKind) => sum + (input.promptPack.cachePlan.segments.find((segment) => segment.segmentKind === segmentKind)?.estimatedTokens ?? 0), 0);
-    const inputEstimatedTokens = estimateSerializedTokens(input.providerBody.input);
-    const toolsEstimatedTokens = estimateSerializedTokens(input.providerBody.tools);
-    const providerBodyEstimatedTokens = estimateSerializedTokens(input.providerBody);
-    const providerStablePrefixEstimatedTokens = input.promptSplit.instructionEstimatedTokens + toolsEstimatedTokens;
-    const providerDynamicInputEstimatedTokens = inputEstimatedTokens;
-    return {
-        kind: "praxis.modelCall.cacheDebug",
-        strategy: "prompt-pack-cache-xray",
-        promptCacheKey: input.promptCacheKey,
-        promptPack: {
-            totalEstimatedTokens: input.promptPack.totalEstimatedTokens,
-            renderedTextEstimatedTokens: estimateSerializedTokens(input.promptPack.renderedText),
-            cacheablePrefixEstimatedTokens,
-            dynamicEstimatedTokens,
-            segmentCount: segments.length,
-            segments,
-            cacheRiskWarnings: input.promptPack.cachePlan.cacheRiskWarnings,
-            providerLowering: {
-                instructionSegmentKinds: input.promptSplit.instructionSegmentKinds,
-                dynamicInputSegmentKinds: input.promptSplit.dynamicSegmentKinds,
-                instructionEstimatedTokens: input.promptSplit.instructionEstimatedTokens,
-                dynamicInputEstimatedTokens: input.promptSplit.dynamicEstimatedTokens,
-                instructionsHash: hashDebugValue(input.promptSplit.instructionText),
-                dynamicInputHash: hashDebugValue(input.promptSplit.dynamicInputText),
-            },
-        },
-        providerBody: {
-            estimatedTokens: providerBodyEstimatedTokens,
-            inputEstimatedTokens,
-            toolsEstimatedTokens,
-            toolCount: recordArrayLength(input.providerBody.tools),
-            fingerprints: providerBodyFingerprints(input),
-            previousProviderOutputItems: input.previousProviderOutputItems.length,
-            toolResultInputs: input.toolResultInputs.length,
-            toolResultBudget: input.toolResultBudget,
-            cacheShape: {
-                providerStablePrefixEstimatedTokens,
-                providerDynamicInputEstimatedTokens,
-                stablePrefixShare: ratioOrZero(providerStablePrefixEstimatedTokens, providerBodyEstimatedTokens),
-                dynamicInputShare: ratioOrZero(providerDynamicInputEstimatedTokens, providerBodyEstimatedTokens),
-                stablePrefixHash: hashDebugValue({
-                    instructions: input.providerBody.instructions,
-                    tools: input.providerBody.tools,
-                }),
-                dynamicPayloadHash: hashDebugValue({
-                    input: input.providerBody.input,
-                    previousProviderOutputItems: input.previousProviderOutputItems,
-                    toolResultInputs: input.toolResultInputs,
-                }),
-            },
-        },
-    };
-}
-function cacheDebugWithObservedUsage(cacheDebug, usage) {
-    if (usage === undefined)
-        return cacheDebug;
-    const inputTokens = usage.inputTokens;
-    const cachedInputTokens = usage.cachedInputTokens;
-    if (inputTokens === undefined || cachedInputTokens === undefined || inputTokens <= 0) {
-        return {
-            ...cacheDebug,
-            observedUsage: {
-                inputTokens,
-                cachedInputTokens,
-                diagnosis: "no-cache-telemetry",
-                reasons: ["provider usage did not include both inputTokens and cachedInputTokens"],
-            },
-        };
-    }
-    const nonCachedInputTokens = Math.max(0, inputTokens - cachedInputTokens);
-    const cacheHitRate = ratioOrZero(cachedInputTokens, inputTokens);
-    const stablePrefixEstimate = cacheDebug.providerBody.cacheShape.providerStablePrefixEstimatedTokens;
-    const stablePrefixWarmthEstimate = ratioOrZero(cachedInputTokens, stablePrefixEstimate);
-    const dynamicInputShare = cacheDebug.providerBody.cacheShape.dynamicInputShare;
-    const reasons = [
-        `observed cachedInputTokens=${cachedInputTokens} inputTokens=${inputTokens}`,
-        `provider stable prefix estimate=${stablePrefixEstimate} dynamic input estimate=${cacheDebug.providerBody.cacheShape.providerDynamicInputEstimatedTokens}`,
-    ];
-    let diagnosis = "partial-cache-hit";
-    if (cacheHitRate >= 0.9) {
-        diagnosis = "warm-stable-prefix";
-        reasons.push("overall cache hit rate is already warm");
-    }
-    else if (stablePrefixEstimate > 0 && stablePrefixWarmthEstimate < 0.6) {
-        diagnosis = "stable-prefix-cache-break";
-        reasons.push("cached tokens cover less than 60% of the estimated stable prefix");
-    }
-    else if (dynamicInputShare >= 0.35 || nonCachedInputTokens > cachedInputTokens * 0.5) {
-        diagnosis = "dynamic-payload-dominates";
-        reasons.push("non-cached dynamic payload is large enough to dilute the overall hit rate");
-    }
-    else {
-        reasons.push("cache hit is partial; compare fingerprints across adjacent turns for the changing field");
-    }
-    return {
-        ...cacheDebug,
-        observedUsage: {
-            inputTokens,
-            cachedInputTokens,
-            nonCachedInputTokens,
-            cacheHitRate,
-            stablePrefixWarmthEstimate,
-            diagnosis,
-            reasons,
-        },
-    };
-}
-function cacheDebugWithPreviousComparison(cacheDebug, previous) {
-    if (previous === undefined)
-        return cacheDebug;
-    const currentFingerprints = cacheDebug.providerBody.fingerprints;
-    const previousFingerprints = previous.providerBody.fingerprints;
-    const fingerprintKeys = [...new Set([
-            ...Object.keys(previousFingerprints),
-            ...Object.keys(currentFingerprints),
-        ])].sort();
-    const changedFingerprintKeys = fingerprintKeys.filter((key) => previousFingerprints[key] !== currentFingerprints[key]);
-    const stablePrefixChanged = previous.providerBody.cacheShape.stablePrefixHash !== cacheDebug.providerBody.cacheShape.stablePrefixHash;
-    const dynamicPayloadChanged = previous.providerBody.cacheShape.dynamicPayloadHash !== cacheDebug.providerBody.cacheShape.dynamicPayloadHash;
-    const observedUsage = cacheDebug.observedUsage;
-    const stablePrefixMissWithStableBody = observedUsage?.diagnosis === "stable-prefix-cache-break"
-        && observedUsage.cachedInputTokens === 0
-        && !stablePrefixChanged
-        && previousFingerprints.instructionsHash === currentFingerprints.instructionsHash
-        && previousFingerprints.toolsHash === currentFingerprints.toolsHash;
-    return {
-        ...cacheDebug,
-        observedUsage: stablePrefixMissWithStableBody
-            ? {
-                ...observedUsage,
-                diagnosis: "provider-cache-miss-with-stable-prefix",
-                reasons: [
-                    ...observedUsage.reasons,
-                    "stable prefix and provider tool fingerprints match the previous model call; this looks like provider cache routing/reuse miss, not PromptPack prefix drift",
-                ],
-            }
-            : observedUsage,
-        comparisonToPrevious: {
-            previousStablePrefixHash: previous.providerBody.cacheShape.stablePrefixHash,
-            previousDynamicPayloadHash: previous.providerBody.cacheShape.dynamicPayloadHash,
-            stablePrefixChanged,
-            dynamicPayloadChanged,
-            instructionsChanged: previousFingerprints.instructionsHash !== currentFingerprints.instructionsHash,
-            toolsChanged: previousFingerprints.toolsHash !== currentFingerprints.toolsHash,
-            changedFingerprintKeys,
-        },
-    };
-}
-function buildCodexResponsesBodyFromPromptPack(manifest, promptPack, mappings, options = {}) {
-    const promptSplit = splitPromptPackForProvider(promptPack);
-    const stableInstructionText = [
-        "You are running inside PraxisRuntimeKernel. Use the Praxis PromptPack as current situation context.",
-        PRAXIS_BASE_TOOL_CALLING_PROTOCOL,
-        promptSplit.instructionText.length > 0
-            ? [
-                "Praxis PromptPack stable context follows. Treat it as governing instructions and stable tool/context guidance.",
-                promptSplit.instructionText,
-            ].join("\n\n")
-            : undefined,
-    ].filter((part) => typeof part === "string" && part.length > 0).join("\n\n");
-    const dynamicInputText = promptSplit.dynamicInputText.length > 0
-        ? promptSplit.dynamicInputText
-        : "Current Praxis turn has no dynamic prompt material.";
-    const toolResultInputs = providerToolResultsFromObservations(options.observations ?? [])
-        .map((result) => lowerProviderToolResult({ providerFamily: "openaiResponses", result }));
-    const body = {
-        model: manifest.model.model,
-        ...(options.promptCacheKey === undefined ? {} : { prompt_cache_key: options.promptCacheKey }),
-        ...(options.previousProviderResponseId === undefined ? {} : { previous_response_id: options.previousProviderResponseId }),
-        instructions: stableInstructionText,
-        input: composeOpenAIResponsesInput({
-            dynamicInputText,
-            previousProviderOutputItems: options.previousProviderOutputItems ?? [],
-            toolResultInputs,
-        }),
-    };
-    if (options.exposeProviderTools !== false) {
-        const bundle = lowerPraxisToolsForProvider({
-            providerFamily: "openaiResponses",
-            manifest,
-            mappings,
-            includeRuntimeDecisionTools: true,
-        });
-        body.tools = bundle.tools;
-    }
-    return body;
-}
-function buildOpenAIChatCompletionsBodyFromPromptPack(manifest, promptPack, providerToolBundle, options = {}) {
-    const promptSplit = splitPromptPackForProvider(promptPack);
-    const systemText = [
-        "You are running inside PraxisRuntimeKernel. Use the Praxis PromptPack as current situation context.",
-        PRAXIS_BASE_TOOL_CALLING_PROTOCOL,
-        promptSplit.instructionText,
-    ].filter((part) => part.trim().length > 0).join("\n\n");
-    const dynamicInputText = promptSplit.dynamicInputText.length > 0
-        ? promptSplit.dynamicInputText
-        : "Current Praxis turn has no dynamic prompt material.";
-    const toolResultMessages = providerToolResultsFromObservations(options.observations ?? [])
-        .map((result) => lowerProviderToolResult({ providerFamily: "openaiChatCompletions", result }));
-    const reasoningEffort = isDeepSeekV4Model(manifest.model.model)
-        ? manifest.model.reasoning?.effort
-        : undefined;
-    return {
-        model: manifest.model.model,
-        stream: true,
-        stream_options: { include_usage: true },
-        ...(reasoningEffort === undefined ? {} : { reasoning_effort: reasoningEffort }),
-        messages: [
-            ...(systemText.length > 0 ? [{ role: "system", content: systemText }] : []),
-            ...composeOpenAIChatCompletionsMessages({
-                dynamicInputText,
-                previousProviderOutputItems: options.previousProviderOutputItems ?? [],
-                toolResultMessages,
-            }),
-        ],
-        ...(options.exposeProviderTools === false || providerToolBundle.tools.length === 0 ? {} : { tools: providerToolBundle.tools }),
-    };
-}
-function buildAnthropicMessagesBodyFromPromptPack(manifest, promptPack, providerToolBundle, options = {}) {
-    const promptSplit = splitPromptPackForProvider(promptPack);
-    const systemText = [
-        "You are running inside PraxisRuntimeKernel. Use the Praxis PromptPack as current situation context.",
-        PRAXIS_BASE_TOOL_CALLING_PROTOCOL,
-        promptSplit.instructionText,
-    ].filter((part) => part.trim().length > 0).join("\n\n");
-    const dynamicInputText = promptSplit.dynamicInputText.length > 0
-        ? promptSplit.dynamicInputText
-        : "Current Praxis turn has no dynamic prompt material.";
-    const toolResultInputs = providerToolResultsFromObservations(options.observations ?? [])
-        .map((result) => lowerProviderToolResult({ providerFamily: "anthropicMessages", result }));
-    const messages = composeAnthropicMessages({
-        dynamicInputText,
-        previousProviderOutputItems: options.previousProviderOutputItems ?? [],
-        toolResultMessages: toolResultInputs,
-    });
-    const deepSeekReasoning = isDeepSeekV4Model(manifest.model.model)
-        ? mapDeepSeekV4ReasoningEffort(manifest.model.reasoning?.effort)
-        : undefined;
-    const maxTokens = readPositiveInteger(manifest.model.metadata?.maxOutputTokens) ?? 8_192;
-    return {
-        model: manifest.model.model,
-        max_tokens: maxTokens,
-        stream: true,
-        ...(systemText.length === 0 ? {} : { system: systemText }),
-        ...(deepSeekReasoning === undefined ? {} : { thinking: deepSeekReasoning.thinking }),
-        ...(deepSeekReasoning?.outputConfig === undefined ? {} : { output_config: deepSeekReasoning.outputConfig }),
-        messages,
-        ...(options.exposeProviderTools === false || providerToolBundle.tools.length === 0 ? {} : { tools: providerToolBundle.tools }),
-    };
-}
-function buildProviderBodyFromPromptPack(manifest, promptPack, providerToolBundle, mappings, options = {}) {
-    if (manifest.model.provider === "anthropic" || manifest.model.endpointShape === "messages") {
-        return buildAnthropicMessagesBodyFromPromptPack(manifest, promptPack, providerToolBundle, options);
-    }
-    if (manifest.model.endpointShape === "chat_completions") {
-        return buildOpenAIChatCompletionsBodyFromPromptPack(manifest, promptPack, providerToolBundle, options);
-    }
-    return buildCodexResponsesBodyFromPromptPack(manifest, promptPack, mappings, options);
-}
-function kernelError(code, message, boundary) {
-    return { code, message, boundary, publicSafe: true };
-}
-async function recordMainLoopStep(input) {
-    input.mainLoopSteps.push(input.step);
-    input.events.push(`mainLoop.${input.step.actionPrimitive}.${input.step.status}`);
-    await input.store.appendMainLoopStep(input.step);
-    await input.store.appendEvent(event(input.sessionId, `event:${input.step.stepId}`, "runtime.mainLoop.step", input.createdAt, { step: input.step }));
-}
-async function recordKernelError(input) {
-    const boundary = input.error.boundary === "compile"
-        ? "runtime-state"
-        : input.error.boundary === "io"
-            ? "io"
-            : input.error.boundary === "runtime-state"
-                ? "runtime-state"
-                : input.error.boundary;
-    await input.store.appendPublicSafeError({
-        sessionId: input.sessionId,
-        errorId: input.errorId,
-        code: input.error.code,
-        message: input.error.message,
-        boundary,
-        createdAt: input.createdAt,
-        metadata: input.metadata ?? {},
-        publicSafe: true,
-    });
-}
-async function recordHandoffPlan(input) {
-    const plan = planFrameworkMainLoopHandoff({
-        sessionId: input.sessionId,
-        turnIndex: input.turnIndex,
-        startStepIndex: input.startStepIndex,
-        now: input.createdAt,
-        tickKind: input.tickKind,
-        promptPackRef: input.promptPackRef,
-        loweredPromptRef: input.loweredPromptRef,
-        modelCallId: input.modelCallId,
-        toolCallId: input.toolCallId,
-        procedureId: input.procedureId,
-        observationRefs: input.observationRefs,
-        inputRefs: input.inputRefs,
-        outputRefs: input.outputRefs,
-        error: input.error,
-    });
-    input.events.push(...plan.events);
-    if (!plan.ok) {
-        return;
-    }
-    for (const step of plan.plan.stepRecords) {
-        await recordMainLoopStep({
-            store: input.store,
-            sessionId: input.sessionId,
-            createdAt: input.createdAt,
-            events: input.events,
-            mainLoopSteps: input.mainLoopSteps,
-            step,
-        });
-    }
-}
-function promptLoweringMaterials(promptPack) {
-    return promptPack.materials.map((material) => ({
-        kind: material.kind,
-        ref: material.id,
-        text: material.text,
-        sourceCategory: material.sourceCategory,
-        priority: material.priority,
-        metadata: material.metadata,
-    }));
-}
-async function requestRuntimeApproval(input) {
-    const createdAt = input.now();
-    const interfaceSurface = input.interfaceSurface ?? (input.resolver === undefined ? "application" : "test-harness");
-    const envelope = {
-        approvalId: input.approvalId,
-        runtimeId: input.runtimeId,
-        sessionId: input.sessionId,
-        source: input.source,
-        reason: input.reason,
-        requestedScopes: input.requestedScopes,
-        riskLevel: input.riskLevel,
-        interfaceSurface,
-        metadata: input.metadata ?? {},
-        publicSafe: true,
-    };
-    await input.store.appendApproval({
-        sessionId: input.sessionId,
-        approvalId: input.approvalId,
-        status: "pending",
-        reason: input.reason,
-        requestedScopes: input.requestedScopes,
-        riskLevel: input.riskLevel,
-        source: input.source,
-        interfaceSurface,
-        createdAt,
-        metadata: input.metadata ?? {},
-    });
-    await input.store.appendEvent(event(input.sessionId, `event:approval:${input.approvalId}:pending`, "runtime.approval.pending", createdAt, {
-        approval: envelope,
-    }));
-    const interfaceEnvelope = approvalInterfaceEnvelope({
-        approvalId: input.approvalId,
-        runtimeId: input.runtimeId,
-        sessionId: input.sessionId,
-        surface: interfaceSurface === "cli" || interfaceSurface === "tui" || interfaceSurface === "raxos"
-            ? interfaceSurface
-            : "application",
-        payload: envelope,
-        createdAt,
-    });
-    if (interfaceEnvelope.ok) {
-        await input.store.appendEvent(event(input.sessionId, `event:interface:approval:${input.approvalId}`, "runtime.interfaceAdapter.approval.envelope", createdAt, {
-            envelope: interfaceEnvelope.envelope,
-        }));
-    }
-    if (input.resolver === undefined) {
-        return {
-            status: "pending",
-            envelope,
-            interfaceEnvelope: interfaceEnvelope.ok ? interfaceEnvelope.envelope : undefined,
-            events: ["runtime.approval.pending", ...(interfaceEnvelope.ok ? interfaceEnvelope.events : [])],
-            reason: input.reason,
-        };
-    }
-    let resolution;
-    try {
-        resolution = await input.resolver(envelope);
-    }
-    catch {
-        const resolvedAt = input.now();
-        await input.store.resolveApproval(input.sessionId, input.approvalId, {
-            status: "denied",
-            resolvedAt,
-            resolution: {
-                resolvedBy: "approvalResolver",
-                reason: "approval resolver failed",
-            },
-        });
-        await input.store.appendEvent(event(input.sessionId, `event:approval:${input.approvalId}:resolverFailed`, "runtime.approval.denied", resolvedAt, {
-            approvalId: input.approvalId,
-            status: "denied",
-            publicSafeFailure: "approval resolver failed",
-        }));
-        return {
-            status: "denied",
-            envelope,
-            interfaceEnvelope: interfaceEnvelope.ok ? interfaceEnvelope.envelope : undefined,
-            events: ["runtime.approval.denied", ...(interfaceEnvelope.ok ? interfaceEnvelope.events : [])],
-            reason: "approval resolver failed",
-        };
-    }
-    const status = resolution.status;
-    if (status === "pending") {
-        return {
-            status,
-            envelope,
-            interfaceEnvelope: interfaceEnvelope.ok ? interfaceEnvelope.envelope : undefined,
-            events: ["runtime.approval.pending", ...(interfaceEnvelope.ok ? interfaceEnvelope.events : [])],
-            reason: resolution.reason ?? input.reason,
-        };
-    }
-    const resolvedAt = input.now();
-    await input.store.resolveApproval(input.sessionId, input.approvalId, {
-        status: status === "approved" ? "approved" : "denied",
-        resolvedAt,
-        resolution: {
-            resolvedBy: resolution.resolvedBy ?? "approvalResolver",
-            reason: resolution.reason,
-            ...(resolution.metadata ?? {}),
-        },
-    });
-    await input.store.appendEvent(event(input.sessionId, `event:approval:${input.approvalId}:resolved`, `runtime.approval.${status}`, resolvedAt, {
-        approvalId: input.approvalId,
-        status,
-        resolvedBy: resolution.resolvedBy ?? "approvalResolver",
-    }));
-    return {
-        status,
-        envelope,
-        interfaceEnvelope: interfaceEnvelope.ok ? interfaceEnvelope.envelope : undefined,
-        events: [`runtime.approval.${status}`, ...(interfaceEnvelope.ok ? interfaceEnvelope.events : [])],
-        reason: resolution.reason,
-    };
-}
-async function prepareKernelSandbox(input) {
-    const sandbox = await prepareSandboxRuntime(input.manifest.sandbox, {
-        cwd: input.options.sandbox?.cwd ?? input.storageRuntime.layout.workspace.root,
-        runSmoke: input.options.sandbox?.runSmoke ?? false,
-    });
-    input.events.push(...sandbox.events);
-    await input.store.appendEvent(event(input.sessionId, "event:sandbox.prepared", "runtime.sandboxPlane.prepared", input.now(), { sandbox }));
-    const failOnUnavailable = input.options.sandbox?.failOnUnavailable ?? true;
-    if (!sandbox.ready && failOnUnavailable) {
-        return {
-            ok: false,
-            sandbox,
-            error: kernelError("SANDBOX_UNAVAILABLE", sandbox.probe.publicSafeMessage, "runtime-state"),
-        };
-    }
-    return { ok: true, sandbox };
-}
-async function buildPromptPackAndLower(input) {
-    const promptPackId = input.manifest.harness.promptPack.promptPackId ?? `${input.sessionId}:promptPack:${input.turnIndex + 1}`;
-    const mainLoopRun = runMainLoop({
-        runtime: {
-            runtimeId: input.runtimeId,
-            sessionId: input.sessionId,
-            manifestRef: input.manifest.manifestId,
-            callerRef: input.modelCaller.id,
-            surfaces: [
-                { surfaceId: "promptPack", kind: "promptPack", ready: true },
-                { surfaceId: "modelAdapter", kind: "modelAdapter", ready: true },
-                { surfaceId: "baseToolExecutor", kind: "baseToolExecutor", ready: true },
-                { surfaceId: "stateEventStore", kind: "stateEventStore", ready: true },
-            ],
-            now: input.now === undefined ? undefined : () => input.now ?? defaultNow(),
-            metadata: { source: "PraxisRuntimeKernel.buildPromptPackAndLower" },
-        },
-        input: input.task,
-        userTurnIndex: input.turnIndex,
-        loopTickIndex: input.turnIndex,
-        startStepIndex: input.startStepIndex,
-        inputRefs: ["runtime.input.normalized", ...input.observations.map((observation) => observation.observationId)],
-        targetModel: input.manifest.model.model,
-        loweringHint: input.manifest.model.endpointShape,
-        promptPackId,
-        materials: promptMaterialsForTurn({
-            manifest: input.manifest,
-            task: input.task,
-            turnIndex: input.turnIndex,
-            toolMappings: input.toolMappings,
-            observations: input.observations,
-            events: input.events,
-            toolContextSelection: input.toolContextSelection,
-            toolContextUsage: input.toolContextUsage,
-        }),
-    });
-    if (!mainLoopRun.ok) {
-        return {
-            ok: false,
-            error: kernelError("PROMPT_PACK_FAILED", mainLoopRun.error.message, "runtime-state"),
-            events: mainLoopRun.events,
-        };
-    }
-    const preparedTurn = mainLoopRun.turnPreparation;
-    if (preparedTurn === undefined) {
-        return {
-            ok: false,
-            error: kernelError("PROMPT_PACK_FAILED", "mainLoop run did not return turn preparation", "runtime-state"),
-            events: mainLoopRun.events,
-        };
-    }
-    const providerFamily = providerToolSchemaFamilyForModel(input.manifest.model);
-    const providerToolBundle = lowerPraxisToolsForProvider({
-        providerFamily,
-        manifest: input.manifest,
-        mappings: input.toolMappings,
-        includeRuntimeDecisionTools: true,
-    });
-    const lowered = lowerPromptForModelAdapter({
-        runtimeId: input.runtimeId,
-        caller: input.modelCaller,
-        promptPack: {
-            id: promptPackId,
-            materials: promptLoweringMaterials(preparedTurn.promptPack),
-            metadata: {
-                source: "PraxisRuntimeKernel",
-                format: preparedTurn.promptPack.format,
-                cachePlan: preparedTurn.cachePlan,
-                turnRecord: preparedTurn.turnRecord,
-            },
-        },
-        target: {
-            capabilityId: modelInvocationCapabilityForModel(input.manifest.model).capabilityId,
-            carrierId: input.manifest.model.carrierId,
-            outputMode: "single",
-        },
-        providerToolBundle,
-        providerCacheHintPlan: providerToolBundle.cacheHintPlan,
-        runtimeReady: true,
-        contract: { accepted: true },
-        governance: { accepted: true },
-    });
-    if (!lowered.ok) {
-        return {
-            ok: false,
-            error: kernelError("PROMPT_PACK_FAILED", lowered.error.message, "runtime-state"),
-            events: [...mainLoopRun.events, ...lowered.events],
-        };
-    }
-    return {
-        ok: true,
-        promptPackId,
-        promptPack: preparedTurn.promptPack,
-        loweredPrompt: lowered.loweredPrompt,
-        providerToolBundle,
-        turnRecord: preparedTurn.turnRecord,
-        events: [...mainLoopRun.events, ...lowered.events],
-    };
-}
-async function executeBaseToolDecision(input) {
-    let toolArguments = enrichToolArguments(input.manifest, input.toolId, input.args, {
-        runtimeId: input.runtimeId,
-        sessionId: input.sessionId,
-        invocationId: input.toolCallId,
-        workspaceRoot: input.workspaceRoot,
-        allowedRoots: input.allowedRoots,
-    });
-    const runtimeReadiness = evaluateBaseToolRuntimeReadiness({
-        toolId: input.toolId,
-        executor: input.executor,
-        implementedPortPaths: listRuntimeBaseToolImplementedPortPaths(),
-    });
-    const filesystemAction = await inferFilesystemActionForTool({
-        toolId: input.toolId,
-        args: toolArguments,
-        workspaceRoot: input.workspaceRoot,
-    });
-    const governance = evaluateBaseToolRuntimeGovernance({
-        toolId: input.toolId,
-        policyMatrix: input.manifest.toolPolicy,
-        sandbox: input.manifest.sandbox,
-        readiness: runtimeReadiness,
-        catalogEntry: runtimeReadiness.entry,
-        resourceLimits: input.manifest.sandbox.resourceLimits,
-        metadata: {
-            toolCallId: input.toolCallId,
-            providerToolName: input.providerToolName ?? "",
-            ...(filesystemAction === undefined ? {} : { filesystemAction }),
-        },
-    });
-    input.events.push(...governance.events);
-    if (governance.status === "deny") {
-        const record = {
-            callId: input.toolCallId,
-            toolId: input.toolId,
-            arguments: toolArguments,
-            ok: false,
-            error: {
-                code: "GOVERNANCE_REJECTED",
-                message: runtimeReadiness.decision === "blocked" ? runtimeReadiness.reason : `BaseTool ${input.toolId} was denied by runtime governance`,
-                publicSafe: true,
-            },
-        };
-        const observation = createObservationMaterial({
-            observationId: `${input.sessionId}:observation:${input.toolCallId}`,
-            source: "baseTool",
-            status: "failed",
-            title: `BaseTool ${input.toolId}`,
-            summary: "tool invocation denied by runtime governance",
-            refs: [input.toolCallId, input.toolId],
-            payload: record.error,
-            metadata: metadataRecord({ toolCallId: input.toolCallId, toolId: input.toolId, governanceStatus: governance.status }),
-        });
-        return { record, observation, events: governance.events, governance };
-    }
-    if (governance.status === "requiresApproval") {
-        const approval = await requestRuntimeApproval({
-            runtimeId: input.runtimeId,
-            sessionId: input.sessionId,
-            approvalId: `${input.toolCallId}:approval`,
-            source: "baseTool",
-            reason: governance.approvalReason ?? `BaseTool ${input.toolId} requires approval`,
-            requestedScopes: ["tool.execute", `tool.${input.toolId}`],
-            riskLevel: governance.risk,
-            resolver: input.approvalResolver,
-            store: input.store,
-            now: input.now,
-            metadata: {
-                toolCallId: input.toolCallId,
-                toolId: input.toolId,
-                policyMatrixId: governance.policyMatrixId,
-            },
-        });
-        input.events.push(...approval.events);
-        if (approval.status !== "approved") {
-            const error = {
-                code: "APPROVAL_REQUIRED",
-                message: approval.reason ?? governance.approvalReason ?? `BaseTool ${input.toolId} requires approval`,
-                publicSafe: true,
-            };
-            const record = {
-                callId: input.toolCallId,
-                toolId: input.toolId,
-                arguments: toolArguments,
-                ok: false,
-                error,
-            };
-            const observation = createObservationMaterial({
-                observationId: `${input.sessionId}:observation:${input.toolCallId}:approval`,
-                source: "baseTool",
-                status: "waitingApproval",
-                title: `BaseTool ${input.toolId}`,
-                summary: error.message,
-                refs: [input.toolCallId, input.toolId, approval.envelope.approvalId],
-                payload: approval.envelope,
-                metadata: metadataRecord({ toolCallId: input.toolCallId, toolId: input.toolId, governanceStatus: governance.status }),
-            });
-            return { record, observation, events: [...governance.events, ...approval.events], governance };
-        }
-        toolArguments = withApprovedRuntimePermissions(input.toolId, toolArguments);
-    }
-    let dependencyPreflight = await preflightBaseToolDependencies({
-        executor: input.executor,
-        implementedPortPaths: listRuntimeBaseToolImplementedPortPaths(),
-        readiness: runtimeReadiness,
-        catalogEntry: runtimeReadiness.entry,
-        probes: input.dependencyRuntime?.probes,
-        context: {
-            runtimeId: input.runtimeId,
-            sessionId: input.sessionId,
-            invocationId: input.toolCallId,
-            toolId: input.toolId,
-            toolInput: toolArguments,
-            governanceAccepted: true,
-            allowedScopes: input.manifest.harness.policy.scopes,
-            mode: input.dependencyRuntime?.mode ?? "observe",
-            managedRoot: input.dependencyRuntime?.managedRoot,
-            env: input.dependencyRuntime?.env,
-            homeDir: input.dependencyRuntime?.homeDir,
-            timeoutMs: input.dependencyRuntime?.timeoutMs,
-        },
-    });
-    input.events.push(...dependencyPreflight.events);
-    await input.store.appendEvent(event(input.sessionId, `event:tool:${input.toolCallId}:dependencies`, "runtime.baseTool.dependencies.preflight", input.now(), {
-        toolId: input.toolId,
-        dependencyPreflight,
-    }));
-    if (dependencyPreflight.decision === "requiresApproval") {
-        const approval = await requestRuntimeApproval({
-            runtimeId: input.runtimeId,
-            sessionId: input.sessionId,
-            approvalId: `${input.toolCallId}:dependency-approval`,
-            source: "runtime",
-            reason: dependencyPreflight.reason,
-            requestedScopes: [
-                "dependency.prepare",
-                ...dependencyPreflight.approvalRequiredDependencies.map((dependencyId) => `dependency.${dependencyId}`),
-            ],
-            riskLevel: "risky",
-            resolver: input.approvalResolver,
-            store: input.store,
-            now: input.now,
-            metadata: {
-                toolCallId: input.toolCallId,
-                toolId: input.toolId,
-                dependencyStatus: dependencyPreflight.status,
-                installableDependencies: dependencyPreflight.installableDependencies,
-            },
-        });
-        input.events.push(...approval.events);
-        if (approval.status !== "approved") {
-            const error = {
-                code: "DEPENDENCY_APPROVAL_REQUIRED",
-                message: approval.reason ?? dependencyPreflight.reason,
-                publicSafe: true,
-            };
-            const record = {
-                callId: input.toolCallId,
-                toolId: input.toolId,
-                arguments: toolArguments,
-                ok: false,
-                error,
-            };
-            const observation = createObservationMaterial({
-                observationId: `${input.sessionId}:observation:${input.toolCallId}:dependency-approval`,
-                source: "baseTool",
-                status: "waitingApproval",
-                title: `BaseTool ${input.toolId}`,
-                summary: error.message,
-                refs: [input.toolCallId, input.toolId, approval.envelope.approvalId],
-                payload: approval.envelope,
-                metadata: metadataRecord({ toolCallId: input.toolCallId, toolId: input.toolId, dependencyStatus: dependencyPreflight.status }),
-            });
-            return { record, observation, events: [...governance.events, ...dependencyPreflight.events, ...approval.events], governance };
-        }
-        if (!dependencyModeCanPrepare(input.dependencyRuntime?.mode ?? "observe")) {
-            const error = {
-                code: "DEPENDENCY_PREPARE_PENDING",
-                message: "dependency approval was granted, but automatic trusted managed installation is not enabled for this run",
-                publicSafe: true,
-            };
-            const record = {
-                callId: input.toolCallId,
-                toolId: input.toolId,
-                arguments: toolArguments,
-                ok: false,
-                error,
-            };
-            const observation = createObservationMaterial({
-                observationId: `${input.sessionId}:observation:${input.toolCallId}:dependency-prepare`,
-                source: "baseTool",
-                status: "waitingApproval",
-                title: `BaseTool ${input.toolId}`,
-                summary: error.message,
-                refs: [input.toolCallId, input.toolId],
-                payload: dependencyPreflight,
-                metadata: metadataRecord({ toolCallId: input.toolCallId, toolId: input.toolId, dependencyStatus: dependencyPreflight.status }),
-            });
-            return { record, observation, events: [...governance.events, ...dependencyPreflight.events, ...approval.events], governance };
-        }
-        dependencyPreflight = await preflightBaseToolDependencies({
-            executor: input.executor,
-            implementedPortPaths: listRuntimeBaseToolImplementedPortPaths(),
-            readiness: runtimeReadiness,
-            catalogEntry: runtimeReadiness.entry,
-            probes: input.dependencyRuntime?.probes,
-            context: {
-                runtimeId: input.runtimeId,
-                sessionId: input.sessionId,
-                invocationId: input.toolCallId,
-                toolId: input.toolId,
-                toolInput: toolArguments,
-                governanceAccepted: true,
-                allowedScopes: input.manifest.harness.policy.scopes,
-                mode: "autoInstallTrustedManaged",
-                managedRoot: input.dependencyRuntime?.managedRoot,
-                env: input.dependencyRuntime?.env,
-                homeDir: input.dependencyRuntime?.homeDir,
-                timeoutMs: input.dependencyRuntime?.timeoutMs,
-            },
-        });
-        input.events.push(...dependencyPreflight.events);
-        await input.store.appendEvent(event(input.sessionId, `event:tool:${input.toolCallId}:dependencies:prepared`, "runtime.baseTool.dependencies.prepared", input.now(), {
-            toolId: input.toolId,
-            dependencyPreflight,
-        }));
-    }
-    if (dependencyPreflight.decision === "blocked") {
-        const record = {
-            callId: input.toolCallId,
-            toolId: input.toolId,
-            arguments: toolArguments,
-            ok: false,
-            error: {
-                code: dependencyPreflight.status === "providerUnavailable" ? "PROVIDER_UNAVAILABLE" : "DEPENDENCY_UNAVAILABLE",
-                message: dependencyPreflight.reason,
-                publicSafe: true,
-            },
-        };
-        const observation = createObservationMaterial({
-            observationId: `${input.sessionId}:observation:${input.toolCallId}:dependency`,
-            source: "baseTool",
-            status: "failed",
-            title: `BaseTool ${input.toolId}`,
-            summary: dependencyPreflight.reason,
-            refs: [input.toolCallId, input.toolId],
-            payload: dependencyPreflight,
-            metadata: metadataRecord({ toolCallId: input.toolCallId, toolId: input.toolId, dependencyStatus: dependencyPreflight.status }),
-        });
-        return { record, observation, events: [...governance.events, ...dependencyPreflight.events], governance };
-    }
-    const toolResult = await invokeMountedBaseTool({
-        runtimeId: input.runtimeId,
-        sessionId: input.sessionId,
-        toolId: input.toolId,
-        toolCallId: input.toolCallId,
-        input: toolArguments,
-        executor: input.executor,
-        runtimeReady: true,
-        readinessMode: "observe",
-        implementedPortPaths: listRuntimeBaseToolImplementedPortPaths(),
-        requestedScopes: ["tool.execute", `tool.${input.toolId}`],
-        allowedScopes: [
-            ...(input.manifest.harness.policy.scopes ?? []),
-            "tool.execute",
-            `tool.${input.toolId}`,
-            input.toolId,
-        ],
-        governance: { accepted: input.allowToolExecution ?? input.manifest.harness.policy.allowToolExecution ?? true },
-        contract: { accepted: true },
-        metadata: {
-            sandbox: governance.sandbox,
-            governance: {
-                status: governance.status,
-                risk: governance.risk,
-                policyProfile: governance.policyProfile,
-                policyMatrixId: governance.policyMatrixId,
-            },
-            dependencyRuntime: {
-                status: dependencyPreflight.status,
-                decision: dependencyPreflight.decision,
-                missingDependencies: dependencyPreflight.missingDependencies,
-                installableDependencies: dependencyPreflight.installableDependencies,
-            },
-        },
-    });
-    input.events.push(...toolResult.events);
-    const record = {
-        callId: input.toolCallId,
-        toolId: input.toolId,
-        arguments: toolArguments,
-        ok: toolResult.ok && toolResult.toolResult.ok,
-        output: toolResult.ok && toolResult.toolResult.ok ? toolResult.toolResult.output : undefined,
-        error: toolResult.ok ? (toolResult.toolResult.ok ? undefined : toolResult.toolResult.error) : toolResult.error,
-    };
-    const observation = createObservationMaterial({
-        observationId: `${input.sessionId}:observation:${input.toolCallId}`,
-        source: "baseTool",
-        status: record.ok ? "completed" : "failed",
-        title: `BaseTool ${input.toolId}`,
-        summary: record.ok ? "tool invocation completed" : "tool invocation failed",
-        refs: [input.toolCallId, input.toolId],
-        payload: record.ok ? record.output : record.error,
-        ...(input.workspaceRoot === undefined ? {} : {
-            artifactStore: {
-                workspaceRoot: input.workspaceRoot,
-                sessionId: input.sessionId,
-            },
-        }),
-        metadata: metadataRecord({
-            toolCallId: input.toolCallId,
-            toolId: input.toolId,
-            providerToolName: input.providerToolName ?? "",
-            createdAt: input.now(),
-        }),
-    });
-    return { record, observation, events: toolResult.events, governance };
-}
-async function executeEphemeralProcedure(input) {
-    const shellWorkspaceWriteViolation = procedureShellWorkspaceWriteViolation(input.plan);
-    if (shellWorkspaceWriteViolation !== undefined) {
-        return {
-            ok: false,
-            records: [],
-            observations: [createObservationMaterial({
-                    observationId: `${input.sessionId}:observation:${input.plan.procedureId}:${shellWorkspaceWriteViolation.step.stepId}:workspace-write-blocked`,
-                    source: "ephemeralProcedure",
-                    status: "failed",
-                    title: `EphemeralProcedure ${input.plan.procedureId} blocked`,
-                    summary: shellWorkspaceWriteViolation.message,
-                    refs: [input.plan.procedureId, shellWorkspaceWriteViolation.step.stepId, shellWorkspaceWriteViolation.step.baseToolId],
-                    payload: {
-                        procedureId: input.plan.procedureId,
-                        stepId: shellWorkspaceWriteViolation.step.stepId,
-                        baseToolId: shellWorkspaceWriteViolation.step.baseToolId,
-                        reason: shellWorkspaceWriteViolation.reason,
-                        recommendedTools: ["code.overwrite", "code.modify", "code.replaceFile"],
-                    },
-                    metadata: metadataRecord({
-                        procedureId: input.plan.procedureId,
-                        stepId: shellWorkspaceWriteViolation.step.stepId,
-                        baseToolId: shellWorkspaceWriteViolation.step.baseToolId,
-                        blockedBy: "shellWorkspaceWriteGuard",
-                    }),
-                })],
-            error: kernelError("PROCEDURE_INVOCATION_FAILED", shellWorkspaceWriteViolation.message, "tool"),
-        };
-    }
-    if (input.plan.approval.required) {
-        const approval = await requestRuntimeApproval({
-            runtimeId: input.runtimeId,
-            sessionId: input.sessionId,
-            approvalId: `${input.plan.procedureId}:approval`,
-            source: "ephemeralProcedure",
-            reason: input.plan.approval.reason ?? `EphemeralProcedure ${input.plan.procedureId} requires approval`,
-            requestedScopes: input.plan.requiredBaseTools.map((toolId) => `tool.${toolId}`),
-            riskLevel: input.plan.riskLevel,
-            resolver: input.approvalResolver,
-            store: input.store,
-            now: input.now,
-            metadata: {
-                procedureId: input.plan.procedureId,
-                requiredBaseTools: input.plan.requiredBaseTools,
-            },
-        });
-        input.events.push(...approval.events);
-        if (approval.status === "approved") {
-            // Approval was resolved by the application/test harness; execute the procedure below.
-        }
-        else {
-            return {
-                ok: false,
-                records: [],
-                observations: [createObservationMaterial({
-                        observationId: `${input.sessionId}:observation:${input.plan.procedureId}:approval`,
-                        source: "ephemeralProcedure",
-                        status: "waitingApproval",
-                        title: `EphemeralProcedure ${input.plan.procedureId}`,
-                        summary: approval.reason ?? input.plan.approval.reason ?? "procedure requires approval",
-                        refs: [input.plan.procedureId, approval.envelope.approvalId],
-                        payload: approval.envelope,
-                    })],
-                error: kernelError("APPROVAL_REQUIRED", `procedure requires approval: ${input.plan.procedureId}`, "tool"),
-            };
-        }
-    }
-    const pending = new Map(input.plan.steps.map((step) => [step.stepId, step]));
-    const completed = new Set();
-    const records = [];
-    const observations = [];
-    while (pending.size > 0) {
-        const ready = [...pending.values()].filter((step) => step.dependsOn.every((dependency) => completed.has(dependency)));
-        if (ready.length === 0) {
-            return {
-                ok: false,
-                records,
-                observations,
-                error: kernelError("PROCEDURE_INVOCATION_FAILED", `procedure has unresolved dependencies: ${input.plan.procedureId}`, "tool"),
-            };
-        }
-        const wave = input.plan.executionMode === "serial" ? ready.slice(0, 1) : ready;
-        const results = await Promise.all(wave.map(async (step) => {
-            const toolCallId = `${input.plan.procedureId}:${step.stepId}`;
-            await input.onToolCallProgress?.({
-                phase: "started",
-                callId: toolCallId,
-                toolId: step.baseToolId,
-                arguments: step.input,
-            });
-            const result = await executeBaseToolDecision({
-                runtimeId: input.runtimeId,
-                sessionId: input.sessionId,
-                manifest: input.manifest,
-                executor: input.executor,
-                toolCallId,
-                toolId: step.baseToolId,
-                args: step.input,
-                allowToolExecution: input.allowToolExecution,
-                store: input.store,
-                approvalResolver: input.approvalResolver,
-                dependencyRuntime: input.dependencyRuntime,
-                now: input.now,
-                events: input.events,
-            });
-            await input.onToolCallProgress?.({
-                phase: result.record.ok ? "completed" : "failed",
-                record: result.record,
-            });
-            return { step, result };
-        }));
-        for (const { step, result } of results) {
-            records.push(result.record);
-            observations.push(createObservationMaterial({
-                observationId: `${input.sessionId}:observation:${input.plan.procedureId}:${step.stepId}`,
-                source: "ephemeralProcedure",
-                status: result.record.ok ? "completed" : "failed",
-                title: `EphemeralProcedure ${input.plan.procedureId} step ${step.stepId}`,
-                summary: result.record.ok ? "procedure step completed" : "procedure step failed",
-                refs: [input.plan.procedureId, step.stepId, result.record.callId],
-                payload: result.record.ok ? result.record.output : result.record.error,
-                metadata: metadataRecord({
-                    procedureId: input.plan.procedureId,
-                    stepId: step.stepId,
-                    baseToolId: step.baseToolId,
-                    outputRef: step.outputRef,
-                }),
-            }));
-            pending.delete(step.stepId);
-            if (!result.record.ok) {
-                return {
-                    ok: false,
-                    records,
-                    observations,
-                    error: kernelError("PROCEDURE_INVOCATION_FAILED", `procedure step failed: ${step.stepId}`, "tool"),
-                };
-            }
-            completed.add(step.stepId);
-        }
-    }
-    return { ok: true, records, observations };
-}
-export class PraxisRuntimeKernel {
-    runtimeId;
-    store;
-    storeProvided;
-    constructor(options = {}) {
-        this.runtimeId = options.runtimeId;
-        this.store = options.store ?? createInMemorySessionStateEventStore();
-        this.storeProvided = options.store !== undefined;
-    }
-    async run(agent, task, options = {}) {
-        const compiled = compileAgent(agent);
-        if (!compiled.ok) {
-            return {
-                ok: false,
-                error: kernelError("MANIFEST_COMPILE_FAILED", compiled.error.message, "compile"),
-                events: compiled.events,
-            };
-        }
-        return await this.runManifest(compiled.manifest, task, options);
-    }
-    async runManifest(manifest, task, options = {}) {
-        const runtimeId = options.runtimeId ?? this.runtimeId ?? runtimeIdFor(manifest);
-        const sessionId = options.sessionId ?? sessionIdFor(runtimeId, manifest);
-        const now = options.now ?? defaultNow;
-        const events = [];
-        const storageRuntimeResult = createStoragePlaneRuntime({
-            cwd: options.storage?.cwd,
-            raxHome: options.storage?.raxHome,
-            workspaceRoot: options.storage?.workspaceRoot ?? (manifest.storage.kind === "rax-workspace" ? manifest.storage.path : undefined),
-            homeDir: options.storage?.homeDir,
-            env: options.storage?.env,
-            agentId: manifest.identity.id,
-            initMode: options.storage?.initMode ?? manifest.storage.init,
-        });
-        if (!storageRuntimeResult.ok) {
-            const error = kernelError("STORAGE_RESOLUTION_FAILED", storageRuntimeResult.error.message, "runtime-state");
-            return {
-                ok: false,
-                runtimeId,
-                sessionId,
-                manifest,
-                error,
-                mainLoopSteps: [],
-                events: storageRuntimeResult.events,
-                state: { states: [], events: [], invocations: [], mainLoopSteps: [], procedures: [], approvals: [], errors: [] },
-            };
-        }
-        const storageRuntime = storageRuntimeResult.runtime;
-        events.push(...storageRuntimeResult.events);
-        const toolWorkspaceRoot = path.resolve(options.sandbox?.cwd ?? options.storage?.cwd ?? process.cwd());
-        const toolAllowedRoots = Array.from(new Set([
-            toolWorkspaceRoot,
-            storageRuntime.layout.workspace.root,
-        ]));
-        const shouldUseWorkspaceSqlite = options.store === undefined &&
-            !this.storeProvided &&
-            manifest.session.persistence === "sqlite" &&
-            manifest.storage.kind !== "memory";
-        if (shouldUseWorkspaceSqlite && storageRuntime.initMode === "on-run") {
-            const init = await applyRaxStorageInitPlan(storageRuntime.initPlan);
-            events.push(...init.events);
-        }
-        const sqliteStorePath = manifest.storage.kind === "sqlite" && manifest.storage.path !== undefined
-            ? path.resolve(manifest.storage.path)
-            : storageRuntime.layout.workspace.sessionSqlitePath;
-        if (shouldUseWorkspaceSqlite && storageRuntime.initMode === "on-run" && manifest.storage.kind === "sqlite" && manifest.storage.path !== undefined) {
-            await mkdir(path.dirname(sqliteStorePath), { recursive: true });
-            events.push("runtime.storagePlane.sqlitePath.parentReady");
-        }
-        const store = shouldUseWorkspaceSqlite
-            ? await createSqliteSessionStateEventStore(sqliteStorePath)
-            : options.store ?? this.store;
-        const modelCalls = [];
-        const toolCalls = [];
-        const mainLoopSteps = [];
-        const observations = [];
-        const sameTurnCodeReadCache = new Map();
-        const createdAt = now();
-        await store.createSession({
-            sessionId,
-            runtimeId,
-            agentId: manifest.identity.id,
-            manifestHash: manifest.manifestHash,
-            createdAt,
-            status: "running",
-            metadata: {
-                manifestId: manifest.manifestId,
-                storage: storageSessionMetadata(storageRuntime, sqliteStorePath),
-            },
-        });
-        await store.appendState(state(sessionId, "state:received", "received", now()));
-        await store.appendEvent(event(sessionId, "event:session.created", "runtime.session.created", now(), {
-            agentId: manifest.identity.id,
-            storageWorkspaceRef: storageRuntime.layout.refs.workspaceRef,
-        }));
-        const sandboxPrepared = await prepareKernelSandbox({
-            manifest,
-            runtimeId,
-            sessionId,
-            storageRuntime,
-            options,
-            store,
-            now,
-            events,
-        });
-        await recordMainLoopStep({
-            store,
-            sessionId,
-            createdAt: now(),
-            events,
-            mainLoopSteps,
-            step: createMainLoopStepRecord({
-                sessionId,
-                turnIndex: 0,
-                stepIndex: 0,
-                actionPrimitive: "sandboxPrepare",
-                status: sandboxPrepared.ok ? "completed" : "failed",
-                inputRefs: [manifest.sandbox.sandboxId],
-                outputRefs: [sandboxPrepared.sandbox.providerFamily],
-                error: sandboxPrepared.ok ? undefined : {
-                    code: sandboxPrepared.error.code,
-                    message: sandboxPrepared.error.message,
-                    boundary: "runtime-state",
-                    publicSafe: true,
-                },
-                now: now(),
-                metadata: {
-                    providerFamily: sandboxPrepared.sandbox.providerFamily,
-                    profile: sandboxPrepared.sandbox.profile,
-                    probeStatus: sandboxPrepared.sandbox.probe.status,
-                    ready: sandboxPrepared.sandbox.ready,
-                },
-            }),
-        });
-        if (!sandboxPrepared.ok) {
-            await recordKernelError({
-                store,
-                sessionId,
-                errorId: "error:sandbox",
-                error: sandboxPrepared.error,
-                createdAt: now(),
-                metadata: {
-                    sandbox: sandboxPrepared.sandbox,
-                },
-            });
-            await store.updateSessionStatus(sessionId, "failed");
-            const snapshot = await store.readSession(sessionId);
-            return {
-                ok: false,
-                runtimeId,
-                sessionId,
-                manifest,
-                error: sandboxPrepared.error,
-                mainLoopSteps,
-                events,
-                state: snapshot,
-            };
-        }
-        const input = receiveTextInput({
-            runtimeId,
-            sessionId,
-            source: "user",
-            text: task,
-            runtimeReady: true,
-            requestedScopes: ["agent.invoke"],
-            allowedScopes: ["agent.invoke"],
-            governance: { accepted: true },
-        });
-        events.push(...input.events);
-        if (!input.ok) {
-            const error = kernelError("TEXT_INPUT_REJECTED", input.error.message, "io");
-            await recordKernelError({ store, sessionId, errorId: "error:input", error, createdAt: now() });
-            await store.updateSessionStatus(sessionId, "failed");
-            await recordMainLoopStep({
-                store,
-                sessionId,
-                createdAt: now(),
-                events,
-                mainLoopSteps,
-                step: createMainLoopStepRecord({
-                    sessionId,
-                    turnIndex: 0,
-                    stepIndex: 1,
-                    actionPrimitive: "receiveInput",
-                    status: "failed",
-                    inputRefs: ["runtime.input.text"],
-                    error: {
-                        code: input.error.code,
-                        message: input.error.message,
-                        boundary: "input",
-                        publicSafe: true,
-                    },
-                    now: now(),
-                }),
-            });
-            const snapshot = await store.readSession(sessionId);
-            return {
-                ok: false,
-                runtimeId,
-                sessionId,
-                manifest,
-                error,
-                mainLoopSteps,
-                events,
-                state: snapshot,
-            };
-        }
-        await recordMainLoopStep({
-            store,
-            sessionId,
-            createdAt: now(),
-            events,
-            mainLoopSteps,
-            step: createMainLoopStepRecord({
-                sessionId,
-                turnIndex: 0,
-                stepIndex: 1,
-                actionPrimitive: "receiveInput",
-                status: "completed",
-                inputRefs: ["runtime.input.text"],
-                outputRefs: ["runtime.input.normalized"],
-                stateAfterRef: "state:received",
-                now: now(),
-            }),
-        });
-        const dryRun = options.dryRun !== false;
-        const executor = options.executor ?? createRuntimeBaseToolExecutorPort({
-            runtimeId,
-            sessionId,
-            policy: {
-                workspaceRoot: manifest.harness.policy.workspaceRoot,
-                allowedRoots: manifest.harness.policy.allowedRoots,
-                allowShellExecution: manifest.harness.policy.allowToolExecution ?? options.allowToolExecution,
-                allowGitExecution: manifest.harness.policy.allowToolExecution ?? options.allowToolExecution,
-                allowProcessExecution: manifest.harness.policy.allowToolExecution ?? options.allowToolExecution,
-                allowFilesystemWrite: manifest.harness.policy.allowToolExecution ?? options.allowToolExecution,
-                allowFilesystemDelete: manifest.harness.policy.allowToolExecution ?? options.allowToolExecution,
-                allowRipgrep: true,
-                allowNetworkFetch: true,
-                allowNetworkSearch: true,
-                ...(options.baseToolPolicy ?? {}),
-            },
-            resourceLimits: options.baseToolResourceLimits,
-            adapters: options.baseToolAdapters,
-            sandbox: {
-                ...sandboxPrepared.sandbox,
-                policyProfile: manifest.toolPolicy.profile,
-                mountPolicy: manifest.sandbox.mountPolicy,
-                networkPolicy: manifest.sandbox.networkPolicy,
-            },
-            emitEvent: (runtimeEvent) => {
-                events.push(runtimeEvent.type);
-            },
-        });
-        const modelCaller = {
-            kind: "application",
-            id: "praxis-runtime-kernel",
-            sessionId,
-        };
-        const maxModelTurns = manifest.harness.loop.maxModelTurns ?? 2;
-        const maxToolCalls = manifest.harness.loop.maxToolCalls ?? 4;
-        const toolMappings = providerToolMappings(manifest);
-        const providerFamily = providerToolSchemaFamilyForModel(manifest.model);
-        let toolContextSelection = {
-            families: normalizedSelection(options.toolContextSelection?.families),
-            groups: normalizedSelection(options.toolContextSelection?.groups),
-            toolIds: normalizedSelection(options.toolContextSelection?.toolIds),
-        };
-        const providerResponseOutputItems = [];
-        let previousProviderResponse = options.previousProviderResponse;
-        let toolContextHeatState = createBaseToolContextHeatState({
-            agentId: manifest.identity.id,
-            sessionId,
-            usage: options.toolContextUsage,
-            updatedAt: createdAt,
-        });
-        let previousModelCacheDebug;
-        let runnerError;
-        const runnerResult = await runMainLoopRunner({
-            maxModelTurns,
-            maxToolCalls,
-            prepareTurn: async (turn) => {
-                await store.appendState(state(sessionId, `state:model:${turn + 1}`, "model", now(), { turn }));
-                const stepBase = turn * 20 + 2;
-                const prompt = await buildPromptPackAndLower({
-                    runtimeId,
-                    sessionId,
-                    manifest,
-                    task: input.input.normalizedText,
-                    turnIndex: turn,
-                    startStepIndex: stepBase,
-                    now: now(),
-                    modelCaller,
-                    toolMappings,
-                    observations,
-                    events,
-                    toolContextSelection,
-                    toolContextUsage: toolContextHeatState.usage,
-                });
-                toolContextSelection = { families: [], groups: [], toolIds: [] };
-                events.push(...prompt.events);
-                if (!prompt.ok) {
-                    await recordKernelError({ store, sessionId, errorId: `error:prompt:${turn + 1}`, error: prompt.error, createdAt: now() });
-                    await recordMainLoopStep({
-                        store,
-                        sessionId,
-                        createdAt: now(),
-                        events,
-                        mainLoopSteps,
-                        step: createMainLoopStepRecord({
-                            sessionId,
-                            turnIndex: turn,
-                            stepIndex: stepBase,
-                            actionPrimitive: "assemblePromptPack",
-                            status: "failed",
-                            inputRefs: ["runtime.input.normalized", ...observations.map((observation) => observation.observationId)],
-                            error: {
-                                code: prompt.error.code,
-                                message: prompt.error.message,
-                                boundary: "prompt",
-                                publicSafe: true,
-                            },
-                            now: now(),
-                        }),
-                    });
-                    return {
-                        ok: false,
-                        error: {
-                            code: prompt.error.code,
-                            message: prompt.error.message,
-                            boundary: "prompt",
-                            publicSafe: true,
-                        },
-                        events: prompt.events,
-                    };
-                }
-                for (const turnStep of prompt.turnRecord.stepRecords) {
-                    await recordMainLoopStep({
-                        store,
-                        sessionId,
-                        createdAt: now(),
-                        events,
-                        mainLoopSteps,
-                        step: turnStep,
-                    });
-                }
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
-                        sessionId,
-                        turnIndex: turn,
-                        stepIndex: stepBase + 3,
-                        actionPrimitive: "lowerPrompt",
-                        status: "completed",
-                        inputRefs: [prompt.promptPackId],
-                        outputRefs: [prompt.loweredPrompt.loweringId],
-                        promptPackRef: prompt.promptPackId,
-                        loweredPromptRef: prompt.loweredPrompt.loweringId,
-                        now: now(),
-                        metadata: {
-                            materialRefs: prompt.loweredPrompt.materialRefs,
-                            targetCapability: prompt.loweredPrompt.target.capabilityId,
-                        },
-                    }),
-                });
-                return { prompt, events: prompt.events };
-            },
-            invokeModel: async (turn, prompt) => {
-                const stepBase = turn * 20 + 2;
-                const modelInvocationId = `${sessionId}:model:${turn + 1}`;
-                const promptCacheKey = stablePromptCacheKey(manifest, sessionId);
-                const promptSplit = splitPromptPackForProvider(prompt.promptPack);
-                const providerToolResultHistory = providerToolResultHistoryFromObservations(observations);
-                const toolResultInputs = providerToolResultHistory.results
-                    .map((result) => lowerProviderToolResult({ providerFamily, result }));
-                const providerBodyCandidate = buildProviderBodyFromPromptPack(manifest, prompt.promptPack, prompt.providerToolBundle, prompt.providerToolBundle.mappings, {
-                    exposeProviderTools: options.exposeProviderTools,
-                    observations,
-                    previousProviderOutputItems: providerResponseOutputItems,
-                    promptCacheKey,
-                });
-                const candidateCacheDebug = buildPromptPackCacheDebug({
-                    promptPack: prompt.promptPack,
-                    providerBody: providerBodyCandidate,
-                    promptCacheKey,
-                    previousProviderOutputItems: providerResponseOutputItems,
-                    toolResultInputs,
-                    toolResultBudget: providerToolResultHistory.budget,
-                    promptSplit,
-                });
-                const previousProviderResponseId = options.allowPreviousResponseId === true &&
-                    manifest.model.endpointShape !== "chat_completions" &&
-                    manifest.model.provider !== "anthropic" &&
-                    previousProviderResponse !== undefined &&
-                    previousProviderResponse.stablePrefixHash === candidateCacheDebug.providerBody.cacheShape.stablePrefixHash
-                    ? previousProviderResponse.responseId
-                    : undefined;
-                const providerBody = previousProviderResponseId === undefined
-                    ? providerBodyCandidate
-                    : buildProviderBodyFromPromptPack(manifest, prompt.promptPack, prompt.providerToolBundle, prompt.providerToolBundle.mappings, {
-                        exposeProviderTools: options.exposeProviderTools,
-                        observations,
-                        previousProviderOutputItems: providerResponseOutputItems,
-                        previousProviderResponseId,
-                        promptCacheKey,
-                    });
-                const cacheDebug = previousProviderResponseId === undefined
-                    ? candidateCacheDebug
-                    : buildPromptPackCacheDebug({
-                        promptPack: prompt.promptPack,
-                        providerBody,
-                        promptCacheKey,
-                        previousProviderOutputItems: providerResponseOutputItems,
-                        toolResultInputs,
-                        toolResultBudget: providerToolResultHistory.budget,
-                        promptSplit,
-                    });
-                await options.onModelCallProgress?.({
-                    phase: "started",
-                    invocationId: modelInvocationId,
-                    turnIndex: turn,
-                    provider: manifest.model.provider,
-                    carrierId: manifest.model.carrierId,
-                    model: manifest.model.model,
-                });
-                const modelResult = await invokeModelThroughRuntime({
-                    runtimeId,
-                    invocationId: modelInvocationId,
-                    caller: modelCaller,
-                    loweredPrompt: prompt.loweredPrompt,
-                    capability: modelInvocationCapabilityForModel(manifest.model),
-                    carrier: {
-                        carrierId: manifest.model.carrierId,
-                        provider: manifest.model.provider,
-                        endpointShape: manifest.model.endpointShape,
-                        baseURL: manifest.model.baseURL,
-                        metadata: manifest.model.metadata,
-                    },
-                    mode: "single",
-                    dryRun,
-                    allowProviderCall: options.allowProviderCall ?? manifest.harness.policy.allowProviderCall ?? !dryRun,
-                    auth: options.auth,
-                    providerCaller: options.providerCaller,
-                    openaiResponsesCaller: options.openaiResponsesCaller,
-                    openaiChatCompletionsCaller: options.openaiChatCompletionsCaller,
-                    anthropicMessagesCaller: options.anthropicMessagesCaller,
-                    providerBody,
-                    governance: { accepted: true },
-                    contract: { accepted: true },
-                    clientName: manifest.model.clientName,
-                    clientVersion: manifest.model.clientVersion,
-                });
-                const modelUsage = modelResult.ok && modelResult.usage
-                    ? {
-                        inputTokens: modelResult.usage.inputTokens,
-                        outputTokens: modelResult.usage.outputTokens,
-                        thinkingTokens: "reasoningTokens" in modelResult.usage ? modelResult.usage.reasoningTokens : undefined,
-                        totalTokens: modelResult.usage.totalTokens,
-                        cachedInputTokens: "cachedInputTokens" in modelResult.usage ? modelResult.usage.cachedInputTokens : undefined,
-                        source: modelResult.usage.source,
-                        estimated: modelResult.usage.estimated,
-                    }
-                    : undefined;
-                const providerRouting = modelResult.ok
-                    ? providerRoutingDebug(providerResponseHeadersForKernel(modelResult.providerResult))
-                    : undefined;
-                const providerResponseId = modelResult.ok ? extractOpenAIResponseId(modelResult.raw) : undefined;
-                const observedCacheDebug = cacheDebugWithPreviousComparison(cacheDebugWithObservedUsage(cacheDebug, modelUsage), previousModelCacheDebug);
-                previousModelCacheDebug = observedCacheDebug;
-                await options.onModelCallProgress?.({
-                    phase: modelResult.ok ? "completed" : "failed",
-                    invocationId: modelInvocationId,
-                    turnIndex: turn,
-                    provider: manifest.model.provider,
-                    carrierId: manifest.model.carrierId,
-                    model: manifest.model.model,
-                    ok: modelResult.ok,
-                    usage: modelUsage,
-                    providerRouting,
-                    cacheDebug: observedCacheDebug,
-                    providerResponseId,
-                    previousProviderResponseId,
-                    error: modelResult.ok
-                        ? undefined
-                        : kernelError("MODEL_INVOCATION_FAILED", modelResult.error.message, "model"),
-                });
-                events.push(...modelResult.events);
-                modelCalls.push({
-                    invocationId: modelInvocationId,
-                    raw: modelResult.ok ? modelResult.raw : null,
-                    ok: modelResult.ok,
-                    usage: modelUsage,
-                    providerRouting,
-                    providerResponseId,
-                    previousProviderResponseId,
-                });
-                await store.appendInvocation(invocation(sessionId, modelInvocationId, "model", manifest.model.carrierId, modelResult.ok, now(), {
-                    turn,
-                    promptPackId: prompt.promptPackId,
-                    loweringId: prompt.loweredPrompt.loweringId,
-                }));
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
-                        sessionId,
-                        turnIndex: turn,
-                        stepIndex: stepBase + 4,
-                        actionPrimitive: "invokeModel",
-                        status: modelResult.ok ? "completed" : "failed",
-                        inputRefs: [prompt.loweredPrompt.loweringId],
-                        outputRefs: [modelInvocationId],
-                        modelCallId: modelInvocationId,
-                        promptPackRef: prompt.promptPackId,
-                        loweredPromptRef: prompt.loweredPrompt.loweringId,
-                        error: modelResult.ok ? undefined : {
-                            code: modelResult.error.code,
-                            message: modelResult.error.message,
-                            boundary: "model",
-                            publicSafe: true,
-                        },
-                        now: now(),
-                        metadata: { turn },
-                    }),
-                });
-                await recordHandoffPlan({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    turnIndex: turn,
-                    startStepIndex: stepBase + 20,
-                    tickKind: "model-only",
-                    promptPackRef: prompt.promptPackId,
-                    loweredPromptRef: prompt.loweredPrompt.loweringId,
-                    modelCallId: modelInvocationId,
-                    inputRefs: [prompt.promptPackId, prompt.loweredPrompt.loweringId],
-                    outputRefs: [modelInvocationId],
-                });
-                if (!modelResult.ok) {
-                    const error = kernelError("MODEL_INVOCATION_FAILED", modelResult.error.message, "model");
-                    runnerError = error;
-                    await recordKernelError({ store, sessionId, errorId: `error:model:${turn + 1}`, error, createdAt: now(), metadata: { modelInvocationId } });
-                    return {
-                        ok: false,
-                        modelCallId: modelInvocationId,
-                        error: {
-                            code: error.code,
-                            message: error.message,
-                            boundary: "model",
-                            publicSafe: true,
-                        },
-                        events: modelResult.events,
-                    };
-                }
-                providerResponseOutputItems.push(...extractProviderOutputItems(modelResult.raw, providerFamily));
-                if (providerResponseId !== undefined) {
-                    previousProviderResponse = {
-                        responseId: providerResponseId,
-                        stablePrefixHash: observedCacheDebug.providerBody.cacheShape.stablePrefixHash,
-                    };
-                }
-                return {
-                    ok: true,
-                    modelCallId: modelInvocationId,
-                    raw: modelResult.raw,
-                    events: modelResult.events,
-                };
-            },
-            interpretDecision: async (turn, model, prompt) => {
-                const stepBase = turn * 20 + 2;
-                const decisionResult = interpretModelDecision({
-                    raw: model.raw,
-                    sessionId,
-                    turnIndex: turn,
-                    providerFamily,
-                    providerToolMappings: toolMappings,
-                    providerRawRef: model.modelCallId,
-                });
-                events.push(...decisionResult.events);
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
-                        sessionId,
-                        turnIndex: turn,
-                        stepIndex: stepBase + 5,
-                        actionPrimitive: "interpretModelDecision",
-                        status: decisionResult.ok ? "completed" : "failed",
-                        inputRefs: [model.modelCallId],
-                        outputRefs: decisionResult.ok ? decisionResult.decisions.map((decision) => decision.decisionId) : [],
-                        modelCallId: model.modelCallId,
-                        promptPackRef: prompt.promptPackId,
-                        error: decisionResult.ok ? undefined : {
-                            code: decisionResult.error.code,
-                            message: decisionResult.error.message,
-                            boundary: "model",
-                            publicSafe: true,
-                        },
-                        now: now(),
-                        metadata: {
-                            decisionKinds: decisionResult.ok ? decisionResult.decisions.map((decision) => decision.kind) : [],
-                        },
-                    }),
-                });
-                if (!decisionResult.ok) {
-                    const error = kernelError("MODEL_DECISION_FAILED", decisionResult.error.message, "model");
-                    runnerError = error;
-                    await recordKernelError({ store, sessionId, errorId: `error:modelDecision:${turn + 1}`, error, createdAt: now(), metadata: { modelInvocationId: model.modelCallId } });
-                    return {
-                        ok: false,
-                        error: {
-                            code: error.code,
-                            message: error.message,
-                            boundary: "model-decision",
-                            publicSafe: true,
-                        },
-                        events: decisionResult.events,
-                    };
-                }
-                return { ok: true, decisions: decisionResult.decisions, events: decisionResult.events };
-            },
-            acceptFinalOutput: async ({ turnIndex: turn, decisionIndex, decision }) => {
-                const finalAcceptance = decideMainLoopFinalAcceptance({
-                    finalOutput: decision.finalOutput ?? "",
-                    fatalFailureRefs: runnerError === undefined ? [] : [runnerError.code],
-                });
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
-                        sessionId,
-                        turnIndex: turn,
-                        stepIndex: turn * 20 + 60 + decisionIndex,
-                        actionPrimitive: "adjudicateDecision",
-                        status: finalAcceptance.canBreak ? "completed" : "failed",
-                        inputRefs: [decision.decisionId],
-                        outputRefs: finalAcceptance.canBreak ? ["runtime.final.accepted"] : finalAcceptance.blockingRefs,
-                        error: finalAcceptance.canBreak ? undefined : {
-                            code: "FINAL_OUTPUT_REJECTED",
-                            message: finalAcceptance.reason,
-                            boundary: "output",
-                            publicSafe: true,
-                        },
-                        now: now(),
-                        metadata: {
-                            decisionKind: decision.kind,
-                            finalAcceptanceKind: finalAcceptance.kind,
-                            canBreak: finalAcceptance.canBreak,
-                        },
-                    }),
-                });
-                if (!finalAcceptance.canBreak) {
-                    return {
-                        ok: false,
-                        error: {
-                            code: "FINAL_OUTPUT_REJECTED",
-                            message: finalAcceptance.reason,
-                            boundary: "output",
-                            publicSafe: true,
-                        },
-                        events: ["agentCore.execution.mainLoop.runner.finalOutputRejected"],
-                    };
-                }
-                return {
-                    ok: true,
-                    finalOutput: finalAcceptance.finalOutput ?? "",
-                    events: ["agentCore.execution.mainLoop.runner.finalOutputAccepted"],
-                };
-            },
-            handleContinue: async ({ turnIndex: turn, decisionIndex, decision }) => {
-                const expansion = decision.toolContextExpansion;
-                if (expansion === undefined) {
-                    return {
-                        ok: true,
-                        continueLoop: true,
-                        events: ["agentCore.execution.mainLoop.runner.continue"],
-                    };
-                }
-                if (expansion.targetKind === "family" && expansion.family !== undefined && !toolContextSelection.families.includes(expansion.family)) {
-                    toolContextSelection.families.push(expansion.family);
-                }
-                if (expansion.targetKind === "group" && expansion.family !== undefined && expansion.group !== undefined) {
-                    const groupId = `${expansion.family}/${expansion.group}`;
-                    if (!toolContextSelection.groups.includes(groupId))
-                        toolContextSelection.groups.push(groupId);
-                }
-                if (expansion.targetKind === "tool" && expansion.toolId !== undefined && !toolContextSelection.toolIds.includes(expansion.toolId)) {
-                    toolContextSelection.toolIds.push(expansion.toolId);
-                }
-                const providerCallId = typeof decision.metadata.callId === "string" && decision.metadata.callId.trim().length > 0
-                    ? decision.metadata.callId.trim()
-                    : undefined;
-                if (providerCallId !== undefined) {
-                    observations.push(createObservationMaterial({
-                        observationId: `${sessionId}:observation:${providerCallId}:tool-context-expanded`,
-                        source: "runtime",
-                        status: "completed",
-                        title: "BaseTool context expanded",
-                        summary: `Expanded ${expansion.targetKind} BaseTool context for the next turn.`,
-                        refs: [providerCallId, decision.decisionId],
-                        payload: {
-                            expanded: expansion,
-                            selection: {
-                                families: [...toolContextSelection.families],
-                                groups: [...toolContextSelection.groups],
-                                toolIds: [...toolContextSelection.toolIds],
-                            },
-                        },
-                        trustLevel: "runtimeFact",
-                        metadata: metadataRecord({
-                            toolCallId: providerCallId,
-                            toolId: "praxis_expand_tool_context",
-                            providerToolName: "praxis_expand_tool_context",
-                            observationStatus: "completed",
-                            runtimeDecision: "expandToolContext",
-                        }),
-                    }));
-                }
-                const stepBase = turn * 20 + 2;
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
-                        sessionId,
-                        turnIndex: turn,
-                        stepIndex: stepBase + 6 + decisionIndex,
-                        actionPrimitive: "emitEvent",
-                        status: "completed",
-                        inputRefs: [decision.decisionId],
-                        outputRefs: [
-                            ...(expansion.family === undefined ? [] : [`baseToolContext.family:${expansion.family}`]),
-                            ...(expansion.group === undefined || expansion.family === undefined ? [] : [`baseToolContext.group:${expansion.family}/${expansion.group}`]),
-                            ...(expansion.toolId === undefined ? [] : [`baseToolContext.tool:${expansion.toolId}`]),
-                        ],
-                        now: now(),
-                        metadata: {
-                            runtimeDecision: "expandToolContext",
-                            expansion,
-                            reason: expansion.reason ?? "model requested folded BaseTool documentation",
-                            selection: {
-                                families: [...toolContextSelection.families],
-                                groups: [...toolContextSelection.groups],
-                                toolIds: [...toolContextSelection.toolIds],
-                            },
-                        },
-                    }),
-                });
-                return {
-                    ok: true,
-                    continueLoop: true,
-                    events: ["agentCore.execution.mainLoop.runner.expandToolContext"],
-                };
-            },
-            handleFailure: async ({ turnIndex: turn, decisionIndex, decision }) => {
-                const stepBase = turn * 20 + 2;
-                const error = kernelError("MODEL_DECISION_FAILED", decision.failure?.message ?? "model decision requested failure", "model");
-                runnerError = error;
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
-                        sessionId,
-                        turnIndex: turn,
-                        stepIndex: stepBase + 6 + decisionIndex,
-                        actionPrimitive: "fail",
-                        status: "failed",
-                        inputRefs: [decision.decisionId],
-                        error: {
-                            code: decision.failure?.code ?? "MODEL_DECISION_FAILED",
-                            message: decision.failure?.message ?? "model decision requested failure",
-                            boundary: "model",
-                            publicSafe: true,
-                        },
-                        now: now(),
-                    }),
-                });
-                await recordKernelError({
-                    store,
-                    sessionId,
-                    errorId: `error:modelDecisionFail:${turn + 1}:${decisionIndex}`,
-                    error,
-                    createdAt: now(),
-                    metadata: {
-                        decisionId: decision.decisionId,
-                        providerRawRef: decision.metadata.providerRawRef,
-                    },
-                });
-                return {
-                    ok: false,
-                    error: {
-                        code: error.code,
-                        message: error.message,
-                        boundary: "model-decision",
-                        publicSafe: true,
-                    },
-                    events: ["agentCore.execution.mainLoop.runner.fail"],
-                };
-            },
-            handleApproval: async ({ turnIndex: turn, decisionIndex, decision }) => {
-                const stepBase = turn * 20 + 2;
-                const approval = await requestRuntimeApproval({
-                    runtimeId,
-                    sessionId,
-                    approvalId: `${decision.decisionId}:approval`,
-                    source: "model",
-                    reason: decision.approvalRequest?.reason ?? "model requested approval",
-                    requestedScopes: decision.approvalRequest?.requestedScopes ?? [],
-                    riskLevel: decision.approvalRequest?.riskLevel,
-                    resolver: options.approvalResolver,
-                    store,
-                    now,
-                    metadata: {
-                        decisionId: decision.decisionId,
-                        modelCallId: `${sessionId}:model:${turn + 1}`,
-                    },
-                });
-                events.push(...approval.events);
-                await recordHandoffPlan({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    turnIndex: turn,
-                    startStepIndex: stepBase + 30 + decisionIndex * 10,
-                    tickKind: "approval-wait",
-                    inputRefs: [decision.decisionId],
-                    outputRefs: [approval.envelope.approvalId],
-                });
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
-                        sessionId,
-                        turnIndex: turn,
-                        stepIndex: stepBase + 6 + decisionIndex,
-                        actionPrimitive: "requestApproval",
-                        status: "waitingApproval",
-                        inputRefs: [decision.decisionId],
-                        outputRefs: decision.approvalRequest?.requestedScopes ?? [],
-                        now: now(),
-                        metadata: {
-                            reason: decision.approvalRequest?.reason ?? "model requested approval",
-                            riskLevel: decision.approvalRequest?.riskLevel ?? "unknown",
-                            approvalId: approval.envelope.approvalId,
-                            approvalStatus: approval.status,
-                        },
-                    }),
-                });
-                if (approval.status === "approved") {
-                    const providerCallId = typeof decision.metadata.callId === "string" && decision.metadata.callId.trim().length > 0
-                        ? decision.metadata.callId.trim()
-                        : undefined;
-                    if (providerCallId !== undefined) {
-                        observations.push(createObservationMaterial({
-                            observationId: `${sessionId}:observation:${providerCallId}:approval`,
-                            source: "runtime",
-                            status: "completed",
-                            title: "Runtime approval resolved",
-                            summary: approval.reason ?? "model approval request was approved",
-                            refs: [providerCallId, decision.decisionId, approval.envelope.approvalId],
-                            payload: {
-                                status: approval.status,
-                                reason: approval.reason,
-                                approvalId: approval.envelope.approvalId,
-                                requestedScopes: approval.envelope.requestedScopes,
-                                riskLevel: approval.envelope.riskLevel,
-                            },
-                            trustLevel: "runtimeFact",
-                            metadata: metadataRecord({
-                                toolCallId: providerCallId,
-                                toolId: "praxis.request.approval",
-                                providerToolName: "praxis_request_approval",
-                                observationStatus: "completed",
-                                runtimeDecision: "requestApproval",
-                                approvalId: approval.envelope.approvalId,
-                                approvalStatus: approval.status,
-                            }),
-                        }));
-                    }
-                    return { ok: true, continueLoop: true, events: approval.events };
-                }
-                const error = kernelError("APPROVAL_REQUIRED", decision.approvalRequest?.reason ?? "model requested approval", "tool");
-                runnerError = error;
-                await recordKernelError({
-                    store,
-                    sessionId,
-                    errorId: `error:approval:${approval.envelope.approvalId}`,
-                    error,
-                    createdAt: now(),
-                    metadata: {
-                        approvalId: approval.envelope.approvalId,
-                        approvalStatus: approval.status,
-                        decisionId: decision.decisionId,
-                    },
-                });
-                return {
-                    ok: false,
-                    error: {
-                        code: error.code,
-                        message: error.message,
-                        boundary: "approval",
-                        publicSafe: true,
-                    },
-                    events: approval.events,
-                };
-            },
-            handleToolCall: async ({ turnIndex: turn, decisionIndex, decision }) => {
-                const stepBase = turn * 20 + 2;
-                if (decision.toolCall === undefined) {
-                    return {
-                        ok: false,
-                        error: {
-                            code: "MISSING_TOOL_CALL",
-                            message: "toolCall decision is missing tool call payload",
-                            boundary: "tool",
-                            publicSafe: true,
-                        },
-                        events: ["agentCore.execution.mainLoop.runner.toolCallRejected"],
-                    };
-                }
-                const preambleText = decision.preambleText?.trim();
-                if (preambleText) {
-                    await options.onTextDelta?.(preambleText, {
-                        source: "model_tool_preamble",
-                        decisionId: decision.decisionId,
-                        toolCallId: decision.toolCall.callId,
-                        toolId: decision.toolCall.toolId,
-                    });
-                }
-                await recordHandoffPlan({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    turnIndex: turn,
-                    startStepIndex: stepBase + 40 + decisionIndex * 10,
-                    tickKind: "tool-call",
-                    toolCallId: decision.toolCall.callId,
-                    inputRefs: [decision.decisionId],
-                });
-                await store.appendState(state(sessionId, `state:tool:${decision.toolCall.callId}`, "tool", now(), {
-                    toolId: decision.toolCall.toolId,
-                    providerToolName: decision.toolCall.providerToolName,
-                }));
-                await options.onToolCallProgress?.({
-                    phase: "started",
-                    callId: decision.toolCall.callId,
-                    toolId: decision.toolCall.toolId,
-                    providerToolName: decision.toolCall.providerToolName,
-                    arguments: decision.toolCall.arguments,
-                });
-                const readCacheKey = codeReadCacheKey(decision.toolCall.toolId, decision.toolCall.arguments);
-                const cachedRead = readCacheKey === undefined ? undefined : sameTurnCodeReadCache.get(readCacheKey);
-                if (cachedRead?.fullFileRead === true) {
-                    const reused = duplicateCodeReadRecord({
-                        sessionId,
-                        toolCallId: decision.toolCall.callId,
-                        toolId: decision.toolCall.toolId,
-                        providerToolName: decision.toolCall.providerToolName,
-                        args: decision.toolCall.arguments,
-                        previousCallId: cachedRead.callId,
-                        now: now(),
-                    });
-                    await options.onToolCallProgress?.({
-                        phase: "completed",
-                        providerToolName: decision.toolCall.providerToolName,
-                        record: reused.record,
-                    });
-                    toolCalls.push(reused.record);
-                    observations.push(reused.observation);
-                    await store.appendInvocation(invocation(sessionId, reused.record.callId, "tool", reused.record.toolId, true, now(), {
-                        ok: true,
-                        decisionId: decision.decisionId,
-                        duplicateOfToolCallId: cachedRead.callId,
-                    }));
-                    await recordMainLoopStep({
-                        store,
-                        sessionId,
-                        createdAt: now(),
-                        events,
-                        mainLoopSteps,
-                        step: createMainLoopStepRecord({
-                            sessionId,
-                            turnIndex: turn,
-                            stepIndex: stepBase + 6 + decisionIndex,
-                            actionPrimitive: "invokeBaseTool",
-                            status: "completed",
-                            inputRefs: [decision.decisionId],
-                            outputRefs: [reused.record.callId],
-                            toolCallId: reused.record.callId,
-                            observationRefs: [reused.observation.observationId],
-                            now: now(),
-                            metadata: {
-                                toolId: reused.record.toolId,
-                                providerToolName: decision.toolCall.providerToolName ?? "",
-                                duplicateObservationReuse: true,
-                                duplicateOfToolCallId: cachedRead.callId,
-                            },
-                        }),
-                    });
-                    return { ok: true, continueLoop: true, events: ["runtime.baseTool.codeRead.duplicateObservationReused"] };
-                }
-                const executed = await executeBaseToolDecision({
-                    runtimeId,
-                    sessionId,
-                    manifest,
-                    executor,
-                    toolCallId: decision.toolCall.callId,
-                    toolId: decision.toolCall.toolId,
-                    providerToolName: decision.toolCall.providerToolName,
-                    args: decision.toolCall.arguments,
-                    workspaceRoot: toolWorkspaceRoot,
-                    allowedRoots: toolAllowedRoots,
-                    allowToolExecution: options.allowToolExecution,
-                    store,
-                    approvalResolver: options.approvalResolver,
-                    dependencyRuntime: options.baseToolDependencyRuntime,
-                    now,
-                    events,
-                });
-                await options.onToolCallProgress?.({
-                    phase: executed.record.ok ? "completed" : "failed",
-                    providerToolName: decision.toolCall.providerToolName,
-                    record: executed.record,
-                });
-                toolCalls.push(executed.record);
-                observations.push(executed.observation);
-                if (isCodeMutationTool(executed.record.toolId)) {
-                    sameTurnCodeReadCache.clear();
-                }
-                else if (readCacheKey !== undefined && executed.record.ok) {
-                    const output = isRecord(executed.record.output) ? executed.record.output : undefined;
-                    const truncated = output?.truncated === true;
-                    sameTurnCodeReadCache.set(readCacheKey, {
-                        callId: executed.record.callId,
-                        fullFileRead: !codeReadHasRange(executed.record.arguments) && !truncated,
-                    });
-                }
-                toolContextHeatState = applyBaseToolContextUsage(toolContextHeatState, [{ toolId: executed.record.toolId }], now());
-                await store.appendState(state(sessionId, `state:toolContextHeat:${executed.record.callId}`, "toolContextHeat", now(), {
-                    agentId: toolContextHeatState.agentId,
-                    usage: toolContextHeatState.usage,
-                }));
-                await store.appendInvocation(invocation(sessionId, executed.record.callId, "tool", executed.record.toolId, executed.record.ok, now(), {
-                    ok: executed.record.ok,
-                    decisionId: decision.decisionId,
-                }));
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
-                        sessionId,
-                        turnIndex: turn,
-                        stepIndex: stepBase + 6 + decisionIndex,
-                        actionPrimitive: "invokeBaseTool",
-                        status: executed.record.ok ? "completed" : (isRecord(executed.record.error) && executed.record.error.code === "APPROVAL_REQUIRED" ? "waitingApproval" : "failed"),
-                        inputRefs: [decision.decisionId],
-                        outputRefs: [executed.record.callId],
-                        toolCallId: executed.record.callId,
-                        observationRefs: [executed.observation.observationId],
-                        error: executed.record.ok ? undefined : {
-                            code: "TOOL_INVOCATION_FAILED",
-                            message: `tool invocation failed: ${executed.record.toolId}`,
-                            boundary: "tool",
-                            publicSafe: true,
-                        },
-                        now: now(),
-                        metadata: {
-                            toolId: executed.record.toolId,
-                            providerToolName: decision.toolCall.providerToolName ?? "",
-                        },
-                    }),
-                });
-                if (!executed.record.ok) {
-                    const approvalRequired = isRecord(executed.record.error) && executed.record.error.code === "APPROVAL_REQUIRED";
-                    const error = approvalRequired
-                        ? kernelError("APPROVAL_REQUIRED", `tool invocation requires approval: ${executed.record.toolId}`, "tool")
-                        : kernelError("TOOL_INVOCATION_FAILED", `tool invocation failed: ${executed.record.toolId}`, "tool");
-                    await recordKernelError({
-                        store,
-                        sessionId,
-                        errorId: `error:tool:${executed.record.callId}`,
-                        error,
-                        createdAt: now(),
-                        metadata: {
-                            toolCallId: executed.record.callId,
-                            toolId: executed.record.toolId,
-                            approvalRequired,
-                        },
-                    });
-                    if (!approvalRequired) {
-                        return {
-                            ok: true,
-                            continueLoop: true,
-                            events: [...executed.events, "agentCore.execution.mainLoop.runner.toolFailureObservation"],
-                        };
-                    }
-                    runnerError = error;
-                    return {
-                        ok: false,
-                        error: {
-                            code: error.code,
-                            message: error.message,
-                            boundary: approvalRequired ? "approval" : "tool",
-                            publicSafe: true,
-                        },
-                        events: executed.events,
-                    };
-                }
-                return { ok: true, continueLoop: true, events: executed.events };
-            },
-            handleEphemeralProcedure: async ({ turnIndex: turn, decisionIndex, decision }) => {
-                const stepBase = turn * 20 + 2;
-                if (decision.ephemeralProcedurePlan === undefined) {
-                    return {
-                        ok: false,
-                        error: {
-                            code: "MISSING_EPHEMERAL_PROCEDURE_PLAN",
-                            message: "ephemeralProcedurePlan decision is missing a procedure plan",
-                            boundary: "procedure",
-                            publicSafe: true,
-                        },
-                        events: ["agentCore.execution.mainLoop.runner.procedureRejected"],
-                    };
-                }
-                const procedureCreatedAt = now();
-                await recordHandoffPlan({
-                    store,
-                    sessionId,
-                    createdAt: procedureCreatedAt,
-                    events,
-                    mainLoopSteps,
-                    turnIndex: turn,
-                    startStepIndex: stepBase + 50 + decisionIndex * 10,
-                    tickKind: "ephemeral-procedure",
-                    procedureId: decision.ephemeralProcedurePlan.procedureId,
-                    inputRefs: [decision.decisionId],
-                });
-                await store.appendProcedure({
-                    sessionId,
-                    procedureId: decision.ephemeralProcedurePlan.procedureId,
-                    status: decision.ephemeralProcedurePlan.approval.required ? "waitingApproval" : "running",
-                    createdAt: procedureCreatedAt,
-                    summary: {
-                        decisionId: decision.decisionId,
-                        executionMode: decision.ephemeralProcedurePlan.executionMode,
-                        requiredBaseTools: decision.ephemeralProcedurePlan.requiredBaseTools,
-                        riskLevel: decision.ephemeralProcedurePlan.riskLevel,
-                    },
-                });
-                await store.appendInvocation(invocation(sessionId, decision.ephemeralProcedurePlan.procedureId, "procedure", decision.ephemeralProcedurePlan.purpose, true, now(), {
-                    decisionId: decision.decisionId,
-                    status: "planned",
-                }));
-                const procedureResult = await executeEphemeralProcedure({
-                    runtimeId,
-                    sessionId,
-                    manifest,
-                    executor,
-                    plan: decision.ephemeralProcedurePlan,
-                    allowToolExecution: options.allowToolExecution,
-                    store,
-                    approvalResolver: options.approvalResolver,
-                    dependencyRuntime: options.baseToolDependencyRuntime,
-                    onToolCallProgress: options.onToolCallProgress,
-                    now,
-                    events,
-                });
-                await store.appendProcedure({
-                    sessionId,
-                    procedureId: decision.ephemeralProcedurePlan.procedureId,
-                    status: procedureResult.ok ? "completed" : (procedureResult.error?.code === "APPROVAL_REQUIRED" ? "waitingApproval" : "failed"),
-                    createdAt: procedureCreatedAt,
-                    updatedAt: now(),
-                    summary: {
-                        decisionId: decision.decisionId,
-                        executionMode: decision.ephemeralProcedurePlan.executionMode,
-                        requiredBaseTools: decision.ephemeralProcedurePlan.requiredBaseTools,
-                        recordCount: procedureResult.records.length,
-                        observationCount: procedureResult.observations.length,
-                        errorCode: procedureResult.error?.code,
-                    },
-                });
-                toolCalls.push(...procedureResult.records);
-                observations.push(...procedureResult.observations);
-                const providerCallId = typeof decision.metadata.callId === "string" && decision.metadata.callId.trim().length > 0
-                    ? decision.metadata.callId.trim()
-                    : undefined;
-                if (providerCallId !== undefined) {
-                    observations.push(createObservationMaterial({
-                        observationId: `${sessionId}:observation:${providerCallId}:ephemeral-procedure`,
-                        source: "ephemeralProcedure",
-                        status: procedureResult.ok ? "completed" : (procedureResult.error?.code === "APPROVAL_REQUIRED" ? "waitingApproval" : "failed"),
-                        title: `EphemeralProcedure ${decision.ephemeralProcedurePlan.procedureId}`,
-                        summary: procedureResult.ok
-                            ? "ephemeral procedure completed"
-                            : procedureResult.error?.message ?? "ephemeral procedure failed",
-                        refs: [providerCallId, decision.decisionId, decision.ephemeralProcedurePlan.procedureId],
-                        payload: {
-                            ok: procedureResult.ok,
-                            procedureId: decision.ephemeralProcedurePlan.procedureId,
-                            recordCount: procedureResult.records.length,
-                            observationCount: procedureResult.observations.length,
-                            error: procedureResult.error,
-                        },
-                        metadata: metadataRecord({
-                            toolCallId: providerCallId,
-                            toolId: "praxis_ephemeral_procedure",
-                            providerToolName: "praxis_ephemeral_procedure",
-                            observationStatus: procedureResult.ok ? "completed" : "failed",
-                            procedureId: decision.ephemeralProcedurePlan.procedureId,
-                        }),
-                    }));
-                }
-                if (procedureResult.records.length > 0) {
-                    toolContextHeatState = applyBaseToolContextUsage(toolContextHeatState, procedureResult.records.map((record) => ({ toolId: record.toolId })), now());
-                    await store.appendState(state(sessionId, `state:toolContextHeat:${decision.ephemeralProcedurePlan.procedureId}`, "toolContextHeat", now(), {
-                        agentId: toolContextHeatState.agentId,
-                        procedureId: decision.ephemeralProcedurePlan.procedureId,
-                        usage: toolContextHeatState.usage,
-                    }));
-                }
-                for (const record of procedureResult.records) {
-                    await store.appendInvocation(invocation(sessionId, record.callId, "tool", record.toolId, record.ok, now(), {
-                        ok: record.ok,
-                        procedureId: decision.ephemeralProcedurePlan.procedureId,
-                        decisionId: decision.decisionId,
-                    }));
-                }
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
-                        sessionId,
-                        turnIndex: turn,
-                        stepIndex: stepBase + 6 + decisionIndex,
-                        actionPrimitive: "executeEphemeralProcedure",
-                        status: procedureResult.ok ? "completed" : (procedureResult.error?.code === "APPROVAL_REQUIRED" ? "waitingApproval" : "failed"),
-                        inputRefs: [decision.decisionId],
-                        outputRefs: procedureResult.records.map((record) => record.callId),
-                        procedureId: decision.ephemeralProcedurePlan.procedureId,
-                        observationRefs: procedureResult.observations.map((observation) => observation.observationId),
-                        error: procedureResult.ok || procedureResult.error === undefined ? undefined : {
-                            code: procedureResult.error.code,
-                            message: procedureResult.error.message,
-                            boundary: "procedure",
-                            publicSafe: true,
-                        },
-                        now: now(),
-                        metadata: {
-                            executionMode: decision.ephemeralProcedurePlan.executionMode,
-                            requiredBaseTools: decision.ephemeralProcedurePlan.requiredBaseTools,
-                        },
-                    }),
-                });
-                if (!procedureResult.ok) {
-                    const error = procedureResult.error ?? kernelError("PROCEDURE_INVOCATION_FAILED", "procedure invocation failed", "tool");
-                    await recordKernelError({
-                        store,
-                        sessionId,
-                        errorId: `error:procedure:${decision.ephemeralProcedurePlan.procedureId}`,
-                        error,
-                        createdAt: now(),
-                        metadata: {
-                            procedureId: decision.ephemeralProcedurePlan.procedureId,
-                            decisionId: decision.decisionId,
-                            approvalRequired: error.code === "APPROVAL_REQUIRED",
-                        },
-                    });
-                    if (error.code !== "APPROVAL_REQUIRED") {
-                        return {
-                            ok: true,
-                            continueLoop: true,
-                            events: ["agentCore.execution.mainLoop.runner.procedureFailureObservation"],
-                        };
-                    }
-                    runnerError = error;
-                    return {
-                        ok: false,
-                        error: {
-                            code: error.code,
-                            message: error.message,
-                            boundary: error.code === "APPROVAL_REQUIRED" ? "approval" : "procedure",
-                            publicSafe: true,
-                        },
-                        events: [],
-                    };
-                }
-                return { ok: true, continueLoop: true, events: [] };
-            },
-            onModelDryRun: async () => ({
-                ok: true,
-                finalOutput: "PraxisRuntimeKernel dry-run completed.",
-                events: ["agentCore.execution.mainLoop.runner.dryRunFinal"],
-            }),
-            onNoFinalOutput: async (input) => ({
-                ok: true,
-                finalOutput: input.reason === "tool_call_limit"
-                    ? "PraxisRuntimeKernel reached the tool call limit before a final answer."
-                    : input.reason === "no_continuation"
-                        ? "PraxisRuntimeKernel stopped without a final answer."
-                        : "PraxisRuntimeKernel reached the model turn limit before a final answer.",
-                events: [`agentCore.execution.mainLoop.runner.noFinalOutput.${input.reason}`],
-            }),
-        });
-        events.push(...runnerResult.events);
-        if (!runnerResult.ok) {
-            const fallbackCode = runnerResult.error.boundary === "prompt"
-                ? "PROMPT_PACK_FAILED"
-                : runnerResult.error.boundary === "model" || runnerResult.error.boundary === "model-decision"
-                    ? "MODEL_DECISION_FAILED"
-                    : runnerResult.error.boundary === "tool"
-                        ? "TOOL_INVOCATION_FAILED"
-                        : runnerResult.error.boundary === "procedure"
-                            ? "PROCEDURE_INVOCATION_FAILED"
-                            : runnerResult.error.boundary === "approval"
-                                ? "APPROVAL_REQUIRED"
-                                : "TEXT_OUTPUT_REJECTED";
-            const fallbackBoundary = runnerResult.error.boundary === "model" || runnerResult.error.boundary === "model-decision"
-                ? "model"
-                : runnerResult.error.boundary === "tool" || runnerResult.error.boundary === "procedure" || runnerResult.error.boundary === "approval"
-                    ? "tool"
-                    : runnerResult.error.boundary === "output"
-                        ? "io"
-                        : "runtime-state";
-            const error = runnerError ?? kernelError(fallbackCode, runnerResult.error.message, fallbackBoundary);
-            await store.updateSessionStatus(sessionId, error.code === "APPROVAL_REQUIRED" ? "waitingApproval" : "failed");
-            const snapshot = await store.readSession(sessionId);
-            return {
-                ok: false,
-                runtimeId,
-                sessionId,
-                manifest,
-                error,
-                mainLoopSteps,
-                events,
-                state: snapshot,
-            };
-        }
-        const finalOutput = runnerResult.finalOutput;
-        const output = exposeTextOutput({
-            outputId: `${sessionId}:output:final`,
-            runtimeId,
-            sessionId,
-            source: "model",
-            stage: "final",
-            text: finalOutput,
-            governance: { accepted: true },
-            contract: { accepted: true },
-        });
-        events.push(...output.events);
-        const outputStepIndex = Math.max(0, ...mainLoopSteps.map((step) => step.stepIndex)) + 1;
-        if (!output.ok) {
-            const error = kernelError("TEXT_OUTPUT_REJECTED", output.error.message, "io");
-            await store.updateSessionStatus(sessionId, "failed");
-            await recordMainLoopStep({
-                store,
-                sessionId,
-                createdAt: now(),
-                events,
-                mainLoopSteps,
-                step: createMainLoopStepRecord({
-                    sessionId,
-                    turnIndex: maxModelTurns,
-                    stepIndex: outputStepIndex,
-                    actionPrimitive: "exposeOutput",
-                    status: "failed",
-                    inputRefs: ["runtime.output.final"],
-                    error: {
-                        code: output.error.code,
-                        message: output.error.message,
-                        boundary: "output",
-                        publicSafe: true,
-                    },
-                    now: now(),
-                }),
-            });
-            await recordKernelError({
-                store,
-                sessionId,
-                errorId: "error:output:final",
-                error,
-                createdAt: now(),
-                metadata: { outputId: `${sessionId}:output:final` },
-            });
-            const snapshot = await store.readSession(sessionId);
-            return {
-                ok: false,
-                runtimeId,
-                sessionId,
-                manifest,
-                error,
-                mainLoopSteps,
-                events,
-                state: snapshot,
-            };
-        }
-        await recordMainLoopStep({
-            store,
-            sessionId,
-            createdAt: now(),
-            events,
-            mainLoopSteps,
-            step: createMainLoopStepRecord({
-                sessionId,
-                turnIndex: maxModelTurns,
-                stepIndex: outputStepIndex,
-                actionPrimitive: "exposeOutput",
-                status: "completed",
-                inputRefs: ["runtime.output.final"],
-                outputRefs: [output.exposed.outputId],
-                now: now(),
-            }),
-        });
-        await store.appendEvent(event(sessionId, "event:output.final", "runtime.output.final", now(), {
-            outputId: output.exposed.outputId,
-        }));
-        await store.appendState(state(sessionId, "state:completed", "completed", now()));
-        await store.updateSessionStatus(sessionId, "completed");
-        return {
-            ok: true,
-            runtimeId,
-            sessionId,
-            manifest,
-            finalOutput,
-            modelCalls,
-            toolCalls,
-            mainLoopSteps,
-            events,
-            state: await store.readSession(sessionId),
-        };
-    }
-}
-export function createPraxisRuntimeKernel(options = {}) {
-    return new PraxisRuntimeKernel(options);
-}