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

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

@@ -29,9 +29,18 @@ import { PluginPackageStoreError } from './plugin-package-store.js';
 import { HostPluginPlatformError } from './plugin-platform.js';
 export class HostPluginPlatformCoordinator {
     platform;
+    queryExecutors;
     #streams = new Map();
     #pendingStreamOpens = new Map();
     handlers = {
+        'plugin.executor.query': async (input) => {
+            try {
+                return { ok: true, result: { items: await this.queryExecutors(input) } };
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
         'plugin.client.query': (input) => this.#client(input),
         'plugin.client.remote.call': (input, context) => this.#remoteCall(input, context),
         'plugin.client.remote.stream.open': (input, context) => this.#remoteStreamOpen(input, context),
@@ -45,8 +54,9 @@ export class HostPluginPlatformCoordinator {
         'plugin.composition.apply': (input) => this.#apply(input),
         'plugin.platform.reconcile': () => this.#reconcile(),
     };
-    constructor(platform) {
+    constructor(platform, queryExecutors = async () => []) {
         this.platform = platform;
+        this.queryExecutors = queryExecutors;
     }
     releaseConnection(connectionId) {
         for (const [streamId, stream] of this.#streams) {

package/node_modules/@maka/runtime-host/dist/server/process-lifecycle.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { RuntimeHostProcessTerminationRequiredError, } from './host-kernel.js';
+import { RuntimeHostProcessTerminationRequiredError } from './process-termination-error.js';
 export async function runRuntimeHostProcessLifecycle(host, options = {}) {
     let closing = false;
     const close = () => {

package/node_modules/@maka/runtime-host/dist/server/process-termination-error.js

@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export class RuntimeHostProcessTerminationRequiredError extends Error {
+    shutdownGraceMs;
+    code = 'process_termination_required';
+    constructor(shutdownGraceMs) {
+        super(`Runtime Host did not shut down within ${shutdownGraceMs} ms`);
+        this.shutdownGraceMs = shutdownGraceMs;
+        this.name = 'RuntimeHostProcessTerminationRequiredError';
+    }
+}

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

@@ -966,10 +966,10 @@ export class RootTurnCoordinator {
             };
             if (!(await this.bindRecoveryCapabilities(input.sessionId, execution)))
                 return { deferred: true };
-            execution = await this.prepareFreshWorkHubExecution(header, turnId, input.content, execution);
             const unavailableReason = runtimeHostExecutionUnavailableReason(header, execution);
             if (unavailableReason)
                 return { error: unavailableReason };
+            execution = await this.prepareFreshWorkHubExecution(header, turnId, input.content, execution);
             const reservation = this.reserveRootTurn(input.sessionId);
             if (!reservation)
                 return { error: 'Another root Turn is being admitted' };
@@ -1011,18 +1011,19 @@ export class RootTurnCoordinator {
         });
     }
     async prepareFreshWorkHubExecution(header, turnId, content, execution, inputClosedSignal) {
-        if (execution.kind !== 'workhub_coordination' || !this.prepareWorkHubRoutingDecision) {
+        if (execution.kind !== 'workhub_coordination' ||
+            execution.feedback ||
+            execution.operation === 'action' ||
+            !this.prepareWorkHubRoutingDecision) {
             return execution;
         }
-        return {
-            ...execution,
-            routingDecision: await this.prepareWorkHubRoutingDecision({
-                header,
-                turnId,
-                content,
-                ...(inputClosedSignal ? { inputClosedSignal } : {}),
-            }),
-        };
+        const routingDecision = await this.prepareWorkHubRoutingDecision({
+            header,
+            turnId,
+            content,
+            ...(inputClosedSignal ? { inputClosedSignal } : {}),
+        });
+        return routingDecision === undefined ? execution : { ...execution, routingDecision };
     }
     prepareMessage(input) {
         return this.runCommand(async () => {
@@ -1160,6 +1161,70 @@ export class RootTurnCoordinator {
         }
         return this.startRootMessage(request, context);
     }
+    /** Result delivery uses the same durable root admission as ordinary WorkHub turns.
+     * The deterministic Turn identity is the delivery receipt, including after a crash.
+     * Content is re-read under both Session admissions immediately before committing.
+     */
+    startWorkHubResult(origin, prepareContent) {
+        return this.runCommand(async () => {
+            const sessionId = WORKHUB_COORDINATION_SESSION_ID;
+            const turnId = origin.eventId;
+            let disposition;
+            const result = await this.sessionAdmission.runMany([sessionId, origin.targetSessionId], async (lease) => {
+                const previousDelivery = await this.stores.agentRunStore.readRootTurnAdmission(sessionId, turnId);
+                if (previousDelivery) {
+                    if (previousDelivery.execution.kind !== 'workhub_coordination' ||
+                        !isDeepStrictEqual(previousDelivery.execution.feedback, origin))
+                        throw new Error('WorkHub feedback identity conflict');
+                    return 'delivered';
+                }
+                if (!this.isSessionExecutionIdle(sessionId))
+                    return 'pending';
+                const content = await prepareContent(lease);
+                if (!content)
+                    return 'obsolete';
+                const previous = this.rootAdmissionOwner.latestAdmission(sessionId)?.execution;
+                const execution = {
+                    kind: 'workhub_coordination',
+                    inputDigest: messageContentDigest(content),
+                    feedback: origin,
+                    ...(previous?.kind === 'workhub_coordination' && previous.capabilityBinding
+                        ? { capabilityBinding: previous.capabilityBinding }
+                        : {}),
+                };
+                if (!(await this.bindRecoveryCapabilities(sessionId, execution)))
+                    return 'pending';
+                const header = await this.stores.sessionStore.readHeaderSnapshot(sessionId);
+                if (runtimeHostExecutionUnavailableReason(header, execution))
+                    return 'pending';
+                const reservation = this.reserveRootTurn(sessionId);
+                if (!reservation)
+                    return 'pending';
+                try {
+                    if (!this.beginRootAdmission(reservation))
+                        return 'pending';
+                    const admitted = await this.rootAdmissionOwner.admitRootTurn({
+                        sessionId,
+                        turnId,
+                        proposedRunId: randomUUID(),
+                        proposedUserMessageId: turnId,
+                        execution,
+                        normalizedInput: content,
+                        sourceMessages: [],
+                        admittedAt: Date.now(),
+                    });
+                    disposition = await this.prepareAdmittedTurn(activationInputForAdmission(admitted.admission), admitted.admission, this.acquireRecoveryResidency, lease, undefined, undefined, reservation);
+                    return 'delivered';
+                }
+                finally {
+                    this.releaseRootReservation(reservation);
+                }
+            });
+            if (disposition)
+                await this.resolveStartDisposition({ sessionId, turnId }, disposition);
+            return result;
+        });
+    }
     async runWorkHubCoordinationOperation(request, context) {
         if (request.execution.operation !== 'action' || !request.operation) {
             return operationUnavailable('Coordination action requires a Host operation');
@@ -1243,9 +1308,23 @@ export class RootTurnCoordinator {
                 admission.execution.kind !== 'workhub_coordination' ||
                 header.toolProfile !== 'workhub-coordination-v2')
                 return undefined;
+            let content = requireHostedExecutionMessageContent(admission);
+            if (admission.execution.feedback) {
+                const feedback = admission.execution.feedback;
+                const assignments = await this.stores.sessionStore.readActiveWorkHubAssignmentsByTarget([
+                    feedback.targetSessionId,
+                ]);
+                const assignment = assignments.find((a) => a.actionId === feedback.actionId && a.delegationId === feedback.delegationId);
+                if (!assignment)
+                    return undefined;
+                content = normalizeMessageContent({
+                    text: assignment.userText,
+                    ...(assignment.attachments ? { attachments: assignment.attachments } : {}),
+                });
+            }
             return {
                 runId: active.runId,
-                content: requireHostedExecutionMessageContent(admission),
+                content,
                 ...(admission.execution.routingDecision
                     ? { decision: admission.execution.routingDecision }
                     : {}),

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

@@ -453,6 +453,8 @@ function sameLocator(left, right) {
             return right.scope === 'connection' && left.connectionId === right.connectionId;
         case 'web_search':
             return right.scope === 'web_search' && left.provider === right.provider;
+        case 'jev':
+            return right.scope === 'jev';
         case 'network_proxy':
             return right.scope === 'network_proxy';
     }

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

@@ -71,7 +71,10 @@ export class HostSessionBundleCoordinator {
     }
     async #fenced(sessionId, operation) {
         try {
-            return await this.#options.fenceSubtree(sessionId, operation);
+            return await this.#options.fenceSubtree(sessionId, async (fencedSessionIds) => {
+                await this.#options.recoverInterruptedSessions(fencedSessionIds);
+                return operation(fencedSessionIds);
+            });
         }
         catch (error) {
             // Two types, because the Session manager translates on the way out: the

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

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { isExecutorConfiguration } from '@maka/core/executor-catalog';
 import { JsonArrayPageBudget } from './json-array-page-budget.js';
 import { RuntimeHostProtocolError } from '../protocol/errors.js';
 import { createHash } from 'node:crypto';
@@ -150,6 +151,8 @@ export class HostSessionCatalogCoordinator {
     #continuity;
     #workspaceResolver;
     #requestDrain;
+    #configureExecutor;
+    #retireExecutor;
     #assertExecutorAvailable;
     #sessionAccessAuthority;
     constructor(options) {
@@ -161,6 +164,8 @@ export class HostSessionCatalogCoordinator {
         this.#continuity = options.continuity;
         this.#workspaceResolver = options.workspaceResolver;
         this.#requestDrain = options.requestDrain;
+        this.#configureExecutor = options.configureExecutor;
+        this.#retireExecutor = options.retireExecutor;
         this.#assertExecutorAvailable = options.assertExecutorAvailable;
         this.#sessionAccessAuthority = options.sessionAccessAuthority;
     }
@@ -221,7 +226,7 @@ export class HostSessionCatalogCoordinator {
         const prepared = await prepareCreate(input);
         return this.#workspaceResolver.runWithUsageRecorded(input.workspace, async (workspace) => {
             const [model, policy] = await Promise.all([
-                this.#resolveCreateExecution(input),
+                this.#resolveCreateExecution(input, workspace.cwd),
                 this.#readRuntimePolicy(),
             ]);
             return {
@@ -232,7 +237,12 @@ export class HostSessionCatalogCoordinator {
                     ...(workspace.projectId === null ? {} : { projectId: workspace.projectId }),
                     name: prepared.name,
                     labels: [...prepared.labels],
-                    ...(model.executorId ? { executorId: model.executorId } : {}),
+                    ...(model.executorId
+                        ? {
+                            executorId: model.executorId,
+                            ...(model.executorConfig ? { executorConfig: model.executorConfig } : {}),
+                        }
+                        : {}),
                     ...(model.connectionId ? { llmConnectionId: model.connectionId } : {}),
                     llmConnectionSlug: model.connectionSlug,
                     model: model.model,
@@ -394,7 +404,7 @@ export class HostSessionCatalogCoordinator {
                 }
                 return await this.#workspaceResolver.runWithUsageRecorded(input.workspace, async (workspace) => {
                     const [model, policy] = await Promise.all([
-                        this.#resolveCreateExecution(input),
+                        this.#resolveCreateExecution(input, workspace.cwd),
                         this.#readRuntimePolicy(),
                     ]);
                     const createInput = {
@@ -402,7 +412,12 @@ export class HostSessionCatalogCoordinator {
                         ...(workspace.projectId === null ? {} : { projectId: workspace.projectId }),
                         name: prepared.name,
                         labels: [...prepared.labels],
-                        ...(model.executorId ? { executorId: model.executorId } : {}),
+                        ...(model.executorId
+                            ? {
+                                executorId: model.executorId,
+                                ...(model.executorConfig ? { executorConfig: model.executorConfig } : {}),
+                            }
+                            : {}),
                         ...(model.connectionId ? { llmConnectionId: model.connectionId } : {}),
                         llmConnectionSlug: model.connectionSlug,
                         model: model.model,
@@ -480,6 +495,7 @@ export class HostSessionCatalogCoordinator {
         }
         return this.#admission.run(input.sessionId, async (lease) => {
             let commitAttempted = false;
+            let confirmedExecutor;
             try {
                 const current = await this.#stores.readHeaderRecordSnapshot(input.sessionId);
                 if (authority === 'workhub' &&
@@ -499,12 +515,28 @@ export class HostSessionCatalogCoordinator {
                 const configuration = await this.#mergeConfigurationPatch(current.header, input.patch);
                 const clearsConnectionBlock = input.patch.modelTarget !== undefined &&
                     current.header.blockedReason === 'NO_REAL_CONNECTION';
-                if (!clearsConnectionBlock && sessionConfigurationMatches(current.header, configuration)) {
+                if (!clearsConnectionBlock &&
+                    !input.patch.executorConfig &&
+                    sessionConfigurationMatches(current.header, configuration)) {
                     return configurationSuccess({
                         kind: 'committed',
                         session: projectSessionCatalogRecord(await this.#stores.readCatalogRecord(input.sessionId, authority === 'workhub' ? 'recoverable' : 'ordinary')),
                     });
                 }
+                if (input.patch.executorConfig) {
+                    if (this.#manager.runningTurnIds(input.sessionId).length ||
+                        current.header.status === 'waiting_for_user')
+                        throw new SessionOperationFailure('operation_conflict', 'Executor model can only change while idle');
+                    if (!this.#configureExecutor)
+                        throw new SessionOperationFailure('operation_unavailable', 'Executor configuration is unavailable');
+                    try {
+                        await this.#configureExecutor(current.header, input.patch.executorConfig);
+                        confirmedExecutor = current.header;
+                    }
+                    catch {
+                        throw new SessionOperationFailure('operation_unavailable', 'The external agent did not confirm the model change. Retry while idle or start a new task.');
+                    }
+                }
                 commitAttempted = true;
                 await this.#manager.transitionSessionConfiguration(input.sessionId, {
                     expectedRevision: input.expectedRevision,
@@ -515,6 +547,8 @@ export class HostSessionCatalogCoordinator {
                 return configurationSuccess(await this.#committedUpdate(input.sessionId, lease, authority === 'workhub' ? 'recoverable' : 'ordinary'));
             }
             catch (error) {
+                if (confirmedExecutor)
+                    await this.#reconcileExecutorAfterFailedCommit(confirmedExecutor);
                 if (!commitAttempted &&
                     !isNotFound(error) &&
                     !(error instanceof SessionMetadataVersionConflictError) &&
@@ -529,6 +563,28 @@ export class HostSessionCatalogCoordinator {
             }
         });
     }
+    async #reconcileExecutorAfterFailedCommit(previous) {
+        try {
+            const actual = (await this.#stores.readHeaderRecordSnapshot(previous.id)).header;
+            if (actual.executorId !== previous.executorId ||
+                !actual.executorConfig?.model ||
+                !this.#configureExecutor)
+                throw new Error('Confirmed executor model is unavailable');
+            await this.#configureExecutor(actual, actual.executorConfig);
+        }
+        catch {
+            // When the durable value or rollback cannot be confirmed, never leave a
+            // live external Session that might answer on a different model.
+            try {
+                if (!this.#retireExecutor)
+                    throw new Error('Executor retirement is unavailable');
+                await this.#retireExecutor(previous.id);
+            }
+            catch {
+                this.#requestDrain();
+            }
+        }
+    }
     async #relocateWorkspace(input) {
         if (isWorkHubCoordinationSessionId(input.sessionId)) {
             return workspaceFailure('operation_conflict', 'WorkHub Coordination Session workspace requires WorkHub authority');
@@ -839,17 +895,50 @@ export class HostSessionCatalogCoordinator {
         };
     }
     async #mergeConfigurationPatch(current, patch) {
-        if (current.backend === 'fake' && patch.modelTarget === undefined) {
+        if (current.executorConfig && Object.keys(patch).some((key) => key !== 'executorConfig'))
+            throw new SessionOperationFailure('operation_unavailable', 'Native execution settings require a new Maka task');
+        if (patch.executorConfig &&
+            (!current.executorId ||
+                patch.executorTarget !== undefined ||
+                patch.modelTarget !== undefined ||
+                !isExecutorConfiguration(patch.executorConfig)))
+            throw new SessionOperationFailure('invalid_request', 'Invalid executor configuration');
+        if (current.backend === 'fake' &&
+            patch.modelTarget === undefined &&
+            patch.executorTarget === undefined) {
             throw new SessionOperationFailure('operation_conflict', 'Legacy test backend configuration requires an explicit account selection');
         }
         if (current.backend !== 'plugin-executor' &&
             current.llmConnectionId === undefined &&
-            patch.modelTarget === undefined) {
+            patch.modelTarget === undefined &&
+            patch.executorTarget === undefined) {
             throw new SessionOperationFailure('operation_conflict', 'Legacy Session configuration requires an explicit account selection');
         }
         const thinkingLevel = patch.thinkingLevel === undefined
             ? current.thinkingLevel
             : (patch.thinkingLevel ?? undefined);
+        if (patch.executorTarget !== undefined) {
+            let executorConfig;
+            try {
+                executorConfig = await this.#assertExecutorAvailable?.(current.id, patch.executorTarget.executorId, patch.executorTarget.model ? { model: patch.executorTarget.model } : undefined, current.cwd);
+            }
+            catch {
+                throw new SessionOperationFailure('operation_unavailable', `Plugin executor is unavailable: ${patch.executorTarget.executorId}`);
+            }
+            return {
+                backend: 'plugin-executor',
+                executorId: patch.executorTarget.executorId,
+                ...(executorConfig ? { executorConfig } : {}),
+                llmConnectionId: undefined,
+                llmConnectionSlug: `executor:${patch.executorTarget.executorId}`,
+                model: patch.executorTarget.model ?? patch.executorTarget.executorId,
+                thinkingLevel,
+                connectionLocked: current.connectionLocked,
+                permissionMode: patch.permissionMode ?? current.permissionMode,
+                collaborationMode: patch.collaborationMode ?? current.collaborationMode ?? 'agent',
+                orchestrationMode: patch.orchestrationMode ?? current.orchestrationMode ?? 'default',
+            };
+        }
         let model = {
             ...(current.llmConnectionId === undefined ? {} : { connectionId: current.llmConnectionId }),
             connectionSlug: current.llmConnectionSlug,
@@ -870,9 +959,10 @@ export class HostSessionCatalogCoordinator {
         return {
             backend: patch.modelTarget || current.backend === 'ai-sdk' ? 'ai-sdk' : 'plugin-executor',
             executorId: patch.modelTarget ? undefined : current.executorId,
+            executorConfig: patch.executorConfig ?? current.executorConfig,
             llmConnectionId: model.connectionId,
             llmConnectionSlug: model.connectionSlug,
-            model: model.model,
+            model: patch.executorConfig?.model ?? model.model,
             thinkingLevel,
             connectionLocked: patch.modelTarget === undefined ? current.connectionLocked : true,
             permissionMode: patch.permissionMode ?? current.permissionMode,
@@ -880,18 +970,24 @@ export class HostSessionCatalogCoordinator {
             orchestrationMode: patch.orchestrationMode ?? current.orchestrationMode ?? 'default',
         };
     }
-    async #resolveCreateExecution(input) {
+    async #resolveCreateExecution(input, cwd) {
         if (input.executorId) {
+            const requestedModel = input.executorConfig?.model ?? input.executorModel;
+            let executorConfig;
             try {
-                this.#assertExecutorAvailable?.(input.sessionId, input.executorId);
+                executorConfig = await this.#assertExecutorAvailable?.(input.sessionId, input.executorId, requestedModel ? { model: requestedModel } : input.executorConfig, cwd);
             }
             catch {
                 throw new SessionOperationFailure('operation_unavailable', `Plugin executor is unavailable: ${input.executorId}`);
             }
             return {
                 executorId: input.executorId,
+                ...((executorConfig ?? input.executorConfig)
+                    ? { executorConfig: executorConfig ?? input.executorConfig }
+                    : {}),
                 connectionSlug: `executor:${input.executorId}`,
-                model: input.executorId,
+                model: input.executorConfig?.model ?? input.executorModel ?? input.executorId,
+                thinkingLevel: input.thinkingLevel ?? undefined,
             };
         }
         if (!input.modelTarget) {
@@ -911,6 +1007,7 @@ export class HostSessionCatalogCoordinator {
 function sessionConfigurationMatches(header, configuration) {
     return (header.backend === configuration.backend &&
         header.executorId === configuration.executorId &&
+        header.executorConfig?.model === configuration.executorConfig?.model &&
         header.llmConnectionId === configuration.llmConnectionId &&
         header.llmConnectionSlug === configuration.llmConnectionSlug &&
         header.model === configuration.model &&
@@ -923,17 +1020,30 @@ function sessionConfigurationMatches(header, configuration) {
 function isPermissionModeOnlyPatch(patch) {
     return (patch.permissionMode !== undefined &&
         patch.modelTarget === undefined &&
+        patch.executorTarget === undefined &&
+        patch.executorConfig === undefined &&
         patch.thinkingLevel === undefined &&
         patch.collaborationMode === undefined &&
         patch.orchestrationMode === undefined);
 }
 async function prepareCreate(input) {
+    if (input.executorConfig !== undefined &&
+        (!input.executorId || !isExecutorConfiguration(input.executorConfig)))
+        throw new SessionOperationFailure('invalid_request', 'Invalid executor configuration');
     if ((input.executorId === undefined) === (input.modelTarget === undefined)) {
         throw new SessionOperationFailure('invalid_request', 'Session creation requires exactly one model target or executor id');
     }
     if (input.executorId !== undefined && !isExecutorId(input.executorId)) {
         throw new SessionOperationFailure('invalid_request', 'Session executor id is invalid');
     }
+    if (input.executorConfig?.model &&
+        input.executorModel !== undefined &&
+        input.executorConfig.model !== input.executorModel) {
+        throw new SessionOperationFailure('invalid_request', 'Conflicting executor models');
+    }
+    if (input.executorModel !== undefined && input.executorId === undefined) {
+        throw new SessionOperationFailure('invalid_request', 'Executor model requires an executor id');
+    }
     if (input.labels?.some(isExecutionSemanticLabel)) {
         throw new SessionOperationFailure('invalid_request', 'Session creation cannot set reserved execution labels');
     }
@@ -960,7 +1070,7 @@ function createRequestFingerprint(input, prepared) {
         prepared.name,
         prepared.labels,
         input.executorId
-            ? ['executor', input.executorId]
+            ? ['executor', input.executorId, input.executorConfig?.model ?? input.executorModel ?? null]
             : input.modelTarget?.kind === 'default'
                 ? ['default']
                 : [
@@ -1036,7 +1146,12 @@ export function projectSessionCatalogRecord(record, liveRunState) {
         ...(header.revisionIndex === undefined ? {} : { revisionIndex: header.revisionIndex }),
         ...(header.revisionState === undefined ? {} : { revisionState: header.revisionState }),
         backend: header.backend,
-        ...(header.executorId ? { executorId: header.executorId } : {}),
+        ...(header.executorId
+            ? {
+                executorId: header.executorId,
+                ...(header.executorConfig ? { executorConfig: header.executorConfig } : {}),
+            }
+            : {}),
         llmConnectionId: header.llmConnectionId ?? null,
         llmConnectionSlug: header.llmConnectionSlug,
         connectionLocked: header.connectionLocked,

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

@@ -90,12 +90,15 @@ export class HostSessionEffectCoordinator {
             const header = await this.#readSessionHeader(sessionId);
             if (header.titleIsManual || header.name !== DEFAULT_SESSION_NAME)
                 return;
-            generated = await this.#model.generateTitle({
-                sessionId,
-                header,
-                sourceText,
-                abortSignal,
-            });
+            generated =
+                header.backend === 'plugin-executor'
+                    ? undefined
+                    : await this.#model.generateTitle({
+                        sessionId,
+                        header,
+                        sourceText,
+                        abortSignal,
+                    });
         }
         catch {
             // An unreachable title model is not a Session failure; the fallback name
@@ -195,6 +198,9 @@ export class HostSessionEffectCoordinator {
             if (header.isArchived) {
                 return settledRecap(recapFailure('session_archived', 'Archived Session cannot generate a recap'));
             }
+            if (header.backend === 'plugin-executor') {
+                return settledRecap(recapFailure('operation_unavailable', 'Plugin executor Sessions do not support native recap generation'));
+            }
             const view = await this.#readModel.getSessionView(input.sessionId);
             if (abort.signal.aborted) {
                 return settledRecap(recapFailure('host_draining', 'Runtime Host is draining'));

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

@@ -146,7 +146,7 @@ export class HostSessionRetirementCoordinator {
                     handles.goal.commit();
                     handles.scheduledTasks.commit();
                     await this.#graphWake.retireSessions(family.sessionIds);
-                    this.#capabilities.retireSessions(family.sessionIds);
+                    await this.#capabilities.retireSessions(family.sessionIds);
                     this.#messages.retireSessions(family.sessionIds);
                     await this.#refreshFamily(family);
                     return lifecycleSuccess(projectSessionCatalogRecord(await this.#stores.readCatalogRecord(target.header.id)));
@@ -215,7 +215,7 @@ export class HostSessionRetirementCoordinator {
                     await this.#graphWake.retireSessions(allSessionIds);
                     this.#rememberRetiredWorktrees(committableRemove, removedSessionIds);
                     this.#scheduleCleanup(removedSessionIds);
-                    this.#capabilities.retireSessions(allSessionIds);
+                    await this.#capabilities.retireSessions(allSessionIds);
                     this.#messages.retireSessions(allSessionIds);
                     await this.#continuity.retireSessions(plan.remove.sessionIds, plan.remove.admission);
                     await this.#refreshFamily(plan.archive);

package/node_modules/@maka/runtime-host/dist/server/session-transcript-reader.js

@@ -47,6 +47,16 @@ export function createSessionTranscriptReader(input) {
         readDurableTurnLandmarks: async (sessionId, request) => (await prepared(sessionId)).readTurnLandmarks(sessionId, request),
     };
 }
+/** Reads only the delegated Turn's projected assistant output. The indexed
+ * Turn extent avoids materializing every earlier message in its Session.
+ */
+export function createTurnResultReader(input) {
+    const ledger = createDurableLedgerTranscriptReader(input);
+    return async (sessionId, turnId) => {
+        await input.ensureTranscriptLedger?.(sessionId);
+        return ledger.readLatestAssistantForTurn(sessionId, turnId);
+    };
+}
 /**
  * Pages seek immutable Session event ordinals before decoding payloads. One
  * Turn is projected at a time, so a page costs one Turn rather than the
@@ -149,6 +159,29 @@ function createDurableLedgerTranscriptReader(input) {
         source,
         readHighWater: highWater,
         ...pagedTranscriptReads(source),
+        async readLatestAssistantForTurn(sessionId, turnId) {
+            const extents = await store.readTranscriptTurns(sessionId, { turnId });
+            let result = '';
+            for (const extent of extents) {
+                for (let ordinal = extent.firstOrdinal; ordinal <= extent.lastOrdinal;) {
+                    const run = await readRun(sessionId, {
+                        direction: 'newer',
+                        throughOrdinal: extent.lastOrdinal,
+                        position: ordinal,
+                    });
+                    if (!run)
+                        break;
+                    if (run.invocation.turnId === turnId) {
+                        for (const { message } of await projectTurn(run)) {
+                            if (message.type === 'assistant' && message.text.trim())
+                                result = message.text;
+                        }
+                    }
+                    ordinal = run.lastOrdinal + 1;
+                }
+            }
+            return result;
+        },
         /** One row per Turn, folded from the Turn's own projected messages. */
         async readTurnContributions(sessionId, throughSequence, position, maxContributions) {
             const watermark = throughSequence ?? (await highWater(sessionId));

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

@@ -731,6 +731,10 @@ export class HostWorkHubCoordinationCoordinator {
         catch {
             // Invalid output, unavailable candidates, or provider failure cannot
             // silently become creation or bind an arbitrary existing Session.
+            // Preparation failures (for example transcript reads) and injected-model
+            // throws bind this admission to clarify, preventing actions for this turn.
+            // This differs intentionally from Jev's internal provider/candidate errors:
+            // that opt-in adapter returns undefined to preserve the legacy unbound path.
             return { kind: 'routing', disposition: 'clarify' };
         }
     }