maka-agent 0.2.0-dev.46.20260922 → 0.2.0-dev.48.20260923

package/node_modules/@maka/runtime-host/dist/server/client-capability-invocation-broker.js

@@ -82,7 +82,7 @@ export class ClientCapabilityInvocationBroker {
         }));
     }
     #prepare(registration, signal, timeoutMs, onProgress, requestInteraction, frameFor) {
-        const sender = this.#senderFor(registration.connectionId);
+        const sender = this.#senderFor(registration);
         if (!sender) {
             throw new ClientCapabilityInvocationError('capability_lost', 'Client Capability provider is unavailable');
         }
@@ -162,7 +162,7 @@ export class ClientCapabilityInvocationBroker {
                     invocation.requestInteraction = requestInteraction ?? invocation.requestInteraction;
                     invocation.phase = 'admitted';
                     this.#armTimer(invocation);
-                    const currentSender = this.#senderFor(invocation.registration.connectionId);
+                    const currentSender = this.#senderFor(invocation.registration);
                     if (!currentSender) {
                         this.#settle(invocation, undefined, new ClientCapabilityInvocationError('capability_lost', 'Client Capability provider disappeared before admission'), false);
                     }
@@ -183,7 +183,7 @@ export class ClientCapabilityInvocationBroker {
                 const invocation = this.#invocations.get(invocationId);
                 if (!invocation)
                     return;
-                const currentSender = this.#senderFor(invocation.registration.connectionId);
+                const currentSender = this.#senderFor(invocation.registration);
                 void currentSender
                     ?.send({ kind: 'client.capability.cancel', invocationId })
                     .catch(() => { });
@@ -279,10 +279,16 @@ export class ClientCapabilityInvocationBroker {
                 this.#acceptChunk(invocation, frame.index, frame.data);
         }
     }
-    async releaseConnection(connectionId) {
+    releaseConnection(connectionId) {
+        return this.#releaseWhere((registration) => registration.connectionId === connectionId);
+    }
+    releaseRegistration(registration) {
+        return this.#releaseWhere((candidate) => candidate === registration);
+    }
+    async #releaseWhere(matches) {
         const interactions = [];
         for (const invocation of [...this.#invocations.values()]) {
-            if (invocation.registration.connectionId !== connectionId)
+            if (!matches(invocation.registration))
                 continue;
             if (invocation.phase === 'dispatched' || invocation.phase === 'accepted') {
                 invocation.providerAvailability.abort(new ClientCapabilityInvocationError('capability_lost', 'Client Capability provider disconnected before admission'));
@@ -379,7 +385,7 @@ export class ClientCapabilityInvocationBroker {
                 this.#settle(invocation, undefined, terminalBeforeSend.error, terminalBeforeSend.releaseRemote);
                 return;
             }
-            const sender = this.#senderFor(invocation.registration.connectionId);
+            const sender = this.#senderFor(invocation.registration);
             if (!sender) {
                 this.#settle(invocation, undefined, new ToolOutcomeUnknownError('Client Capability provider disappeared before receiving an interaction result'), false);
                 return;
@@ -433,7 +439,7 @@ export class ClientCapabilityInvocationBroker {
             const current = this.#invocations.get(invocation.invocationId);
             if (current !== invocation)
                 return;
-            const sender = this.#senderFor(current.registration.connectionId);
+            const sender = this.#senderFor(current.registration);
             void sender
                 ?.send({ kind: 'client.capability.cancel', invocationId: current.invocationId })
                 .catch(() => { });
@@ -456,7 +462,7 @@ export class ClientCapabilityInvocationBroker {
         }
         this.#rememberRetired(invocation.invocationId);
         if (releaseRemote) {
-            const sender = this.#senderFor(invocation.registration.connectionId);
+            const sender = this.#senderFor(invocation.registration);
             void sender
                 ?.send({
                 kind: 'client.capability.release',

package/node_modules/@maka/runtime-host/dist/server/client-capability-recovery.js

@@ -20,53 +20,51 @@ import { compatibilityToolResultProjection } from '@maka/runtime/durable-tool-re
 const OUTCOME_UNKNOWN_TEXT = 'outcome_unknown: the Host restarted after dispatching this Client Capability call. The client-side effect may have happened; do not retry it automatically.';
 export async function recoverClientCapabilityOutcomes(store, sessionIds, now = Date.now) {
     let recovered = 0;
-    for (const sessionId of sessionIds) {
-        const operations = await store.listUnsettledToolOperations(sessionId);
-        for (const operation of operations) {
-            if (operation.recoveryMode !== 'outcome_unknown')
-                continue;
-            const ts = now();
-            const result = {
-                kind: 'text',
-                text: OUTCOME_UNKNOWN_TEXT,
-                uncertainOutcome: {
-                    code: 'outcome_unknown',
-                    retrySafe: false,
-                },
-            };
-            const responseContent = {
-                kind: 'function_response',
-                id: operation.providerToolCallId,
-                name: operation.toolName,
-                result,
-                isError: true,
-            };
-            const modelProjection = compatibilityToolResultProjection(responseContent, sessionId);
-            const runtimeEvent = {
-                id: `${operation.operationId}_response`,
-                invocationId: operation.invocationId,
-                runId: operation.runId,
-                sessionId,
-                turnId: operation.turnId,
-                ts,
-                partial: false,
-                role: 'tool',
-                author: 'tool',
-                content: { ...responseContent, ...(modelProjection ? { modelProjection } : {}) },
-                refs: {
-                    operationId: operation.operationId,
-                    toolCallId: operation.providerToolCallId,
-                },
-            };
-            const committed = await store.commitToolOutcome({
+    const operations = await store.listUnsettledToolOperations(sessionIds);
+    for (const operation of operations) {
+        if (operation.recoveryMode !== 'outcome_unknown')
+            continue;
+        const ts = now();
+        const result = {
+            kind: 'text',
+            text: OUTCOME_UNKNOWN_TEXT,
+            uncertainOutcome: {
+                code: 'outcome_unknown',
+                retrySafe: false,
+            },
+        };
+        const responseContent = {
+            kind: 'function_response',
+            id: operation.providerToolCallId,
+            name: operation.toolName,
+            result,
+            isError: true,
+        };
+        const modelProjection = compatibilityToolResultProjection(responseContent, operation.sessionId);
+        const runtimeEvent = {
+            id: `${operation.operationId}_response`,
+            invocationId: operation.invocationId,
+            runId: operation.runId,
+            sessionId: operation.sessionId,
+            turnId: operation.turnId,
+            ts,
+            partial: false,
+            role: 'tool',
+            author: 'tool',
+            content: { ...responseContent, ...(modelProjection ? { modelProjection } : {}) },
+            refs: {
                 operationId: operation.operationId,
-                journalEventId: `${operation.operationId}_outcome`,
-                runtimeEvent,
-                committedAt: ts,
-            });
-            if (committed.created)
-                recovered += 1;
-        }
+                toolCallId: operation.providerToolCallId,
+            },
+        };
+        const committed = await store.commitToolOutcome({
+            operationId: operation.operationId,
+            journalEventId: `${operation.operationId}_outcome`,
+            runtimeEvent,
+            committedAt: ts,
+        });
+        if (committed.created)
+            recovered += 1;
     }
     return recovered;
 }

package/node_modules/@maka/runtime-host/dist/server/context-coordinator.js

@@ -150,6 +150,8 @@ export class HostContextCoordinator {
                 return notFound('Session does not exist');
             throw error;
         }
+        if (header.backend === 'plugin-executor')
+            return operationUnavailable('External executors own their context. Start a new task instead of compacting.');
         if (header.isArchived) {
             return sessionArchived('Cannot compact an archived Session');
         }

package/node_modules/@maka/runtime-host/dist/server/execution-composition-factory.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { defineInteractiveRuntimeHostComposition, } from './host-composition.js';
+import { defineInteractiveRuntimeHostComposition, } from './host-composition-source.js';
 export async function createExecutionRuntimeHostCompositionSource(options, dependencies = {}) {
     const compositionOptions = {
         ...(options.initialization ? { initialization: options.initialization } : {}),

package/node_modules/@maka/runtime-host/dist/server/execution-composition.js

@@ -16,6 +16,8 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { createWorkHubResultRuntime } from './workhub-result-runtime.js';
+import { createJevRoutingModel } from './jev-routing-model.js';
 import { copyWorkHubAttachmentsToTarget } from './workhub-message-attachments.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { attachmentKindFromMimeType, MAX_READ_IMAGE_BYTES } from '@maka/core/attachments';
@@ -99,9 +101,10 @@ import { HostClientCapabilityCoordinator } from './client-capability-coordinator
 import { HostDailyReviewCoordinator } from './daily-review-coordinator.js';
 import { prepareHostAiSdkBackend } from './execution-model-composition.js';
 import { createInteractiveRunComposer, createInteractiveRunComposerFactory, routeInteractiveRunToolSurface, } from './interactive-run-composer.js';
-import { createHostGoalEvaluator, createHostDailyReviewModel, createHostMemoryExtractionModel, createHostPluginModel, createHostSessionEffectModel, } from './execution-model-authority.js';
+import { readDuringBackendCreation, createHostGoalEvaluator, createHostDailyReviewModel, createHostMemoryExtractionModel, createHostPluginModel, createHostSessionEffectModel, } from './execution-model-authority.js';
 import { HostExecutionInspectCoordinator } from './execution-inspect-coordinator.js';
 import { HostExternalSessionCoordinator } from './external-session-coordinator.js';
+import { boundedFailureDiagnostic } from './failure-diagnostic.js';
 import { HostSessionBundleCoordinator } from './session-bundle-coordinator.js';
 import { HostGoalCoordinator } from './goal-coordinator.js';
 import { HostGoalExecutionCoordinator } from './goal-execution-coordinator.js';
@@ -132,6 +135,7 @@ import { HostPlanCoordinator } from './plan-coordinator.js';
 import { HostProjectDirectoryAuthority, } from './project-directory-authority.js';
 import { HostProjectCatalogCoordinator } from './project-catalog-coordinator.js';
 import { HostProjectMembershipGate } from './project-membership-gate.js';
+import { HostBuiltinExternalAgentPluginCoordinator, withBuiltinExternalAgentCatalog, } from './builtin-external-agent-plugins.js';
 import { HostPluginPlatformCoordinator } from './plugin-platform-coordinator.js';
 import { HostPluginPlatform } from './plugin-platform.js';
 import { RootAdmissionOwner } from './root-admission-owner.js';
@@ -149,7 +153,7 @@ import { HostStorageMaintenance } from './storage-maintenance.js';
 import { HostSessionRevisionCoordinator } from './session-revision-coordinator.js';
 import { HostSessionEffectCoordinator } from './session-effect-coordinator.js';
 import { SessionContinuityCoordinator } from './session-continuity-coordinator.js';
-import { createSessionTranscriptReader, } from './session-transcript-reader.js';
+import { createSessionTranscriptReader, createTurnResultReader, } from './session-transcript-reader.js';
 import { HostSkillCatalogCoordinator, SkillCatalogInvocableContextError, } from './skill-catalog-coordinator.js';
 import { SkillCatalogRepository } from './skill-catalog-repository.js';
 import { HostSessionTodoCoordinator } from './session-todo-coordinator.js';
@@ -252,9 +256,28 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             executors: pluginExecutors,
             clientBridge: pluginClientBridge,
         });
-        const pluginPlatformCoordinator = new HostPluginPlatformCoordinator(pluginPlatform);
+        const pluginPlatformCoordinator = new HostPluginPlatformCoordinator(pluginPlatform, async (input) => {
+            if (input.kind === 'conversation') {
+                const header = await stores.sessionStore.readHeaderSnapshot(input.sessionId);
+                if (!header.executorId)
+                    return [];
+                return pluginExecutors.catalog({
+                    sessionId: input.sessionId,
+                    executorId: header.executorId,
+                    cwd: header.cwd,
+                    ...(header.executorConfig ? { configuration: header.executorConfig } : {}),
+                });
+            }
+            const catalog = await pluginExecutors.catalog({ cwd: input.cwd });
+            return withBuiltinExternalAgentCatalog(catalog);
+        });
         const openedProjectCatalog = storage.projectCatalog;
         const runtimePolicyStores = storage.runtimePolicy;
+        const builtinExternalAgentPlugins = new HostBuiltinExternalAgentPluginCoordinator({
+            platform: pluginPlatform,
+            controlDirectory: context.owner.controlDirectory,
+            readPolicy: () => runtimePolicyStores.runtimePolicy.getSnapshot(),
+        });
         const oauthCredentials = new HostOAuthExecutionAuthority(runtimePolicyStores);
         const openedScheduledTaskStore = storage.scheduledTasks;
         const openedPlanStore = storage.plan;
@@ -622,6 +645,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         }, projectMembership, context.requestDrain, new HostProjectDirectoryAuthority(options.projectDirectoryRoots));
         let rootCoordinator;
         let workHubCoordination;
+        let workHubResults;
         let canonicalProjection;
         let memory;
         let clientCapabilities;
@@ -633,7 +657,32 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         let dailyReview;
         const rootPort = {
             readLatestRootTurnLineage: (identity) => requireRootCoordinator(rootCoordinator).readLatestRootTurnLineage(identity),
-            readSessionHeader: (sessionId) => requireRootCoordinator(rootCoordinator).readSessionHeader(sessionId),
+            readSessionHeader: async (sessionId) => {
+                const projected = await requireRootCoordinator(rootCoordinator).readSessionHeader(sessionId);
+                if (!projected || projected.unavailableReason)
+                    return projected;
+                const header = await stores.sessionStore.readHeaderSnapshot(sessionId);
+                if (!header.executorId)
+                    return projected;
+                const [entry] = await pluginExecutors.catalog({
+                    sessionId,
+                    executorId: header.executorId,
+                    cwd: header.cwd,
+                    ...(header.executorConfig ? { configuration: header.executorConfig } : {}),
+                });
+                return {
+                    ...projected,
+                    idleOnly: true,
+                    supportsAttachments: entry?.supportsAttachments ?? false,
+                    ...(entry?.readiness === 'ready'
+                        ? {}
+                        : {
+                            unavailableReason: entry?.readiness === 'history_only'
+                                ? 'External conversation is history-only. Start a new task.'
+                                : 'Executor is unavailable. Check External Agents settings.',
+                        }),
+                };
+            },
             readRootState: (sessionId) => requireRootCoordinator(rootCoordinator).readRootState(sessionId),
             claimStopFence: (input, commitQueueFence, admission) => requireRootCoordinator(rootCoordinator).claimStopFence(input, commitQueueFence, admission),
             startFromMessage: (input, admission, commitAdmission) => requireRootCoordinator(rootCoordinator).startFromMessage(input, admission, commitAdmission),
@@ -675,8 +724,14 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         continuity = new SessionContinuityCoordinator(context.hostEpoch, (sessionId) => canonicalProjectionReader.read(sessionId), sessionAdmission, context.requestDrain, transcriptReader, (sessionId) => hostChanges.publishSessionCatalog(sessionId), context.sessionAccessAuthority);
         const continuityCoordinator = continuity;
         const planStore = observeInteractivePlanStoreWriter(openedPlanStore, (sessionId) => continuityCoordinator.enqueueSessionDomainChanged(sessionId, 'plan'), context.requestDrain);
-        unsubscribeTranscriptChanges = stores.sessionStore.subscribeTranscriptChanges((sessionId) => continuityCoordinator.enqueueCanonicalRefresh(sessionId));
-        unsubscribeRuntimeEventCommits = stores.runtimeEventStore.subscribeRuntimeEventCommits((sessionId) => continuityCoordinator.enqueueTranscriptAdvanced(sessionId));
+        unsubscribeTranscriptChanges = stores.sessionStore.subscribeTranscriptChanges((sessionId) => {
+            continuityCoordinator.enqueueCanonicalRefresh(sessionId);
+            sessionAdmission.detach(() => workHubResults?.notify(sessionId));
+        });
+        unsubscribeRuntimeEventCommits = stores.runtimeEventStore.subscribeRuntimeEventCommits((sessionId) => {
+            continuityCoordinator.enqueueTranscriptAdvanced(sessionId);
+            sessionAdmission.detach(() => workHubResults?.notify(sessionId));
+        });
         unsubscribeUsageChanges = openedUsageStores.subscribeSessionUsageChanges((sessionId) => continuityCoordinator.enqueueSessionDomainChanged(sessionId, 'usage'));
         dailyReview = new HostDailyReviewCoordinator({
             store: openedDailyReviewStore,
@@ -716,7 +771,10 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             preflightSessionSnapshot: (sessionId, interactionProjection) => canonicalProjectionReader.fitsCandidate(sessionId, {
                 interactions: interactionProjection,
             }),
-            refreshCanonicalContinuity: (sessionId, admission) => continuityCoordinator.refreshCanonical(sessionId, admission),
+            refreshCanonicalContinuity: async (sessionId, admission) => {
+                await continuityCoordinator.refreshCanonical(sessionId, admission);
+                sessionAdmission.detach(() => workHubResults?.notify(sessionId));
+            },
             onPoison: (error) => {
                 if (poisonFailure)
                     return;
@@ -783,7 +841,9 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 goalTools: requireGoal(goal).tools,
                 builtinTools,
                 hostTools,
-                resolveRootTools: (sessionId) => requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId),
+                resolveRootTools: (sessionId) => sessionId === WORKHUB_COORDINATION_SESSION_ID && workHubResults
+                    ? Promise.resolve([workHubResults.tool])
+                    : requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId),
                 resolvePluginTools: (sessionId, coreTools) => pluginTools.resolveContributions(sessionId, coreTools),
                 resolvePluginSystemPrompt: async (sessionId, promptContext, baseText) => {
                     const assembly = await pluginSystemPrompt.assemble({
@@ -835,6 +895,15 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     build: (factoryContext) => new PluginExecutorBackend({
                         sessionId: factoryContext.sessionId,
                         cwd: factoryContext.header.cwd,
+                        ...(factoryContext.header.model === executorId
+                            ? {}
+                            : { model: factoryContext.header.model }),
+                        ...(factoryContext.header.thinkingLevel
+                            ? { thinkingLevel: factoryContext.header.thinkingLevel }
+                            : {}),
+                        ...(factoryContext.header.executorConfig
+                            ? { configuration: factoryContext.header.executorConfig }
+                            : {}),
                         ...(factoryContext.systemPrompt ? { instructions: factoryContext.systemPrompt } : {}),
                         binding,
                     }),
@@ -911,7 +980,9 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             const capabilitySnapshot = requireClientCapabilities(clientCapabilities).snapshotForSession(sessionId);
             try {
                 const [graphTools, planState] = await Promise.all([
-                    requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId),
+                    sessionId === WORKHUB_COORDINATION_SESSION_ID && workHubResults
+                        ? Promise.resolve([workHubResults.tool])
+                        : requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId),
                     planStore.readState(sessionId),
                 ]);
                 const { runtimePolicy, surface } = await resolveInteractiveToolSurface({
@@ -1160,6 +1231,10 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         };
         clientCapabilities = new HostClientCapabilityCoordinator({
             activation: runtimePolicyActivation,
+            isSessionRetired: async (sessionId) => {
+                const state = await stores.sessionStore.probeSessionRemoval(sessionId);
+                return (state.kind === 'removed' || (state.kind === 'present' && state.record.header.isArchived));
+            },
             onModelToolsChanged: registerBackendInvalidation,
             interactions,
             grants: stores.interactionStore,
@@ -1235,9 +1310,32 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         }, {
             currentGraphId: (rootSessionId) => requireGraphCoordinator(graphCoordinator).currentGraphId(rootSessionId),
             beginNextGraphEpoch: async (rootSessionId) => (await requireGraphCoordinator(graphCoordinator).beginNextGraphEpoch(rootSessionId, (operation) => requireGraphSupervisorWake(graphSupervisorWake).runWithSessionWakesSuppressed(rootSessionId, operation, 'agent_graph_epoch_advanced'))).graphId,
-        }, (input) => sessionEffectCoordinator.nameSessionFromRootMessage(input), context.owner.capability.rootId, dependencies.workHubRoutingModel
-            ? (input) => workHubCoordination.prepareRoutingDecision(input)
-            : undefined);
+        }, (input) => sessionEffectCoordinator.nameSessionFromRootMessage(input), context.owner.capability.rootId, async (input) => {
+            // Explicit injection remains an experiment seam. Injected models own
+            // policy/egress checks and cancellation; this bypasses the production
+            // Jev preparation deadline (including its transcript-read protection).
+            if (dependencies.workHubRoutingModel)
+                return workHubCoordination.prepareRoutingDecision(input);
+            // One admission budget covers policy/transcript reads, both Jev asks,
+            // candidate resolution and transport cleanup; it is not per request.
+            const signal = AbortSignal.any([
+                ...(input.inputClosedSignal ? [input.inputClosedSignal] : []),
+                AbortSignal.timeout(8_000),
+            ]);
+            try {
+                const { policy } = await readDuringBackendCreation(() => runtimePolicyStores.runtimePolicy.getSnapshot(), signal);
+                if (!policy.jev?.enabled || policy.privacy.incognitoActive)
+                    return undefined;
+                return await readDuringBackendCreation(() => workHubCoordination.prepareRoutingDecision({ ...input, inputClosedSignal: signal }), signal);
+            }
+            catch {
+                if (!input.inputClosedSignal?.aborted) {
+                    const failure = signal.aborted ? 'timeout' : 'preparation_unavailable';
+                    console.warn(`[runtime-host] Jev routing fallback: ${failure}`);
+                }
+                return undefined;
+            }
+        });
         const coordinator = rootCoordinator;
         const pluginModel = createHostPluginModel({
             runtimePolicy: runtimePolicyStores,
@@ -1590,6 +1688,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         });
         async function applyRuntimePolicyMutationEffects() {
             try {
+                await builtinExternalAgentPlugins.reconcile();
                 await requireMemory(memory).refreshAfterPolicyMutation();
             }
             catch (error) {
@@ -1613,8 +1712,33 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             continuity: continuityCoordinator,
             workspaceResolver,
             requestDrain: context.requestDrain,
-            assertExecutorAvailable: (sessionId, executorId) => {
+            configureExecutor: async (header, configuration) => {
+                if (!header.executorId)
+                    throw new Error('Session has no executor');
+                await pluginExecutors.configureConversation(header.id, header.executorId, {
+                    conversationKey: header.id,
+                    cwd: header.cwd,
+                    configuration,
+                });
+            },
+            retireExecutor: (sessionId) => pluginExecutors.retireConversation(sessionId),
+            assertExecutorAvailable: async (sessionId, executorId, configuration, cwd) => {
                 pluginExecutors.identity(sessionId, executorId);
+                const [entry] = await pluginExecutors.catalog({
+                    cwd,
+                    executorId,
+                    discoverySessionId: sessionId,
+                });
+                if (!entry || entry.readiness !== 'ready')
+                    throw new Error('Executor is not ready');
+                // Catalog-managed executors pin their confirmed configuration on every create path.
+                // Providers without model discovery retain main's executor-specific model contract.
+                if (entry.supportsModelChange || entry.models.length > 0) {
+                    if (configuration?.model &&
+                        !entry.models.some((model) => model.id === configuration.model))
+                        throw new Error('Executor model is unavailable');
+                    return configuration ?? {};
+                }
             },
             ...(context.sessionAccessAuthority
                 ? { sessionAccessAuthority: context.sessionAccessAuthority }
@@ -1640,7 +1764,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             },
         });
         workHubCoordination = new HostWorkHubCoordinationCoordinator({
-            routingModel: dependencies.workHubRoutingModel,
+            routingModel: dependencies.workHubRoutingModel ?? createJevRoutingModel({ stores: runtimePolicyStores }),
             requestForm: (input) => interactions.requestForm(input),
             targetExecution: workHubTargetExecution,
             configureModel: (input) => sessionCatalog.configureWorkHubModel(input),
@@ -1789,7 +1913,12 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                             workspace: input.create.workspace,
                             name: input.create.title,
                             ...(input.create.defaults?.executorId
-                                ? { executorId: input.create.defaults.executorId }
+                                ? {
+                                    executorId: input.create.defaults.executorId,
+                                    ...(input.create.defaults.executorModel
+                                        ? { executorModel: input.create.defaults.executorModel }
+                                        : {}),
+                                }
                                 : {
                                     modelTarget: input.create.defaults?.model
                                         ? {
@@ -1803,6 +1932,9 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                             ...(input.create.defaults?.permissionMode
                                 ? { permissionMode: input.create.defaults.permissionMode }
                                 : {}),
+                            ...(input.create.defaults?.thinkingLevel
+                                ? { thinkingLevel: input.create.defaults.thinkingLevel }
+                                : {}),
                             collaborationMode: 'agent',
                             orchestrationMode: 'default',
                         })
@@ -1862,6 +1994,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                                         ? WORKHUB_COORDINATION_REPLACEMENT_SCHEMA_VERSION
                                         : 1,
                                     kind: 'delegation_assigned',
+                                    returnResults: true,
                                     actionId: input.actionId,
                                     actionFingerprint: input.actionFingerprint,
                                     coordinationTurnId: input.coordinationTurnId ?? input.actionId,
@@ -1928,6 +2061,20 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             },
             requestDrain: context.requestDrain,
         });
+        workHubResults = createWorkHubResultRuntime({
+            stores,
+            executions: coordinator,
+            messages,
+            interactions,
+            admission: sessionAdmission,
+            readTurnResult: createTurnResultReader({
+                stores,
+                canonicalPermissionOutcomes,
+                ensureTranscriptLedger: (sessionId) => requireSessionManager(manager).ensureTranscriptLedgerForRead(sessionId),
+            }),
+            acquireResidency: () => context.acquireResidency('hosted-execution'),
+            onError: (error) => console.error(`[runtime-host] WorkHub result reconciliation failed: ${boundedFailureDiagnostic(error)}`),
+        });
         scheduledTasks = new HostScheduledTaskCoordinator({
             store: openedScheduledTaskStore,
             sessions: stores.sessionStore,
@@ -1950,6 +2097,9 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         const sessionBundles = new HostSessionBundleCoordinator({
             lease: context.owner.lease,
             fenceSubtree: (sessionId, operation) => requireSessionManager(manager).runSessionSubtreeQuiescentMutation(sessionId, operation),
+            recoverInterruptedSessions: (sessionIds) => requireSessionManager(manager)
+                .recoverInterruptedSessionsForSessions(sessionIds)
+                .then(() => undefined),
             onImported: (sessionId) => hostChanges.publishSessionCatalog(sessionId),
         });
         const externalSessions = new HostExternalSessionCoordinator({
@@ -2007,7 +2157,13 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             sessionEffects: sessionEffectCoordinator,
             graph: requireGraphCoordinator(graphCoordinator),
             graphWake: requireGraphSupervisorWake(graphSupervisorWake),
-            manager,
+            manager: {
+                finalizeChildWorkspacePatches: (sessionId) => requireSessionManager(manager).finalizeChildWorkspacePatches(sessionId),
+                disposeSessionBackend: async (sessionId) => {
+                    await requireSessionManager(manager).disposeSessionBackend(sessionId);
+                    await pluginExecutors.retireConversation(sessionId);
+                },
+            },
             capabilities: clientCapabilities,
             continuity: continuityCoordinator,
             artifacts: openedArtifactStore,
@@ -2081,6 +2237,10 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     (connectionId) => pluginPlatformCoordinator.releaseConnection(connectionId),
                 ],
             }),
+            createRuntimeHostDomainModule({
+                id: 'builtin-external-agent-plugins',
+                recovery: { state: () => builtinExternalAgentPlugins.recover() },
+            }),
             createRuntimeHostDomainModule({
                 id: 'memory',
                 handlers: [requireMemory(memory).handlers],
@@ -2115,9 +2275,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                         recoverySessions = await stores.sessionStore.listForRecovery();
                         await worktreeChildExecutor.recover(recoverySessions.flatMap((session) => session.subagentWorkspace ? [session.subagentWorkspace] : []));
                         await sessionRevisions.recover();
-                        for (const session of recoverySessions) {
-                            await stores.runtimeEventStore.repairImmutableSteeringMessageProofsForRecovery(session.id);
-                        }
                     },
                 },
             }),
@@ -2194,8 +2351,13 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                                     await clientBoundRecovery;
                                 }
                                 catch (error) {
+                                    // The registration mutation has already committed. Returning a
+                                    // failure now would make the Client discard its new registration
+                                    // identity and mistake the old registration's release for
+                                    // authoritative Session retirement. Drain the unhealthy Host, but
+                                    // acknowledge the committed mutation so reconnect can republish it.
+                                    console.error(`[runtime-host] post-commit Client Capability recovery failed: ${boundedFailureDiagnostic(error)}`);
                                     context.requestDrain();
-                                    throw error;
                                 }
                             }
                             return outcome;
@@ -2258,6 +2420,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     },
                 },
                 drain: [
+                    () => workHubResults?.coordinator.beginDrain(),
                     () => turnAccessRequests?.beginDrain(),
                     () => rootCoordinator?.beginDrain(),
                     () => workspaceExecution?.beginDrain(),
@@ -2274,6 +2437,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                         rootCloseTask ??= coordinator.close();
                         await rootCloseTask;
                     },
+                    () => workHubResults?.coordinator.close(),
                     () => runtimeResources?.close(),
                     () => workspaceExecution?.close(),
                     () => sessionEffects?.close(),
@@ -2330,7 +2494,10 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             beginDrain();
         const handlers = composeRuntimeHostDomainHandlers(domainModules);
         const recover = () => {
-            recoveryTask ??= recoverRuntimeHostDomainModules(domainModules);
+            recoveryTask ??= recoverRuntimeHostDomainModules(domainModules).then(() => {
+                if (!draining)
+                    workHubResults?.coordinator.start();
+            });
             return recoveryTask;
         };
         const close = () => {

package/node_modules/@maka/runtime-host/dist/server/execution-model-authority.js

@@ -305,6 +305,9 @@ function createAuxiliaryModelCallAuthority(input) {
     };
 }
 async function runHostAuxiliaryModelCall(authority, input) {
+    if (input.header.backend === 'plugin-executor') {
+        throw new AuxiliaryModelCallConfigurationError('Plugin executor Sessions do not provide a native auxiliary model');
+    }
     const target = await readAuxiliaryPreflight(authority, input.abortSignal, () => readDuringBackendCreation(() => resolveExecutionTarget(input.header, authority.runtimePolicy, authority.oauthCredentials, authority.createFetchTransport), input.abortSignal));
     const pricingSnapshot = await readAuxiliaryPreflight(authority, input.abortSignal, () => readDuringBackendCreation(() => authority.usage.pricing.snapshot(), input.abortSignal));
     const request = input.buildRequest(target);
@@ -589,6 +592,9 @@ function parseDailyReviewModelKey(modelKey) {
     return connectionSlug && modelId ? { connectionSlug, modelId } : undefined;
 }
 export async function resolveExecutionTarget(header, runtimePolicy, oauthCredentials, createFetchTransport) {
+    if (header.backend === 'plugin-executor') {
+        throw new AuxiliaryModelCallConfigurationError('Plugin Executor Sessions do not expose the native auxiliary model authority');
+    }
     const resolved = await runtimePolicy.operations.resolveExecutionConnection(executionConnectionRef(header));
     if (resolved.kind !== 'ready') {
         throw new AuxiliaryModelCallConfigurationError(`Runtime Host model connection is not ready: ${resolved.kind}`);

package/node_modules/@maka/runtime-host/dist/server/extension-bundle.js

@@ -233,6 +233,10 @@ export function extensionPackageContentDigest(files) {
     }
     return `sha256-${hash.digest('hex')}`;
 }
+/** Computes the canonical digest used by PluginPackageStore without installing the package. */
+export async function extensionPackageDirectoryContentDigest(root) {
+    return extensionPackageContentDigest(await readDirectory(root));
+}
 function safePath(value) {
     if (!value ||
         value.length > 512 ||