@praxis-ai/praxis 0.1.4 → 0.1.6

package/dist/runtimeImplementation/praxisRuntimeKernel.js

@@ -27,6 +27,7 @@ import { evaluateBaseToolRuntimeGovernance } from "./runtime.execEngine/baseTool
 import { preflightBaseToolDependencies, } from "./runtime.execEngine/baseToolDependencyRuntime.js";
 import { applyBaseToolContextUsage, createBaseToolContextHeatState, } from "./runtime.execEngine/baseToolContextFolding.js";
 import { assemblePromptContextMaterials, PRAXIS_BASE_TOOL_CALLING_PROTOCOL, } from "./runtime.execEngine/promptContextAssembly.js";
+import { createFileSkillPlaneStore, loadSkillHeadsFromSources, renderSkillIndexMaterial, skillPlaneModuleFrom, } from "./runtime.skillPlane/index.js";
 import { invokeMountedBaseTool } from "./runtime.execEngine/baseToolRuntimeMount.js";
 import { evaluateBaseToolRuntimeReadiness } from "./runtime.execEngine/baseToolSupportCatalog.js";
 import { adjudicateBaseToolPolicy, } from "./runtime.execEngine/baseToolPolicyAdjudicator.js";
@@ -241,7 +242,11 @@ function runtimeGrantedPermissionsForTool(toolId, _profile) {
         case "mcp.use":
             return ["mcp:call", "mcp:auth"];
         case "mcp.resources":
-            return ["mcp:resource:list", "mcp:resource:read"];
+            return ["mcp:resource:list", "mcp:resource:template:list", "mcp:resource:read", "mcp:resource:subscribe"];
+        case "mcp.prompts":
+            return ["mcp:prompt:list", "mcp:prompt:get"];
+        case "mcp.completions":
+            return ["mcp:completion"];
         case "media.viewImage":
             return ["media:image:read", "filesystem:read"];
         case "process.wait":
@@ -349,22 +354,56 @@ function runtimeMcpPlusProjectId(input) {
         return input.explicit.trim();
     return `project.${createHash("sha256").update(path.resolve(input.workspaceRoot)).digest("hex").slice(0, 16)}`;
 }
-function mcpPlusOverlayToExposureState(overlay) {
+function readMcpPlusOverlayState(overlay) {
     if (overlay === undefined)
+        return undefined;
+    return {
+        mode: overlay.state?.mode ?? overlay.mode ?? "expanded",
+        activeTools: [...(overlay.state?.activeTools ?? overlay.activeTools ?? [])],
+        pendingReprofile: overlay.state?.pendingReprofile ?? overlay.pendingReprofile,
+        counters: {
+            consecutiveIndexedToolCalls: {
+                ...(overlay.counters?.consecutiveIndexedToolCalls ?? {}),
+                ...(overlay.state?.counters.consecutiveIndexedToolCalls ?? {}),
+            },
+        },
+    };
+}
+function mcpPlusOverlayToExposureState(overlay) {
+    const state = readMcpPlusOverlayState(overlay);
+    if (state === undefined)
         return {};
     return {
-        mode: overlay.mode,
+        mode: state.mode,
         activeTools: [
-            ...overlay.activeTools,
-            ...(overlay.pendingReprofile ? ["mcp_plus.reprofile"] : []),
+            ...state.activeTools,
+            ...(state.pendingReprofile ? ["mcp_plus.reprofile"] : []),
         ],
     };
 }
+function withMcpPlusOverlayState(overlay, state, input) {
+    const { mode: _legacyMode, activeTools: _legacyActiveTools, pendingReprofile: _legacyPendingReprofile, counters: _legacyCounters, ...base } = overlay;
+    return {
+        ...base,
+        state,
+        updatedAt: input.updatedAt,
+        ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
+    };
+}
 function readStringList(value) {
     if (!Array.isArray(value))
         return [];
     return value.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim());
 }
+function readStringRecord(value) {
+    if (!isRecord(value))
+        return undefined;
+    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+    return entries.length === 0 ? undefined : Object.fromEntries(entries);
+}
+function readProfileRationale(value) {
+    return readString(value) ?? readStringRecord(value);
+}
 function proposalFromArgs(args, fallbackServerId) {
     const rawToolCards = isRecord(args.toolCards) ? args.toolCards : undefined;
     const toolCards = rawToolCards === undefined ? undefined : Object.fromEntries(Object.entries(rawToolCards).flatMap(([toolName, card]) => {
@@ -392,7 +431,7 @@ function proposalFromArgs(args, fallbackServerId) {
             const summary = readString(chapter.summary);
             return id === undefined || title === undefined || summary === undefined ? [] : [{ id, title, summary }];
         }),
-        rationale: readString(args.rationale),
+        rationale: readProfileRationale(args.rationale),
     };
     if (Object.hasOwn(args, "modeHint")) {
         return {
@@ -411,9 +450,11 @@ function createRuntimeMcpPlusController(input) {
         return await input.overlayStore.load({ sessionId: input.sessionId, serverId }) ?? {
             serverId,
             sessionId: input.sessionId,
-            mode: "expanded",
-            activeTools: [],
-            counters: { consecutiveIndexedToolCalls: {} },
+            state: {
+                mode: "expanded",
+                activeTools: [],
+                counters: { consecutiveIndexedToolCalls: {} },
+            },
             updatedAt: now,
         };
     }
@@ -425,7 +466,7 @@ function createRuntimeMcpPlusController(input) {
             const module = mcpHarnessModuleFrom(manifest.harness);
             const profiles = {};
             for (const server of module?.servers ?? []) {
-                if (server.mode !== "mcp-plus" || server.manifest !== undefined)
+                if (server.mode !== "mcp-plus")
                     continue;
                 profiles[server.serverId] = await input.profileStore.load({ projectId: input.projectId, serverId: server.serverId });
             }
@@ -441,34 +482,55 @@ function createRuntimeMcpPlusController(input) {
             }
             return states;
         },
+        async skillIndexByServerId(manifest) {
+            const module = mcpHarnessModuleFrom(manifest.harness);
+            const indexes = {};
+            for (const server of module?.servers ?? []) {
+                if (server.mode !== "mcp-plus")
+                    continue;
+                const notes = await input.skillStore.list({ projectId: input.projectId, serverId: server.serverId });
+                indexes[server.serverId] = notes.map((note) => ({
+                    id: note.id,
+                    title: note.title,
+                    summary: note.summary,
+                    serverId: server.serverId,
+                    whenToUse: note.whenToUse,
+                    why: note.why,
+                    pitfallsPreview: note.pitfalls?.slice(0, 3),
+                }));
+            }
+            return indexes;
+        },
         async callControlTool(control) {
             if (control.controlName === "mcp_plus.init" || control.controlName === "mcp_plus.reprofile") {
                 const proposal = proposalFromArgs(control.args, control.serverId);
                 const nativeTools = nativeInventory[proposal.serverId] ?? [];
                 const existing = await input.profileStore.load({ projectId: input.projectId, serverId: proposal.serverId });
+                const server = mcpPlusServerSpec(control.manifest, proposal.serverId);
                 const learned = learnedProfileFromProposal({
                     proposal,
                     nativeTools,
                     projectId: input.projectId,
                     now: control.now,
                     existing,
+                    protectedAlwaysIndexTools: server?.manifest?.exposure?.alwaysIndexTools,
                 });
                 if (!learned.ok)
                     return { ok: false, error: learned.error };
                 await input.profileStore.save({ projectId: input.projectId, serverId: proposal.serverId }, learned.profile);
                 const overlay = await loadOverlay(proposal.serverId, control.now);
-                await input.overlayStore.save({ sessionId: input.sessionId, serverId: proposal.serverId }, {
-                    ...overlay,
+                await input.overlayStore.save({ sessionId: input.sessionId, serverId: proposal.serverId }, withMcpPlusOverlayState(overlay, {
                     mode: "expanded",
                     activeTools: [],
                     pendingReprofile: false,
                     counters: { consecutiveIndexedToolCalls: {} },
+                }, {
                     updatedAt: control.now,
                     metadata: {
                         ...(overlay.metadata ?? {}),
                         lastProfileControl: control.controlName,
                     },
-                });
+                }));
                 return {
                     ok: true,
                     output: {
@@ -530,12 +592,16 @@ function createRuntimeMcpPlusController(input) {
                     ? indexedTools
                     : indexedTools.filter((toolName) => toolName.toLowerCase().includes(request));
                 const overlay = await loadOverlay(serverId, control.now);
-                await input.overlayStore.save({ sessionId: input.sessionId, serverId }, {
-                    ...overlay,
+                const overlayState = readMcpPlusOverlayState(overlay) ?? {
                     mode: "expanded",
-                    activeTools: [...new Set([...overlay.activeTools, ...activatedTools])],
-                    updatedAt: control.now,
-                });
+                    activeTools: [],
+                    counters: { consecutiveIndexedToolCalls: {} },
+                };
+                await input.overlayStore.save({ sessionId: input.sessionId, serverId }, withMcpPlusOverlayState(overlay, {
+                    ...overlayState,
+                    mode: "expanded",
+                    activeTools: [...new Set([...overlayState.activeTools, ...activatedTools])],
+                }, { updatedAt: control.now }));
                 return { ok: true, output: { serverId, activatedTools, mode: "expanded" } };
             }
             return { ok: false, error: { code: "MCP_PLUS_CONTROL_UNKNOWN", message: `Unknown MCP+ control tool: ${control.controlName}`, publicSafe: true } };
@@ -558,9 +624,19 @@ function createRuntimeMcpPlusController(input) {
                 : undefined;
             const indexedTools = new Set(server.manifest?.exposure?.indexedTools ?? profile?.exposure.indexedTools ?? []);
             const overlay = await loadOverlay(serverId, record.now);
-            const consecutiveIndexedToolCalls = { ...overlay.counters.consecutiveIndexedToolCalls };
-            let pendingReprofile = overlay.pendingReprofile;
+            const overlayState = readMcpPlusOverlayState(overlay) ?? {
+                mode: "expanded",
+                activeTools: [],
+                counters: { consecutiveIndexedToolCalls: {} },
+            };
+            const consecutiveIndexedToolCalls = { ...overlayState.counters.consecutiveIndexedToolCalls };
+            let pendingReprofile = overlayState.pendingReprofile;
             if (indexedTools.has(nativeToolName)) {
+                for (const toolName of Object.keys(consecutiveIndexedToolCalls)) {
+                    if (toolName !== nativeToolName) {
+                        consecutiveIndexedToolCalls[toolName] = 0;
+                    }
+                }
                 consecutiveIndexedToolCalls[nativeToolName] = (consecutiveIndexedToolCalls[nativeToolName] ?? 0) + 1;
                 if (consecutiveIndexedToolCalls[nativeToolName] >= input.reprofileConsecutiveIndexedCalls) {
                     pendingReprofile = true;
@@ -571,38 +647,173 @@ function createRuntimeMcpPlusController(input) {
                     consecutiveIndexedToolCalls[toolName] = 0;
                 }
             }
-            await input.overlayStore.save({ sessionId: input.sessionId, serverId }, {
-                ...overlay,
+            await input.overlayStore.save({ sessionId: input.sessionId, serverId }, withMcpPlusOverlayState(overlay, {
                 mode: "expanded",
-                activeTools: [...new Set([...overlay.activeTools, nativeToolName])],
+                activeTools: [...new Set([...overlayState.activeTools, nativeToolName])],
                 pendingReprofile,
                 counters: { consecutiveIndexedToolCalls },
-                updatedAt: record.now,
-            });
+            }, { updatedAt: record.now }));
             return true;
         },
     };
 }
-async function discoverRuntimeMcpDynamicTools(manifest, executor, mcpPlusRuntime) {
-    const profiles = buildMcpServerProfilesFromManifest(manifest);
-    if (profiles.length === 0 || executor.mcp?.listTools === undefined)
+function mcpPlusPromptLine(label, value) {
+    const normalized = value?.trim();
+    return normalized === undefined || normalized.length === 0 ? undefined : `${label}: ${normalized}`;
+}
+function renderMcpPlusNativePrelude(plan) {
+    const mcpPlusServers = plan.servers.filter((server) => server.mode === "mcp-plus");
+    if (mcpPlusServers.length === 0)
         return [];
+    const sections = mcpPlusServers.map((server) => {
+        const sidecar = server.surface.sidecar;
+        const visibleTools = server.surface.tools
+            .map((tool) => tool.name)
+            .filter((name) => typeof name === "string" && name.trim().length > 0);
+        const lines = [
+            `Server: ${server.serverId}`,
+            mcpPlusPromptLine("Mode", sidecar.serverCard.mode),
+            mcpPlusPromptLine("Title", sidecar.serverCard.title),
+            mcpPlusPromptLine("Summary", sidecar.serverCard.summary),
+            `Visible tools: ${visibleTools.join(", ") || "none"}`,
+        ].filter((line) => line !== undefined);
+        if (sidecar.toolIndex.length > 0) {
+            lines.push("Tool index:");
+            for (const card of sidecar.toolIndex) {
+                lines.push(`- ${card.activation.toolName} (${card.id}): ${card.title}. ${card.summary}`);
+            }
+        }
+        if (sidecar.skillIndex.length > 0) {
+            lines.push("Skill index:");
+            for (const skill of sidecar.skillIndex) {
+                lines.push(`- ${skill.id}: ${skill.title}. ${skill.summary}`);
+            }
+        }
+        return lines.join("\n");
+    });
+    return [{
+            id: "runtime:mcp-plus-native-exposure",
+            kind: "tool-summary",
+            text: [
+                "# MCP+ Native Exposure",
+                "",
+                "MCP+ is a compact exposure layer over standard MCP. Praxis owns the runtime lifecycle; MCP remains the protocol boundary.",
+                "Use visible pinned or active MCP tools directly. Use indexed tool cards to decide when mcp_plus.expand or mcp_plus.reprofile is needed.",
+                "Use skill index cards to decide when mcp_plus.skill_read is relevant. Full skill bodies are read on demand and must not be assumed from this prefix-cached index.",
+                "",
+                sections.join("\n\n"),
+            ].join("\n"),
+            source: "runtime.mcpPlus.nativeExposure",
+            sourceCategory: "declared-built-in",
+            priority: 95.5,
+            trusted: true,
+            scope: "runtime.mcpPlus.exposure",
+            promptSegmentKind: "toolDeclarations",
+            metadata: {
+                promptSegmentKind: "toolDeclarations",
+                toolMaterialType: "policy",
+                mcpPlusServerIds: mcpPlusServers.map((server) => server.serverId),
+            },
+        }];
+}
+function mergeStoredSkillIndexIntoMcpPlusPlan(plan, skillIndexByServerId) {
+    return {
+        servers: plan.servers.map((server) => {
+            if (server.mode !== "mcp-plus")
+                return server;
+            const storedSkillIndex = skillIndexByServerId[server.serverId] ?? [];
+            if (storedSkillIndex.length === 0)
+                return server;
+            const existingSkillIds = new Set(server.surface.sidecar.skillIndex.map((skill) => skill.id));
+            const mergedSkillIndex = [
+                ...server.surface.sidecar.skillIndex,
+                ...storedSkillIndex.filter((skill) => !existingSkillIds.has(skill.id)),
+            ];
+            return {
+                ...server,
+                surface: {
+                    ...server.surface,
+                    sidecar: {
+                        ...server.surface.sidecar,
+                        skillIndex: mergedSkillIndex,
+                    },
+                },
+            };
+        }),
+    };
+}
+async function discoverRuntimeMcpDynamicSurface(manifest, executor, mcpPlusRuntime) {
+    const profiles = buildMcpServerProfilesFromManifest(manifest);
+    if (profiles.length === 0 || executor.mcp?.listTools === undefined) {
+        return { tools: [], toolDeclarationPreludeMaterials: [] };
+    }
     const inventory = {};
     for (const profile of profiles) {
-        const listed = await executor.mcp.listTools({ serverId: profile.serverId });
-        if (listed?.ok !== true)
-            continue;
-        const rawTools = Array.isArray(listed.output?.tools) ? listed.output.tools : [];
+        const rawTools = [];
+        let cursor;
+        for (let page = 0; page < 100; page += 1) {
+            const listed = await executor.mcp.listTools({ serverId: profile.serverId, ...(cursor === undefined ? {} : { cursor }) });
+            if (listed?.ok !== true)
+                break;
+            if (Array.isArray(listed.output?.tools))
+                rawTools.push(...listed.output.tools);
+            const nextCursor = typeof listed.output?.nextCursor === "string" ? listed.output.nextCursor : undefined;
+            if (nextCursor === undefined || nextCursor === cursor)
+                break;
+            cursor = nextCursor;
+        }
         inventory[profile.serverId] = rawTools
             .map(normalizeMcpNativeToolDeclaration)
             .filter((tool) => tool !== undefined);
     }
     await mcpPlusRuntime?.setNativeInventory(inventory);
-    return planMcpHarnessExposure(manifest, inventory, await mcpPlusRuntime?.exposureStateByServerId(manifest) ?? {}, await mcpPlusRuntime?.learnedProfilesByServerId(manifest) ?? {}).servers.flatMap((server) => [...server.dynamicToolSpecs]);
+    const plan = planMcpHarnessExposure(manifest, inventory, await mcpPlusRuntime?.exposureStateByServerId(manifest) ?? {}, await mcpPlusRuntime?.learnedProfilesByServerId(manifest) ?? {});
+    const promptPlan = mergeStoredSkillIndexIntoMcpPlusPlan(plan, await mcpPlusRuntime?.skillIndexByServerId(manifest) ?? {});
+    return {
+        tools: plan.servers.flatMap((server) => [...server.dynamicToolSpecs]),
+        toolDeclarationPreludeMaterials: renderMcpPlusNativePrelude(promptPlan),
+    };
+}
+async function discoverRuntimeSkillIndexMaterials(input) {
+    const skillModule = skillPlaneModuleFrom(input.manifest.harness);
+    if (skillModule === undefined)
+        return [];
+    const includeScopes = skillModule.indexPolicy.includeScopes;
+    function scopeMatchesIndexPolicy(head) {
+        const scopes = includeScopes;
+        if (scopes.length === 0)
+            return true;
+        return head.scope !== undefined && scopes.includes(head.scope);
+    }
+    const bySkillId = new Map();
+    for (const head of await loadSkillHeadsFromSources(skillModule.sources, { workspaceRoot: input.workspaceRoot })) {
+        if (scopeMatchesIndexPolicy(head) && !bySkillId.has(head.skillId)) {
+            bySkillId.set(head.skillId, head);
+        }
+    }
+    for (const head of await input.store.listHeads({ scopes: skillModule.indexPolicy.includeScopes })) {
+        if (!bySkillId.has(head.skillId)) {
+            bySkillId.set(head.skillId, head);
+        }
+    }
+    const heads = [...bySkillId.values()].slice(0, skillModule.indexPolicy.maxHeads);
+    return heads.length === 0 ? [] : [renderSkillIndexMaterial(heads)];
 }
 function providerToolMappings(manifest) {
     return createProviderToolMappings(manifest.harness.tools);
 }
+async function shutdownRuntimeOwnedExecutor(executor, events) {
+    const shutdown = executor?.mcp?.__praxisRuntimeOwnedShutdown;
+    if (typeof shutdown !== "function")
+        return;
+    try {
+        const result = await shutdown({ reason: "runtime.runManifest.finished" });
+        events.push(result?.ok === false ? "runtime.mcp.shutdown.failed" : "runtime.mcp.shutdown.completed");
+    }
+    catch {
+        events.push("runtime.mcp.shutdown.failed");
+    }
+}
 function providerToolSchemaFamilyForModel(model) {
     if (model.provider === "anthropic" || model.endpointShape === "messages")
         return "anthropicMessages";
@@ -2578,6 +2789,8 @@ async function buildPromptPackAndLower(input) {
             budget: contextWindowTokens === undefined ? undefined : { contextWindowTokens },
             sessionSummary: input.sessionSummary,
             conversationWindow: input.conversationWindow,
+            toolDeclarationPreludeMaterials: input.toolDeclarationPreludeMaterials,
+            skillIndexMaterials: input.skillIndexMaterials,
             projectContextGovernanceMaterials: input.projectContextGovernanceMaterials?.map((material) => ({
                 id: material.id,
                 kind: "runtime",
@@ -3926,194 +4139,168 @@ export class PraxisRuntimeKernel {
                 events.push(runtimeEvent.type);
             },
         });
-        const modelCaller = {
-            kind: "application",
-            id: "praxis-runtime-kernel",
-            sessionId,
-        };
-        const mcpPlusRuntime = createRuntimeMcpPlusController({
-            sessionId,
-            projectId: runtimeMcpPlusProjectId({
-                explicit: options.mcpPlus?.projectId,
+        const runtimeOwnedExecutor = options.executor === undefined ? executor : undefined;
+        try {
+            const modelCaller = {
+                kind: "application",
+                id: "praxis-runtime-kernel",
+                sessionId,
+            };
+            const mcpPlusRuntime = createRuntimeMcpPlusController({
+                sessionId,
+                projectId: runtimeMcpPlusProjectId({
+                    explicit: options.mcpPlus?.projectId,
+                    workspaceRoot: toolWorkspaceRoot,
+                }),
+                profileStore: options.mcpPlus?.profileStore ?? createFileMcpPlusProfileStore(path.join(toolWorkspaceRoot, ".rax_workspace", "mcp-plus")),
+                overlayStore: options.mcpPlus?.overlayStore ?? createInMemoryMcpPlusOverlayStore(),
+                skillStore: options.mcpPlus?.skillStore ?? createFileMcpPlusSkillStore(path.join(toolWorkspaceRoot, ".rax_workspace", "mcp-plus")),
+                reprofileConsecutiveIndexedCalls: options.mcpPlus?.reprofileConsecutiveIndexedCalls ?? 6,
+            });
+            const maxModelTurns = manifest.harness.loop.maxModelTurns ?? 2;
+            const maxToolCalls = manifest.harness.loop.maxToolCalls ?? 4;
+            let toolMappings = [];
+            let toolDeclarationPreludeMaterials = [];
+            const skillIndexMaterials = await discoverRuntimeSkillIndexMaterials({
+                manifest,
                 workspaceRoot: toolWorkspaceRoot,
-            }),
-            profileStore: options.mcpPlus?.profileStore ?? createFileMcpPlusProfileStore(path.join(toolWorkspaceRoot, ".rax_workspace", "mcp-plus")),
-            overlayStore: options.mcpPlus?.overlayStore ?? createInMemoryMcpPlusOverlayStore(),
-            skillStore: options.mcpPlus?.skillStore ?? createFileMcpPlusSkillStore(path.join(toolWorkspaceRoot, ".rax_workspace", "mcp-plus")),
-            reprofileConsecutiveIndexedCalls: options.mcpPlus?.reprofileConsecutiveIndexedCalls ?? 6,
-        });
-        const maxModelTurns = manifest.harness.loop.maxModelTurns ?? 2;
-        const maxToolCalls = manifest.harness.loop.maxToolCalls ?? 4;
-        let toolMappings = [];
-        async function refreshRuntimeMcpTools(reason) {
-            manifest = withRuntimeHarnessToolLayer(runtimeMcpBaseManifest, await discoverRuntimeMcpDynamicTools(runtimeMcpBaseManifest, executor, mcpPlusRuntime), reason);
-            toolMappings = providerToolMappings(manifest);
-        }
-        await refreshRuntimeMcpTools("session.checkpoint.start");
-        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 compactSessionSummary = options.sessionSummary;
-        let compactConversationWindow = options.conversationWindow;
-        let preCompactGovernanceProjectContextMaterials = [];
-        const compactInputBudgetTokens = manifestCompactInputBudgetTokens(manifest, options.compactContextWindowTokens);
-        const compactExecutor = options.compactExecutor ?? createRuntimeFallbackCompactExecutor();
-        const preCompactGovernanceExecutor = options.preCompactGovernanceExecutor
-            ?? createNoopPreCompactGovernanceExecutor();
-        const preCompactGovernanceEnabled = options.preCompactGovernanceEnabled ?? options.preCompactGovernanceExecutor !== undefined;
-        let previousModelCacheDebug;
-        let runnerError;
-        const runnerResult = await runMainLoopEngine({
-            sessionId,
-            recorder: {
-                recordEvent: async (coreEvent) => {
-                    await store.appendEvent(event(sessionId, `event:mainLoopEngine:${coreEvent.eventId}`, `runtime.mainLoop.${coreEvent.name}`, coreEvent.createdAt, coreEvent.payload));
+                store: options.skillPlane?.store ?? createFileSkillPlaneStore(path.join(toolWorkspaceRoot, ".rax_workspace", "skills")),
+            });
+            async function refreshRuntimeMcpTools(reason) {
+                const dynamicSurface = await discoverRuntimeMcpDynamicSurface(runtimeMcpBaseManifest, executor, mcpPlusRuntime);
+                manifest = withRuntimeHarnessToolLayer(runtimeMcpBaseManifest, dynamicSurface.tools, reason);
+                toolDeclarationPreludeMaterials = dynamicSurface.toolDeclarationPreludeMaterials;
+                toolMappings = providerToolMappings(manifest);
+            }
+            await refreshRuntimeMcpTools("session.checkpoint.start");
+            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 compactSessionSummary = options.sessionSummary;
+            let compactConversationWindow = options.conversationWindow;
+            let preCompactGovernanceProjectContextMaterials = [];
+            const compactInputBudgetTokens = manifestCompactInputBudgetTokens(manifest, options.compactContextWindowTokens);
+            const compactExecutor = options.compactExecutor ?? createRuntimeFallbackCompactExecutor();
+            const preCompactGovernanceExecutor = options.preCompactGovernanceExecutor
+                ?? createNoopPreCompactGovernanceExecutor();
+            const preCompactGovernanceEnabled = options.preCompactGovernanceEnabled ?? options.preCompactGovernanceExecutor !== undefined;
+            let previousModelCacheDebug;
+            let runnerError;
+            const runnerResult = await runMainLoopEngine({
+                sessionId,
+                recorder: {
+                    recordEvent: async (coreEvent) => {
+                        await store.appendEvent(event(sessionId, `event:mainLoopEngine:${coreEvent.eventId}`, `runtime.mainLoop.${coreEvent.name}`, coreEvent.createdAt, coreEvent.payload));
+                    },
+                    recordStep: async (stepRecord) => {
+                        await recordMainLoopStep({
+                            store,
+                            sessionId,
+                            createdAt: now(),
+                            events,
+                            mainLoopSteps,
+                            step: stepRecord,
+                        });
+                    },
+                    recordTurnState: async (turnState) => {
+                        await store.appendState(state(sessionId, `state:mainLoopEngine:${turnState.turnId}:${turnState.revision}`, turnState.phase, turnState.updatedAt, {
+                            turnId: turnState.turnId,
+                            turnIndex: turnState.turnIndex,
+                            revision: turnState.revision,
+                            resumeToken: turnState.resumeToken,
+                            budgetUsage: turnState.budgetUsage,
+                            pendingInputQueueSize: turnState.pendingInputQueue.length,
+                            observationRefs: turnState.observationRefs,
+                        }));
+                    },
                 },
-                recordStep: async (stepRecord) => {
-                    await recordMainLoopStep({
-                        store,
+                interruptSignal: options.interruptSignal,
+                maxModelTurns,
+                maxToolCalls,
+                prepareTurn: async (turn) => {
+                    await store.appendState(state(sessionId, `state:model:${turn + 1}`, "model", now(), { turn }));
+                    const stepBase = turn * 20 + 2;
+                    let prompt = await buildPromptPackAndLower({
+                        runtimeId,
                         sessionId,
-                        createdAt: now(),
+                        manifest,
+                        task: input.input.normalizedText,
+                        turnIndex: turn,
+                        startStepIndex: stepBase,
+                        workspaceRoot: toolWorkspaceRoot,
+                        allowedRoots: toolAllowedRoots,
+                        now: now(),
+                        modelCaller,
+                        toolMappings,
+                        observations,
                         events,
-                        mainLoopSteps,
-                        step: stepRecord,
+                        contextWindowTokens: compactInputBudgetTokens,
+                        sessionSummary: compactSessionSummary,
+                        conversationWindow: compactConversationWindow,
+                        toolDeclarationPreludeMaterials,
+                        skillIndexMaterials,
+                        projectContextGovernanceMaterials: preCompactGovernanceProjectContextMaterials,
+                        toolContextSelection,
+                        toolContextUsage: toolContextHeatState.usage,
                     });
-                },
-                recordTurnState: async (turnState) => {
-                    await store.appendState(state(sessionId, `state:mainLoopEngine:${turnState.turnId}:${turnState.revision}`, turnState.phase, turnState.updatedAt, {
-                        turnId: turnState.turnId,
-                        turnIndex: turnState.turnIndex,
-                        revision: turnState.revision,
-                        resumeToken: turnState.resumeToken,
-                        budgetUsage: turnState.budgetUsage,
-                        pendingInputQueueSize: turnState.pendingInputQueue.length,
-                        observationRefs: turnState.observationRefs,
-                    }));
-                },
-            },
-            interruptSignal: options.interruptSignal,
-            maxModelTurns,
-            maxToolCalls,
-            prepareTurn: async (turn) => {
-                await store.appendState(state(sessionId, `state:model:${turn + 1}`, "model", now(), { turn }));
-                const stepBase = turn * 20 + 2;
-                let prompt = await buildPromptPackAndLower({
-                    runtimeId,
-                    sessionId,
-                    manifest,
-                    task: input.input.normalizedText,
-                    turnIndex: turn,
-                    startStepIndex: stepBase,
-                    workspaceRoot: toolWorkspaceRoot,
-                    allowedRoots: toolAllowedRoots,
-                    now: now(),
-                    modelCaller,
-                    toolMappings,
-                    observations,
-                    events,
-                    contextWindowTokens: compactInputBudgetTokens,
-                    sessionSummary: compactSessionSummary,
-                    conversationWindow: compactConversationWindow,
-                    projectContextGovernanceMaterials: preCompactGovernanceProjectContextMaterials,
-                    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({
+                    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,
-                            turnIndex: turn,
-                            stepIndex: stepBase,
-                            actionPrimitive: "assemblePromptPack",
-                            status: "failed",
-                            inputRefs: ["runtime.input.normalized", ...observations.map((observation) => observation.observationId)],
+                            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,
                             },
-                            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,
-                        },
-                    }),
-                });
-                const contextWindowTokens = compactInputBudgetTokens;
-                const promptBoundaryEvents = [...prompt.events];
-                if (contextWindowTokens !== undefined) {
-                    const compactDecision = decideTurnBoundaryCompact({
-                        trigger: observations.length > 0 ? "toolLoopBoundary" : "turnBoundary",
-                        estimatedNextPromptTokens: prompt.promptPack.totalEstimatedTokens,
-                        contextWindowTokens,
-                        thresholdRatio: options.compactThresholdRatio,
-                    });
-                    const compactEvent = compactDecision.shouldCompact
-                        ? "runtime.contextCompact.thresholdReached"
-                        : "runtime.contextCompact.thresholdNotReached";
-                    events.push(compactEvent);
-                    promptBoundaryEvents.push(compactEvent);
-                    await store.appendEvent(event(sessionId, `event:contextCompact:decision:${turn + 1}`, "runtime.contextCompact.thresholdDecision", now(), compactDecision));
+                            events: prompt.events,
+                        };
+                    }
+                    for (const turnStep of prompt.turnRecord.stepRecords) {
+                        await recordMainLoopStep({
+                            store,
+                            sessionId,
+                            createdAt: now(),
+                            events,
+                            mainLoopSteps,
+                            step: turnStep,
+                        });
+                    }
                     await recordMainLoopStep({
                         store,
                         sessionId,
@@ -4123,921 +4310,694 @@ export class PraxisRuntimeKernel {
                         step: createMainLoopStepRecord({
                             sessionId,
                             turnIndex: turn,
-                            stepIndex: stepBase + 4,
-                            actionPrimitive: "updateSummaryStateEvent",
-                            status: compactDecision.shouldCompact ? "planned" : "completed",
+                            stepIndex: stepBase + 3,
+                            actionPrimitive: "lowerPrompt",
+                            status: "completed",
                             inputRefs: [prompt.promptPackId],
-                            outputRefs: [],
+                            outputRefs: [prompt.loweredPrompt.loweringId],
                             promptPackRef: prompt.promptPackId,
+                            loweredPromptRef: prompt.loweredPrompt.loweringId,
                             now: now(),
                             metadata: {
-                                decision: compactDecision,
-                                note: compactDecision.shouldCompact
-                                    ? "compact should run after this boundary through the configured CompactExecutor"
-                                    : "compact threshold not reached at this boundary",
+                                materialRefs: prompt.loweredPrompt.materialRefs,
+                                targetCapability: prompt.loweredPrompt.target.capabilityId,
                             },
                         }),
                     });
-                    if (compactDecision.shouldCompact) {
-                        let preCompactGovernanceResult;
-                        let preCompactGovernanceRecord;
-                        if (preCompactGovernanceEnabled) {
-                            const governancePacket = buildPreCompactGovernancePacket({
-                                runtimeId,
+                    const contextWindowTokens = compactInputBudgetTokens;
+                    const promptBoundaryEvents = [...prompt.events];
+                    if (contextWindowTokens !== undefined) {
+                        const compactDecision = decideTurnBoundaryCompact({
+                            trigger: observations.length > 0 ? "toolLoopBoundary" : "turnBoundary",
+                            estimatedNextPromptTokens: prompt.promptPack.totalEstimatedTokens,
+                            contextWindowTokens,
+                            thresholdRatio: options.compactThresholdRatio,
+                        });
+                        const compactEvent = compactDecision.shouldCompact
+                            ? "runtime.contextCompact.thresholdReached"
+                            : "runtime.contextCompact.thresholdNotReached";
+                        events.push(compactEvent);
+                        promptBoundaryEvents.push(compactEvent);
+                        await store.appendEvent(event(sessionId, `event:contextCompact:decision:${turn + 1}`, "runtime.contextCompact.thresholdDecision", now(), compactDecision));
+                        await recordMainLoopStep({
+                            store,
+                            sessionId,
+                            createdAt: now(),
+                            events,
+                            mainLoopSteps,
+                            step: createMainLoopStepRecord({
                                 sessionId,
                                 turnIndex: turn,
-                                trigger: compactDecision.trigger,
-                                currentUserTurnText: input.input.normalizedText,
-                                promptPackId: prompt.promptPackId,
-                                promptPack: prompt.promptPack,
-                                compactDecision,
-                            });
-                            const governance = await preCompactGovernanceExecutor.govern({
-                                packet: governancePacket,
+                                stepIndex: stepBase + 4,
+                                actionPrimitive: "updateSummaryStateEvent",
+                                status: compactDecision.shouldCompact ? "planned" : "completed",
+                                inputRefs: [prompt.promptPackId],
+                                outputRefs: [],
+                                promptPackRef: prompt.promptPackId,
                                 now: now(),
                                 metadata: {
-                                    promptPackId: prompt.promptPackId,
-                                    compactTrigger: compactDecision.trigger,
+                                    decision: compactDecision,
+                                    note: compactDecision.shouldCompact
+                                        ? "compact should run after this boundary through the configured CompactExecutor"
+                                        : "compact threshold not reached at this boundary",
                                 },
-                            });
-                            preCompactGovernanceRecord = governance.record;
-                            events.push(...governance.events);
-                            promptBoundaryEvents.push(...governance.events);
-                            await store.appendEvent(event(sessionId, `event:preCompactGovernance:${turn + 1}`, "runtime.preCompactGovernance.result", now(), governance.record));
-                            await store.appendState(state(sessionId, `state:preCompactGovernance:${turn + 1}`, governance.ok ? "completed" : "failed", now(), {
-                                record: governance.record,
-                            }));
-                            await recordMainLoopStep({
-                                store,
-                                sessionId,
-                                createdAt: now(),
-                                events,
-                                mainLoopSteps,
-                                step: createMainLoopStepRecord({
+                            }),
+                        });
+                        if (compactDecision.shouldCompact) {
+                            let preCompactGovernanceResult;
+                            let preCompactGovernanceRecord;
+                            if (preCompactGovernanceEnabled) {
+                                const governancePacket = buildPreCompactGovernancePacket({
+                                    runtimeId,
                                     sessionId,
                                     turnIndex: turn,
-                                    stepIndex: stepBase + 5,
-                                    actionPrimitive: "updateSummaryStateEvent",
-                                    status: governance.ok ? "completed" : "failed",
-                                    inputRefs: packetMaterialRefs(governancePacket),
-                                    outputRefs: [governance.record.governanceId],
-                                    promptPackRef: prompt.promptPackId,
+                                    trigger: compactDecision.trigger,
+                                    currentUserTurnText: input.input.normalizedText,
+                                    promptPackId: prompt.promptPackId,
+                                    promptPack: prompt.promptPack,
+                                    compactDecision,
+                                });
+                                const governance = await preCompactGovernanceExecutor.govern({
+                                    packet: governancePacket,
                                     now: now(),
                                     metadata: {
-                                        governanceRecord: governance.record,
-                                        note: governance.ok
-                                            ? "preCompactGovernance completed before compactExecutor"
-                                            : "preCompactGovernance failed or skipped; continuing normal compact",
+                                        promptPackId: prompt.promptPackId,
+                                        compactTrigger: compactDecision.trigger,
                                     },
-                                }),
-                            });
-                            if (governance.ok) {
-                                preCompactGovernanceResult = governance.result;
-                                preCompactGovernanceProjectContextMaterials = projectContextMaterialsFromGovernance({
-                                    governanceResult: governance.result,
-                                    governanceRecord: governance.record,
                                 });
-                            }
-                        }
-                        const compactMaterials = compactRequestMaterials({
-                            promptPack: prompt.promptPack,
-                            governanceResult: preCompactGovernanceResult,
-                            projectContextGovernanceMaterials: preCompactGovernanceProjectContextMaterials,
-                        });
-                        const compactResult = await compactExecutor.compact({
-                            sessionId,
-                            trigger: compactDecision.trigger,
-                            materialRefs: compactMaterials.map((material) => material.id),
-                            materials: compactMaterials,
-                            currentUserTurnText: input.input.normalizedText,
-                            estimatedTokens: prompt.promptPack.totalEstimatedTokens,
-                            contextWindowTokens,
-                            thresholdRatio: compactDecision.thresholdRatio,
-                            now: now(),
-                            metadata: {
-                                promptPackId: prompt.promptPackId,
-                                turnIndex: turn,
-                                preCompactGovernanceRecord: preCompactGovernanceRecord ?? null,
-                                preCompactGovernanceResult: preCompactGovernanceResult ?? null,
-                            },
-                        });
-                        events.push(...compactResult.events);
-                        promptBoundaryEvents.push(...compactResult.events);
-                        if (compactResult.ok) {
-                            compactSessionSummary = {
-                                summaryId: compactResult.record.after.sessionSummaryRef,
-                                text: governedSessionSummaryText({
-                                    compactSummaryText: compactResult.sessionSummaryText,
-                                    governanceResult: preCompactGovernanceResult,
-                                }),
-                                compactedUntilTurnId: `${sessionId}:turn:${turn}`,
-                                updatedAt: compactResult.record.createdAt,
-                                metadata: {
-                                    compactId: compactResult.record.compactId,
-                                    executor: compactResult.record.executor,
-                                    preCompactGovernanceId: preCompactGovernanceRecord?.governanceId ?? "",
-                                },
-                            };
-                            compactConversationWindow = compactResult.recentConversationText.trim().length === 0
-                                ? []
-                                : [{
-                                        messageId: compactResult.record.after.recentConversationRefs[0] ?? `${compactResult.record.compactId}:recentConversation`,
-                                        role: "runtime-summary",
-                                        text: compactResult.recentConversationText,
-                                        createdAt: compactResult.record.createdAt,
-                                        metadata: {
-                                            compactId: compactResult.record.compactId,
-                                        },
-                                    }];
-                            await store.appendState(state(sessionId, `state:contextCompact:${turn + 1}`, "summarizing", now(), {
-                                decision: compactDecision,
-                                record: compactResult.record,
-                            }));
-                            const rebuiltPrompt = await buildPromptPackAndLower({
-                                runtimeId,
-                                sessionId,
-                                manifest,
-                                task: input.input.normalizedText,
-                                turnIndex: turn,
-                                startStepIndex: stepBase + 6,
-                                workspaceRoot: toolWorkspaceRoot,
-                                allowedRoots: toolAllowedRoots,
-                                now: now(),
-                                modelCaller,
-                                toolMappings,
-                                observations,
-                                events,
-                                sessionSummary: compactSessionSummary,
-                                conversationWindow: compactConversationWindow,
-                                projectContextGovernanceMaterials: preCompactGovernanceProjectContextMaterials,
-                                toolContextSelection,
-                                toolContextUsage: toolContextHeatState.usage,
-                            });
-                            events.push(...rebuiltPrompt.events);
-                            promptBoundaryEvents.push(...rebuiltPrompt.events);
-                            if (!rebuiltPrompt.ok) {
-                                return {
-                                    ok: false,
-                                    error: {
-                                        code: rebuiltPrompt.error.code,
-                                        message: rebuiltPrompt.error.message,
-                                        boundary: "prompt",
-                                        publicSafe: true,
-                                    },
-                                    events: rebuiltPrompt.events,
-                                };
-                            }
-                            for (const turnStep of rebuiltPrompt.turnRecord.stepRecords) {
+                                preCompactGovernanceRecord = governance.record;
+                                events.push(...governance.events);
+                                promptBoundaryEvents.push(...governance.events);
+                                await store.appendEvent(event(sessionId, `event:preCompactGovernance:${turn + 1}`, "runtime.preCompactGovernance.result", now(), governance.record));
+                                await store.appendState(state(sessionId, `state:preCompactGovernance:${turn + 1}`, governance.ok ? "completed" : "failed", now(), {
+                                    record: governance.record,
+                                }));
                                 await recordMainLoopStep({
                                     store,
                                     sessionId,
                                     createdAt: now(),
                                     events,
                                     mainLoopSteps,
-                                    step: turnStep,
+                                    step: createMainLoopStepRecord({
+                                        sessionId,
+                                        turnIndex: turn,
+                                        stepIndex: stepBase + 5,
+                                        actionPrimitive: "updateSummaryStateEvent",
+                                        status: governance.ok ? "completed" : "failed",
+                                        inputRefs: packetMaterialRefs(governancePacket),
+                                        outputRefs: [governance.record.governanceId],
+                                        promptPackRef: prompt.promptPackId,
+                                        now: now(),
+                                        metadata: {
+                                            governanceRecord: governance.record,
+                                            note: governance.ok
+                                                ? "preCompactGovernance completed before compactExecutor"
+                                                : "preCompactGovernance failed or skipped; continuing normal compact",
+                                        },
+                                    }),
                                 });
+                                if (governance.ok) {
+                                    preCompactGovernanceResult = governance.result;
+                                    preCompactGovernanceProjectContextMaterials = projectContextMaterialsFromGovernance({
+                                        governanceResult: governance.result,
+                                        governanceRecord: governance.record,
+                                    });
+                                }
                             }
-                            await recordMainLoopStep({
-                                store,
+                            const compactMaterials = compactRequestMaterials({
+                                promptPack: prompt.promptPack,
+                                governanceResult: preCompactGovernanceResult,
+                                projectContextGovernanceMaterials: preCompactGovernanceProjectContextMaterials,
+                            });
+                            const compactResult = await compactExecutor.compact({
                                 sessionId,
-                                createdAt: now(),
-                                events,
-                                mainLoopSteps,
-                                step: createMainLoopStepRecord({
-                                    sessionId,
+                                trigger: compactDecision.trigger,
+                                materialRefs: compactMaterials.map((material) => material.id),
+                                materials: compactMaterials,
+                                currentUserTurnText: input.input.normalizedText,
+                                estimatedTokens: prompt.promptPack.totalEstimatedTokens,
+                                contextWindowTokens,
+                                thresholdRatio: compactDecision.thresholdRatio,
+                                now: now(),
+                                metadata: {
+                                    promptPackId: prompt.promptPackId,
                                     turnIndex: turn,
-                                    stepIndex: stepBase + 8,
-                                    actionPrimitive: "lowerPrompt",
-                                    status: "completed",
-                                    inputRefs: [rebuiltPrompt.promptPackId],
-                                    outputRefs: [rebuiltPrompt.loweredPrompt.loweringId],
-                                    promptPackRef: rebuiltPrompt.promptPackId,
-                                    loweredPromptRef: rebuiltPrompt.loweredPrompt.loweringId,
-                                    now: now(),
+                                    preCompactGovernanceRecord: preCompactGovernanceRecord ?? null,
+                                    preCompactGovernanceResult: preCompactGovernanceResult ?? null,
+                                },
+                            });
+                            events.push(...compactResult.events);
+                            promptBoundaryEvents.push(...compactResult.events);
+                            if (compactResult.ok) {
+                                compactSessionSummary = {
+                                    summaryId: compactResult.record.after.sessionSummaryRef,
+                                    text: governedSessionSummaryText({
+                                        compactSummaryText: compactResult.sessionSummaryText,
+                                        governanceResult: preCompactGovernanceResult,
+                                    }),
+                                    compactedUntilTurnId: `${sessionId}:turn:${turn}`,
+                                    updatedAt: compactResult.record.createdAt,
                                     metadata: {
-                                        materialRefs: rebuiltPrompt.loweredPrompt.materialRefs,
-                                        targetCapability: rebuiltPrompt.loweredPrompt.target.capabilityId,
-                                        compactRecordRef: compactResult.record.compactId,
+                                        compactId: compactResult.record.compactId,
+                                        executor: compactResult.record.executor,
+                                        preCompactGovernanceId: preCompactGovernanceRecord?.governanceId ?? "",
                                     },
-                                }),
-                            });
-                            prompt = rebuiltPrompt;
-                            await recordMainLoopStep({
-                                store,
-                                sessionId,
-                                createdAt: now(),
-                                events,
-                                mainLoopSteps,
-                                step: createMainLoopStepRecord({
+                                };
+                                compactConversationWindow = compactResult.recentConversationText.trim().length === 0
+                                    ? []
+                                    : [{
+                                            messageId: compactResult.record.after.recentConversationRefs[0] ?? `${compactResult.record.compactId}:recentConversation`,
+                                            role: "runtime-summary",
+                                            text: compactResult.recentConversationText,
+                                            createdAt: compactResult.record.createdAt,
+                                            metadata: {
+                                                compactId: compactResult.record.compactId,
+                                            },
+                                        }];
+                                await store.appendState(state(sessionId, `state:contextCompact:${turn + 1}`, "summarizing", now(), {
+                                    decision: compactDecision,
+                                    record: compactResult.record,
+                                }));
+                                const rebuiltPrompt = await buildPromptPackAndLower({
+                                    runtimeId,
                                     sessionId,
+                                    manifest,
+                                    task: input.input.normalizedText,
                                     turnIndex: turn,
-                                    stepIndex: stepBase + 9,
-                                    actionPrimitive: "updateSummaryStateEvent",
-                                    status: "completed",
-                                    inputRefs: [compactResult.record.compactId],
-                                    outputRefs: [rebuiltPrompt.promptPackId],
-                                    promptPackRef: rebuiltPrompt.promptPackId,
+                                    startStepIndex: stepBase + 6,
+                                    workspaceRoot: toolWorkspaceRoot,
+                                    allowedRoots: toolAllowedRoots,
                                     now: now(),
-                                    metadata: {
-                                        decision: compactDecision,
-                                        compactRecord: compactResult.record,
-                                        rebuiltPromptPackTokens: rebuiltPrompt.promptPack.totalEstimatedTokens,
-                                    },
-                                }),
-                            });
-                        }
-                        else {
-                            runnerError = kernelError("PROMPT_PACK_FAILED", compactResult.error.message, "runtime-state");
-                            const compactError = {
-                                code: compactResult.error.code,
-                                message: compactResult.error.message,
-                                boundary: "prompt",
-                                publicSafe: true,
-                            };
-                            const compactStepError = {
-                                code: compactResult.error.code,
-                                message: compactResult.error.message,
-                                boundary: "runtime-state",
-                                publicSafe: true,
-                            };
-                            await recordMainLoopStep({
-                                store,
-                                sessionId,
-                                createdAt: now(),
-                                events,
-                                mainLoopSteps,
-                                step: createMainLoopStepRecord({
+                                    modelCaller,
+                                    toolMappings,
+                                    observations,
+                                    events,
+                                    sessionSummary: compactSessionSummary,
+                                    conversationWindow: compactConversationWindow,
+                                    toolDeclarationPreludeMaterials,
+                                    skillIndexMaterials,
+                                    projectContextGovernanceMaterials: preCompactGovernanceProjectContextMaterials,
+                                    toolContextSelection,
+                                    toolContextUsage: toolContextHeatState.usage,
+                                });
+                                events.push(...rebuiltPrompt.events);
+                                promptBoundaryEvents.push(...rebuiltPrompt.events);
+                                if (!rebuiltPrompt.ok) {
+                                    return {
+                                        ok: false,
+                                        error: {
+                                            code: rebuiltPrompt.error.code,
+                                            message: rebuiltPrompt.error.message,
+                                            boundary: "prompt",
+                                            publicSafe: true,
+                                        },
+                                        events: rebuiltPrompt.events,
+                                    };
+                                }
+                                for (const turnStep of rebuiltPrompt.turnRecord.stepRecords) {
+                                    await recordMainLoopStep({
+                                        store,
+                                        sessionId,
+                                        createdAt: now(),
+                                        events,
+                                        mainLoopSteps,
+                                        step: turnStep,
+                                    });
+                                }
+                                await recordMainLoopStep({
+                                    store,
                                     sessionId,
-                                    turnIndex: turn,
-                                    stepIndex: stepBase + 5,
-                                    actionPrimitive: "updateSummaryStateEvent",
-                                    status: "failed",
-                                    inputRefs: [prompt.promptPackId],
-                                    outputRefs: [],
-                                    promptPackRef: prompt.promptPackId,
-                                    now: now(),
-                                    error: compactStepError,
-                                }),
-                            });
-                            return {
-                                ok: false,
-                                error: compactError,
-                                events: promptBoundaryEvents,
-                            };
+                                    createdAt: now(),
+                                    events,
+                                    mainLoopSteps,
+                                    step: createMainLoopStepRecord({
+                                        sessionId,
+                                        turnIndex: turn,
+                                        stepIndex: stepBase + 8,
+                                        actionPrimitive: "lowerPrompt",
+                                        status: "completed",
+                                        inputRefs: [rebuiltPrompt.promptPackId],
+                                        outputRefs: [rebuiltPrompt.loweredPrompt.loweringId],
+                                        promptPackRef: rebuiltPrompt.promptPackId,
+                                        loweredPromptRef: rebuiltPrompt.loweredPrompt.loweringId,
+                                        now: now(),
+                                        metadata: {
+                                            materialRefs: rebuiltPrompt.loweredPrompt.materialRefs,
+                                            targetCapability: rebuiltPrompt.loweredPrompt.target.capabilityId,
+                                            compactRecordRef: compactResult.record.compactId,
+                                        },
+                                    }),
+                                });
+                                prompt = rebuiltPrompt;
+                                await recordMainLoopStep({
+                                    store,
+                                    sessionId,
+                                    createdAt: now(),
+                                    events,
+                                    mainLoopSteps,
+                                    step: createMainLoopStepRecord({
+                                        sessionId,
+                                        turnIndex: turn,
+                                        stepIndex: stepBase + 9,
+                                        actionPrimitive: "updateSummaryStateEvent",
+                                        status: "completed",
+                                        inputRefs: [compactResult.record.compactId],
+                                        outputRefs: [rebuiltPrompt.promptPackId],
+                                        promptPackRef: rebuiltPrompt.promptPackId,
+                                        now: now(),
+                                        metadata: {
+                                            decision: compactDecision,
+                                            compactRecord: compactResult.record,
+                                            rebuiltPromptPackTokens: rebuiltPrompt.promptPack.totalEstimatedTokens,
+                                        },
+                                    }),
+                                });
+                            }
+                            else {
+                                runnerError = kernelError("PROMPT_PACK_FAILED", compactResult.error.message, "runtime-state");
+                                const compactError = {
+                                    code: compactResult.error.code,
+                                    message: compactResult.error.message,
+                                    boundary: "prompt",
+                                    publicSafe: true,
+                                };
+                                const compactStepError = {
+                                    code: compactResult.error.code,
+                                    message: compactResult.error.message,
+                                    boundary: "runtime-state",
+                                    publicSafe: true,
+                                };
+                                await recordMainLoopStep({
+                                    store,
+                                    sessionId,
+                                    createdAt: now(),
+                                    events,
+                                    mainLoopSteps,
+                                    step: createMainLoopStepRecord({
+                                        sessionId,
+                                        turnIndex: turn,
+                                        stepIndex: stepBase + 5,
+                                        actionPrimitive: "updateSummaryStateEvent",
+                                        status: "failed",
+                                        inputRefs: [prompt.promptPackId],
+                                        outputRefs: [],
+                                        promptPackRef: prompt.promptPackId,
+                                        now: now(),
+                                        error: compactStepError,
+                                    }),
+                                });
+                                return {
+                                    ok: false,
+                                    error: compactError,
+                                    events: promptBoundaryEvents,
+                                };
+                            }
                         }
                     }
-                }
-                return { prompt, events: promptBoundaryEvents };
-            },
-            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 canUsePreviousProviderResponseId = providerResponseOutputItems.length === 0 && toolResultInputs.length === 0;
-                const previousProviderResponseId = canUsePreviousProviderResponseId &&
-                    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, {
+                    return { prompt, events: promptBoundaryEvents };
+                },
+                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,
-                        previousProviderResponseId,
                         promptCacheKey,
                     });
-                const cacheDebug = previousProviderResponseId === undefined
-                    ? candidateCacheDebug
-                    : buildPromptPackCacheDebug({
+                    const candidateCacheDebug = buildPromptPackCacheDebug({
                         promptPack: prompt.promptPack,
-                        providerBody,
+                        providerBody: providerBodyCandidate,
                         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: {
+                    const canUsePreviousProviderResponseId = providerResponseOutputItems.length === 0 && toolResultInputs.length === 0;
+                    const previousProviderResponseId = canUsePreviousProviderResponseId &&
+                        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,
+                        runtimeAuthResolver: options.runtimeAuthResolver,
+                        authSelection,
+                        providerCaller: options.providerCaller,
+                        modelClient: options.modelClient,
+                        openaiResponsesCaller: options.openaiResponsesCaller,
+                        openaiChatCompletionsCaller: options.openaiChatCompletionsCaller,
+                        anthropicMessagesCaller: options.anthropicMessagesCaller,
+                        geminiGenerateContentTransport: options.geminiGenerateContentTransport,
+                        providerBody,
+                        governance: { accepted: true },
+                        contract: { accepted: true },
+                        clientName: manifest.model.clientName,
+                        clientVersion: manifest.model.clientVersion,
+                        signal: options.interruptSignal,
+                    });
+                    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 ?? false,
+                        }
+                        : 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,
-                        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,
-                    runtimeAuthResolver: options.runtimeAuthResolver,
-                    authSelection,
-                    providerCaller: options.providerCaller,
-                    modelClient: options.modelClient,
-                    openaiResponsesCaller: options.openaiResponsesCaller,
-                    openaiChatCompletionsCaller: options.openaiChatCompletionsCaller,
-                    anthropicMessagesCaller: options.anthropicMessagesCaller,
-                    geminiGenerateContentTransport: options.geminiGenerateContentTransport,
-                    providerBody,
-                    governance: { accepted: true },
-                    contract: { accepted: true },
-                    clientName: manifest.model.clientName,
-                    clientVersion: manifest.model.clientVersion,
-                    signal: options.interruptSignal,
-                });
-                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 ?? false,
-                    }
-                    : 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,
-                    cacheDebug: observedCacheDebug,
-                    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({
+                        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,
+                        cacheDebug: observedCacheDebug,
+                        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,
-                        stepIndex: stepBase + 4,
-                        actionPrimitive: "invokeModel",
-                        status: modelResult.ok ? "completed" : "failed",
-                        inputRefs: [prompt.loweredPrompt.loweringId],
-                        outputRefs: [modelInvocationId],
-                        modelCallId: modelInvocationId,
+                        startStepIndex: stepBase + 20,
+                        tickKind: "model-only",
                         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 interrupted = options.interruptSignal?.aborted === true;
-                    const error = interrupted
-                        ? kernelError("MAIN_LOOP_INTERRUPTED", modelResult.error.message, "runtime-state")
-                        : kernelError("MODEL_INVOCATION_FAILED", modelResult.error.message, "model");
-                    runnerError = error;
-                    await recordKernelError({ store, sessionId, errorId: `error:model:${turn + 1}`, error, createdAt: now(), metadata: { modelInvocationId } });
+                        modelCallId: modelInvocationId,
+                        inputRefs: [prompt.promptPackId, prompt.loweredPrompt.loweringId],
+                        outputRefs: [modelInvocationId],
+                    });
+                    if (!modelResult.ok) {
+                        const interrupted = options.interruptSignal?.aborted === true;
+                        const error = interrupted
+                            ? kernelError("MAIN_LOOP_INTERRUPTED", modelResult.error.message, "runtime-state")
+                            : 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: false,
+                        ok: true,
                         modelCallId: modelInvocationId,
-                        error: {
-                            code: error.code,
-                            message: error.message,
-                            boundary: "model",
-                            publicSafe: true,
-                        },
+                        raw: modelResult.raw,
+                        usage: modelUsage === undefined
+                            ? undefined
+                            : {
+                                inputTokens: modelUsage.inputTokens,
+                                outputTokens: modelUsage.outputTokens,
+                                totalTokens: modelUsage.totalTokens,
+                                providerRaw: modelResult.usage,
+                            },
                         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,
-                    usage: modelUsage === undefined
-                        ? undefined
-                        : {
-                            inputTokens: modelUsage.inputTokens,
-                            outputTokens: modelUsage.outputTokens,
-                            totalTokens: modelUsage.totalTokens,
-                            providerRaw: modelResult.usage,
-                        },
-                    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({
+                },
+                interpretDecision: async (turn, model, prompt) => {
+                    const stepBase = turn * 20 + 2;
+                    const decisionResult = interpretModelDecision({
+                        raw: model.raw,
                         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({
+                        providerFamily,
+                        providerToolMappings: toolMappings,
+                        providerRawRef: model.modelCallId,
+                    });
+                    events.push(...decisionResult.events);
+                    await recordMainLoopStep({
+                        store,
                         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],
+                        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) : [],
                             },
-                        },
-                        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],
+                    });
+                    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,
                             },
-                        },
-                    }),
-                });
-                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({
+                            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,
-                        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") {
+                        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}:approval`,
+                            observationId: `${sessionId}:observation:${providerCallId}:tool-context-expanded`,
                             source: "runtime",
                             status: "completed",
-                            title: "Runtime approval resolved",
-                            summary: approval.reason ?? "model approval request was approved",
-                            refs: [providerCallId, decision.decisionId, approval.envelope.approvalId],
+                            title: "BaseTool context expanded",
+                            summary: `Expanded ${expansion.targetKind} BaseTool context for the next turn.`,
+                            refs: [providerCallId, decision.decisionId],
                             payload: {
-                                status: approval.status,
-                                reason: approval.reason,
-                                approvalId: approval.envelope.approvalId,
-                                requestedScopes: approval.envelope.requestedScopes,
-                                riskLevel: approval.envelope.riskLevel,
+                                expanded: expansion,
+                                selection: {
+                                    families: [...toolContextSelection.families],
+                                    groups: [...toolContextSelection.groups],
+                                    toolIds: [...toolContextSelection.toolIds],
+                                },
                             },
-                            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 = fileReadCacheKey(decision.toolCall.toolId, decision.toolCall.arguments);
-                const cachedRead = readCacheKey === undefined ? undefined : sameTurnFileReadCache.get(readCacheKey);
-                if (cachedRead?.fullFileRead === true) {
-                    const reused = duplicateFileReadRecord({
-                        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,
-                    }));
+                            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,
@@ -5048,47 +5008,37 @@ export class PraxisRuntimeKernel {
                             sessionId,
                             turnIndex: turn,
                             stepIndex: stepBase + 6 + decisionIndex,
-                            actionPrimitive: "invokeBaseTool",
+                            actionPrimitive: "emitEvent",
                             status: "completed",
                             inputRefs: [decision.decisionId],
-                            outputRefs: [reused.record.callId],
-                            toolCallId: reused.record.callId,
-                            observationRefs: [reused.observation.observationId],
+                            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: {
-                                toolId: reused.record.toolId,
-                                providerToolName: decision.toolCall.providerToolName ?? "",
-                                duplicateObservationReuse: true,
-                                duplicateOfToolCallId: cachedRead.callId,
+                                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: ["runtime.baseTool.fileRead.duplicateObservationReused"] };
-                }
-                const shellCacheKey = shellRunCacheKey(decision.toolCall.toolId, decision.toolCall.arguments);
-                const cachedShell = shellCacheKey === undefined ? undefined : sameTurnShellRunCache.get(shellCacheKey);
-                if (cachedShell !== undefined) {
-                    const reused = duplicateShellRunRecord({
-                        sessionId,
-                        toolCallId: decision.toolCall.callId,
-                        toolId: decision.toolCall.toolId,
-                        providerToolName: decision.toolCall.providerToolName,
-                        args: decision.toolCall.arguments,
-                        previousCallId: cachedShell.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(), {
+                    return {
                         ok: true,
-                        decisionId: decision.decisionId,
-                        duplicateOfToolCallId: cachedShell.callId,
-                    }));
+                        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,
@@ -5099,424 +5049,743 @@ export class PraxisRuntimeKernel {
                             sessionId,
                             turnIndex: turn,
                             stepIndex: stepBase + 6 + decisionIndex,
-                            actionPrimitive: "invokeBaseTool",
-                            status: "completed",
+                            actionPrimitive: "fail",
+                            status: "failed",
                             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: cachedShell.callId,
+                            error: {
+                                code: decision.failure?.code ?? "MODEL_DECISION_FAILED",
+                                message: decision.failure?.message ?? "model decision requested failure",
+                                boundary: "model",
+                                publicSafe: true,
                             },
+                            now: now(),
                         }),
                     });
-                    return { ok: true, continueLoop: true, events: ["runtime.baseTool.shellRun.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,
-                    agentReviewResolver: options.agentReviewResolver,
-                    mcpPlusRuntime,
-                    preparedSandbox: sandboxPrepared.sandbox,
-                    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);
-                const mcpPlusToolCallUpdated = await mcpPlusRuntime.recordToolCall({
-                    manifest,
-                    toolId: executed.record.toolId,
-                    ok: executed.record.ok,
-                    now: now(),
-                });
-                if (executed.record.ok && (mcpPlusToolCallUpdated ||
-                    manifest.harness.tools.find((tool) => tool.toolId === executed.record.toolId)?.metadata?.toolProviderKind === "mcp-plus-control")) {
-                    await refreshRuntimeMcpTools("session.checkpoint.after_mcp_tool");
-                }
-                if (invalidatesFileReadCache(executed.record.toolId)) {
-                    sameTurnFileReadCache.clear();
-                }
-                else if (readCacheKey !== undefined && executed.record.ok) {
-                    const output = isRecord(executed.record.output) ? executed.record.output : undefined;
-                    const truncated = output?.truncated === true;
-                    sameTurnFileReadCache.set(readCacheKey, {
-                        callId: executed.record.callId,
-                        fullFileRead: !truncated,
-                    });
-                }
-                if (shellCacheKey !== undefined && executed.record.ok) {
-                    sameTurnShellRunCache.set(shellCacheKey, { callId: executed.record.callId });
-                }
-                if (invalidatesShellRunCache(executed.record.toolId)) {
-                    sameTurnShellRunCache.clear();
-                }
-                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}`,
+                        errorId: `error:modelDecisionFail:${turn + 1}:${decisionIndex}`,
                         error,
                         createdAt: now(),
                         metadata: {
-                            toolCallId: executed.record.callId,
-                            toolId: executed.record.toolId,
-                            approvalRequired,
+                            decisionId: decision.decisionId,
+                            providerRawRef: decision.metadata.providerRawRef,
                         },
                     });
-                    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",
+                            boundary: "model-decision",
                             publicSafe: true,
                         },
-                        events: executed.events,
+                        events: ["agentCore.execution.mainLoop.runner.fail"],
                     };
-                }
-                return { ok: true, continueLoop: true, events: executed.events };
-            },
-            handleEphemeralProcedure: async ({ turnIndex: turn, decisionIndex, decision }) => {
-                const stepBase = turn * 20 + 2;
-                if (decision.ephemeralProcedurePlan === undefined) {
+                },
+                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: "MISSING_EPHEMERAL_PROCEDURE_PLAN",
-                            message: "ephemeralProcedurePlan decision is missing a procedure plan",
-                            boundary: "procedure",
+                            code: error.code,
+                            message: error.message,
+                            boundary: "approval",
                             publicSafe: true,
                         },
-                        events: ["agentCore.execution.mainLoop.runner.procedureRejected"],
+                        events: approval.events,
                     };
-                }
-                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,
-                    workspaceRoot: toolWorkspaceRoot,
-                    allowedRoots: toolAllowedRoots,
-                    allowToolExecution: options.allowToolExecution,
-                    store,
-                    approvalResolver: options.approvalResolver,
-                    agentReviewResolver: options.agentReviewResolver,
-                    preparedSandbox: sandboxPrepared.sandbox,
-                    dependencyRuntime: options.baseToolDependencyRuntime,
-                    onToolCallProgress: options.onToolCallProgress,
-                    interruptSignal: options.interruptSignal,
-                    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: {
+                },
+                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 = fileReadCacheKey(decision.toolCall.toolId, decision.toolCall.arguments);
+                    const cachedRead = readCacheKey === undefined ? undefined : sameTurnFileReadCache.get(readCacheKey);
+                    if (cachedRead?.fullFileRead === true) {
+                        const reused = duplicateFileReadRecord({
+                            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.fileRead.duplicateObservationReused"] };
+                    }
+                    const shellCacheKey = shellRunCacheKey(decision.toolCall.toolId, decision.toolCall.arguments);
+                    const cachedShell = shellCacheKey === undefined ? undefined : sameTurnShellRunCache.get(shellCacheKey);
+                    if (cachedShell !== undefined) {
+                        const reused = duplicateShellRunRecord({
+                            sessionId,
+                            toolCallId: decision.toolCall.callId,
+                            toolId: decision.toolCall.toolId,
+                            providerToolName: decision.toolCall.providerToolName,
+                            args: decision.toolCall.arguments,
+                            previousCallId: cachedShell.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: cachedShell.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: cachedShell.callId,
+                                },
+                            }),
+                        });
+                        return { ok: true, continueLoop: true, events: ["runtime.baseTool.shellRun.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,
+                        agentReviewResolver: options.agentReviewResolver,
+                        mcpPlusRuntime,
+                        preparedSandbox: sandboxPrepared.sandbox,
+                        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);
+                    const mcpPlusToolCallUpdated = await mcpPlusRuntime.recordToolCall({
+                        manifest,
+                        toolId: executed.record.toolId,
+                        ok: executed.record.ok,
+                        now: now(),
+                    });
+                    if (executed.record.ok && (mcpPlusToolCallUpdated ||
+                        manifest.harness.tools.find((tool) => tool.toolId === executed.record.toolId)?.metadata?.toolProviderKind === "mcp-plus-control")) {
+                        await refreshRuntimeMcpTools("session.checkpoint.after_mcp_tool");
+                    }
+                    if (invalidatesFileReadCache(executed.record.toolId)) {
+                        sameTurnFileReadCache.clear();
+                    }
+                    else if (readCacheKey !== undefined && executed.record.ok) {
+                        const output = isRecord(executed.record.output) ? executed.record.output : undefined;
+                        const truncated = output?.truncated === true;
+                        sameTurnFileReadCache.set(readCacheKey, {
+                            callId: executed.record.callId,
+                            fullFileRead: !truncated,
+                        });
+                    }
+                    if (shellCacheKey !== undefined && executed.record.ok) {
+                        sameTurnShellRunCache.set(shellCacheKey, { callId: executed.record.callId });
+                    }
+                    if (invalidatesShellRunCache(executed.record.toolId)) {
+                        sameTurnShellRunCache.clear();
+                    }
+                    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,
-                        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,
+                    }));
+                    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 (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,
+                    });
+                    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,
-                        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,
+                        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",
                     }));
-                }
-                await recordMainLoopStep({
-                    store,
-                    sessionId,
-                    createdAt: now(),
-                    events,
-                    mainLoopSteps,
-                    step: createMainLoopStepRecord({
+                    const procedureResult = await executeEphemeralProcedure({
+                        runtimeId,
+                        sessionId,
+                        manifest,
+                        executor,
+                        plan: decision.ephemeralProcedurePlan,
+                        workspaceRoot: toolWorkspaceRoot,
+                        allowedRoots: toolAllowedRoots,
+                        allowToolExecution: options.allowToolExecution,
+                        store,
+                        approvalResolver: options.approvalResolver,
+                        agentReviewResolver: options.agentReviewResolver,
+                        preparedSandbox: sandboxPrepared.sandbox,
+                        dependencyRuntime: options.baseToolDependencyRuntime,
+                        onToolCallProgress: options.onToolCallProgress,
+                        interruptSignal: options.interruptSignal,
+                        now,
+                        events,
+                    });
+                    await store.appendProcedure({
                         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: {
+                        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,
                         },
-                    }),
-                });
-                if (!procedureResult.ok) {
-                    const error = procedureResult.error ?? kernelError("PROCEDURE_INVOCATION_FAILED", "procedure invocation failed", "tool");
-                    await recordKernelError({
+                    });
+                    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,
-                        errorId: `error:procedure:${decision.ephemeralProcedurePlan.procedureId}`,
-                        error,
                         createdAt: now(),
-                        metadata: {
+                        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,
-                            decisionId: decision.decisionId,
-                            approvalRequired: error.code === "APPROVAL_REQUIRED",
-                        },
+                            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 (error.code === "MAIN_LOOP_INTERRUPTED") {
+                    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 === "MAIN_LOOP_INTERRUPTED") {
+                            runnerError = error;
+                            return {
+                                ok: false,
+                                error: {
+                                    code: error.code,
+                                    message: error.message,
+                                    boundary: "model",
+                                    publicSafe: true,
+                                },
+                                events: [],
+                            };
+                        }
+                        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: "model",
+                                boundary: error.code === "APPROVAL_REQUIRED" ? "approval" : "procedure",
                                 publicSafe: true,
                             },
                             events: [],
                         };
                     }
-                    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 interrupted = runnerResult.error.code === "MAIN_LOOP_INTERRUPTED";
-            const fallbackCode = interrupted
-                ? "MAIN_LOOP_INTERRUPTED"
-                : runnerResult.error.boundary === "prompt"
-                    ? "PROMPT_PACK_FAILED"
+                    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 interrupted = runnerResult.error.code === "MAIN_LOOP_INTERRUPTED";
+                const fallbackCode = interrupted
+                    ? "MAIN_LOOP_INTERRUPTED"
+                    : 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 = interrupted
+                    ? "runtime-state"
                     : 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 = interrupted
-                ? "runtime-state"
-                : 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, interrupted ? "interrupted" : error.code === "APPROVAL_REQUIRED" ? "waitingApproval" : "failed");
-            const snapshot = await store.readSession(sessionId);
-            return {
-                ok: false,
+                        ? "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, interrupted ? "interrupted" : 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,
-                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");
+                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,
@@ -5528,71 +5797,33 @@ export class PraxisRuntimeKernel {
                     turnIndex: maxModelTurns,
                     stepIndex: outputStepIndex,
                     actionPrimitive: "exposeOutput",
-                    status: "failed",
+                    status: "completed",
                     inputRefs: ["runtime.output.final"],
-                    error: {
-                        code: output.error.code,
-                        message: output.error.message,
-                        boundary: "output",
-                        publicSafe: true,
-                    },
+                    outputRefs: [output.exposed.outputId],
                     now: now(),
                 }),
             });
-            await recordKernelError({
-                store,
-                sessionId,
-                errorId: "error:output:final",
-                error,
-                createdAt: now(),
-                metadata: { outputId: `${sessionId}:output:final` },
-            });
-            const snapshot = await store.readSession(sessionId);
+            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: false,
+                ok: true,
                 runtimeId,
                 sessionId,
                 manifest,
-                error,
+                finalOutput,
+                modelCalls,
+                toolCalls,
                 mainLoopSteps,
                 events,
-                state: snapshot,
+                state: await store.readSession(sessionId),
             };
         }
-        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),
-        };
+        finally {
+            await shutdownRuntimeOwnedExecutor(runtimeOwnedExecutor, events);
+        }
     }
 }
 export function createPraxisRuntimeKernel(options = {}) {