maka-agent 0.2.0-dev.24.20260907 → 0.2.0-dev.26.20260909

package/node_modules/@maka/runtime-host/dist/server/interactive-run-composer.js

@@ -52,31 +52,44 @@ export function createInteractiveRunComposer(input) {
         : input.builtinTools;
     const inventorySnapshotFor = createTurnSkillInventorySnapshotResolver(input.skills);
     const inventoryFor = async (context) => (await inventorySnapshotFor(context)).inventory;
-    const defaultTools = input.boundTools
-        ? input.boundTools
-        : buildDefaultHostTools(input.sessionTodo, inventoryFor, builtinTools, input.hostTools, input.scheduledTaskTool, input.goalTools, input.parentAgentTools, input.plan, input.deepResearch?.tools);
     const hasToolCeiling = input.boundTools !== undefined || input.toolProfile !== undefined;
-    const clientCapabilityTools = hasToolCeiling ? [] : (input.clientCapabilities?.tools ?? []);
-    const unscopedCandidateTools = [...defaultTools, ...clientCapabilityTools];
-    const routedCandidateTools = input.deepResearch
-        ? unscopedCandidateTools.filter(isDeepResearchToolAllowed)
-        : unscopedCandidateTools;
-    const candidateTools = projectHostedExecutionTools(routedCandidateTools, input.toolProfile);
     const activeExecution = input.plan ? activePlanExecution(input.plan.state) : undefined;
-    const selectedTools = input.plan
-        ? selectCollaborationTools({
-            mode: input.plan.mode,
-            tools: candidateTools,
-            hasActiveExecution: activeExecution !== undefined,
-            fullAccess: input.plan.permissionMode === 'bypass',
-        })
-        : candidateTools;
-    // A bound tool list is an exact child/local activation ceiling. Dynamic
-    // capabilities must be included by the authority that constructs that
-    // list. The ceiling is also an exact wire contract: no deferred search
-    // groups inside it, so the bound tools stay fully visible.
-    const tools = [...selectedTools];
-    assertUniqueToolNames(tools);
+    // The base Host binding is immutable for this backend. Only scoped plugin
+    // contributions are sampled at logical step boundaries.
+    const defaultTools = input.boundTools
+        ? input.boundTools
+        : buildDefaultHostTools(input.sessionTodo, inventoryFor, builtinTools, input.hostTools ?? [], input.scheduledTaskTool, input.goalTools, input.parentAgentTools, input.plan, input.deepResearch?.tools);
+    const clientCapabilityTools = input.boundTools !== undefined ||
+        (input.toolProfile !== undefined && input.toolProfile !== 'workhub-coordination-v2')
+        ? []
+        : (input.clientCapabilities?.tools ?? []);
+    const resolveTools = () => {
+        const stableHostTools = [...defaultTools, ...clientCapabilityTools];
+        const additionalTools = hasToolCeiling
+            ? []
+            : (input.resolveAdditionalTools?.(stableHostTools) ?? []);
+        const unscopedCandidateTools = [...stableHostTools, ...additionalTools];
+        const routedCandidateTools = input.deepResearch
+            ? unscopedCandidateTools.filter(isDeepResearchToolAllowed)
+            : unscopedCandidateTools;
+        const candidateTools = projectHostedExecutionTools(routedCandidateTools, input.toolProfile);
+        const selectedTools = input.plan
+            ? selectCollaborationTools({
+                mode: input.plan.mode,
+                tools: candidateTools,
+                hasActiveExecution: activeExecution !== undefined,
+                fullAccess: input.plan.permissionMode === 'bypass',
+            })
+            : candidateTools;
+        // A bound tool list is an exact child/local activation ceiling. Dynamic
+        // capabilities must be included by the authority that constructs that
+        // list. The ceiling is also an exact wire contract: no deferred search
+        // groups inside it, so the bound tools stay fully visible.
+        const resolved = [...selectedTools];
+        assertUniqueToolNames(resolved);
+        return Object.freeze(resolved);
+    };
+    const tools = resolveTools();
     const hostCapabilities = buildHostCapabilitiesFromBinding(tools.map(({ name }) => name));
     const toolAvailability = hasToolCeiling
         ? undefined
@@ -160,6 +173,7 @@ export function createInteractiveRunComposer(input) {
         composerId: INTERACTIVE_RUN_COMPOSER_ID,
         composerRevision: INTERACTIVE_RUN_COMPOSER_REVISION,
         tools,
+        resolveTools,
         toolAvailability,
         resolveSystemPrompt,
     });
@@ -248,6 +262,20 @@ export function createInteractiveRunComposerFactory(input) {
                 ...(clientCapabilities ? { clientCapabilities } : {}),
                 ...(input.builtinTools ? { builtinTools: input.builtinTools } : {}),
                 ...(hostTools.length > 0 ? { hostTools } : {}),
+                ...(input.resolvePluginTools && !backendContext.tools
+                    ? {
+                        resolveAdditionalTools: (hostTools) => {
+                            return routeInteractiveRunToolSurface({
+                                runtimePolicy,
+                                connection,
+                                modelId,
+                                hostTools: input.resolvePluginTools(backendContext.sessionId, hostTools).tools,
+                                worktreePatchWriteBackAvailable: input.worktreePatchWriteBackAvailable,
+                                tavilyReady,
+                            }).hostTools;
+                        },
+                    }
+                    : {}),
                 ...(input.scheduledTaskTool ? { scheduledTaskTool: input.scheduledTaskTool } : {}),
                 ...(input.goalTools ? { goalTools: input.goalTools } : {}),
                 ...(parentAgentTools ? { parentAgentTools } : {}),

package/node_modules/@maka/runtime-host/dist/server/operation-dispatcher.js

@@ -16,14 +16,13 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { truncateUtf8 } from '@maka/core/diagnostic-log';
-import { redactSecrets } from '@maka/core/redaction';
 import { HOST_OPERATION_SPECS, decodeOperationOutcome, } from '../protocol/index.js';
 import { HOST_BOOTSTRAP_OPERATION_SPECS } from '../protocol/host-status.js';
 import { HOST_RESOURCE_OPERATION_SPECS } from '../protocol/host-resources.js';
 import { ACCESS_AUTHORITY_OPERATION_SPECS } from '../protocol/access-authority.js';
 import { SESSION_COLLABORATION_OPERATION_SPECS } from '../protocol/session-collaboration.js';
 import { PEER_MESH_OPERATION_SPECS } from '../protocol/peer-mesh.js';
+import { boundedFailureDiagnostic } from './failure-diagnostic.js';
 import { createPeerMeshOperationHandlers } from './peer-mesh-authority.js';
 /**
  * The spec objects a Runtime Host serves from its own core — operations that
@@ -144,7 +143,7 @@ async function dispatchTypedOperation(request, handlers, context) {
         outcome = decodeOperationOutcome(request.operation, await handler(request.input, context));
     }
     catch (error) {
-        console.error(`[runtime-host] unexpected ${request.operation} failure: ${boundedUnexpectedFailure(error)}`);
+        console.error(`[runtime-host] unexpected ${request.operation} failure: ${boundedFailureDiagnostic(error)}`);
         return operationFailureResponse(request, 'internal_failure', 'Runtime Host operation failed');
     }
     return outcome.ok
@@ -161,7 +160,3 @@ async function dispatchTypedOperation(request, handlers, context) {
             error: outcome.error,
         };
 }
-function boundedUnexpectedFailure(error) {
-    const details = error instanceof Error ? error.stack || `${error.name}: ${error.message}` : String(error);
-    return truncateUtf8(redactSecrets(details), 8 * 1024, '\n<diagnostic truncated>');
-}

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

@@ -56,6 +56,12 @@ export class HostPluginPlatformCoordinator {
                     const inspections = flattenInspections(this.platform.inspect(input.rootId));
                     return { ok: true, result: boundedPage('entries', inspections, input) };
                 }
+                if (input.view === 'tools') {
+                    return {
+                        ok: true,
+                        result: boundedPage('tools', this.platform.inspectTools(input.rootId), input),
+                    };
+                }
                 if (input.view === 'failures') {
                     return { ok: true, result: boundedPage('failures', failures, input) };
                 }

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

@@ -42,6 +42,7 @@ export class HostPluginPlatform {
     #packages;
     #packageLoader;
     #store;
+    #tools;
     #authority = emptyCompositionAuthority();
     #desired = emptyCompositionState();
     #mutation = Promise.resolve();
@@ -62,6 +63,7 @@ export class HostPluginPlatform {
         this.#packageLoader =
             options.packageLoader ?? new TrustedPluginPackageLoader(controlDirectory, this.#packages);
         this.#store = options.store ?? new HostPluginCompositionStore(controlDirectory);
+        this.#tools = options.tools;
     }
     async recover() {
         if (this.#recoveryStarted ||
@@ -338,6 +340,10 @@ export class HostPluginPlatform {
         this.#assertReadable();
         return this.#composition.inspectTree(rootId);
     }
+    inspectTools(rootId) {
+        this.#assertReadable();
+        return this.#tools?.inspect(rootId) ?? Object.freeze([]);
+    }
     async status() {
         this.#assertReadable();
         return Object.freeze({

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

@@ -21,7 +21,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { readLogicalRuntimeExecution, readLogicalRuntimeExecutionForRun, } from '@maka/core/runtime-logical-execution';
 import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
 import { INLINE_REFERENCE_MAX_COUNT, messageContentDigest, messageContentsEqual, normalizeMessageContent, } from '@maka/core/events';
-import { isWorkHubCoordinationSessionId } from '@maka/core/session';
+import { WORKHUB_COORDINATION_SESSION_ID, isWorkHubCoordinationSessionId, } from '@maka/core/session';
 import { resolveEffectiveOrchestration } from '@maka/core/orchestration';
 import { decodeSkillInvocationResult, } from '@maka/core/skill-invocation';
 import { agentGraphIdForRootSession } from '@maka/runtime/stream-graph-coordinator';
@@ -222,6 +222,10 @@ export class RootTurnCoordinator {
             throw error;
         }
     }
+    /** Called under Session admission before changing an execution's authority ceiling. */
+    isSessionExecutionIdle(sessionId) {
+        return (!this.#recoveryPlansBySession.has(sessionId) && this.readRootState(sessionId).kind === 'idle');
+    }
     readRootState(sessionId) {
         const active = this.#executions.get(sessionId);
         if (active) {
@@ -565,7 +569,10 @@ export class RootTurnCoordinator {
         if (isWorkHubCoordinationSessionId(input.sessionId)) {
             return Promise.reject(new RuntimeHostedRootUnavailableError(input.sessionId, WORKHUB_COORDINATION_EXECUTION_UNAVAILABLE_REASON));
         }
-        return this.runCommand(async () => {
+        // Admission is active work even while queued behind a Session gate. Its
+        // residency overlaps the execution residency until admission settles.
+        const residency = this.acquireRecoveryResidency();
+        const admission = this.runCommand(async () => {
             const activeAtEntry = this.#executions.has(input.sessionId);
             let reservation = preparedReservation ?? (activeAtEntry ? undefined : this.reserveRootTurn(input.sessionId));
             if (preparedReservation && this.#admissions.get(input.sessionId) !== preparedReservation) {
@@ -674,6 +681,7 @@ export class RootTurnCoordinator {
                 throw error.cause;
             throw error;
         });
+        return admission.finally(() => residency.release());
     }
     lookup(sessionId, turnId) {
         return this.runCommand(async () => {
@@ -1090,15 +1098,92 @@ export class RootTurnCoordinator {
         if (!isWorkHubCoordinationSessionId(request.sessionId)) {
             return Promise.resolve(operationUnavailable('WorkHub Coordination execution requires its reserved Session'));
         }
+        if ((request.execution.operation === 'action') !== (request.operation !== undefined)) {
+            return Promise.resolve(operationUnavailable('Coordination execution mode does not match its runner'));
+        }
         return this.startRootMessage(request, context);
     }
-    /**
-     * Whether a durable root Turn already owns this identity. WorkHub also writes
-     * Coordination Turns outside this coordinator, and must not append a second
-     * triplet into a Turn this admission ledger already owns.
-     */
-    async hasRootTurnAdmission(sessionId, turnId) {
-        return (await this.stores.agentRunStore.readRootTurnAdmission(sessionId, turnId)) !== undefined;
+    async runWorkHubCoordinationOperation(request, context) {
+        if (request.execution.operation !== 'action' || !request.operation) {
+            return operationUnavailable('Coordination action requires a Host operation');
+        }
+        let turnId = request.turnId;
+        let recoveredReceipt;
+        // A retry preserves the action identity, but never reopens a terminal Run.
+        // The existing admission chain and terminal facts identify prior attempts.
+        for (;;) {
+            const admission = await this.stores.agentRunStore.readRootTurnAdmission(request.sessionId, turnId);
+            if (!admission)
+                break;
+            if (!rootExecutionMatches(admission.execution, request.execution))
+                return operationConflict('Coordination action identity belongs to different content');
+            const run = await this.readRunIfPresent(request.sessionId, admission.runId);
+            if (!run)
+                break;
+            const snapshot = await this.readCanonicalSnapshot(request.sessionId, turnId, admission.runId, run);
+            if (!isTerminalSnapshot(snapshot) || snapshot.status === 'completed')
+                break;
+            // A crash after the receipt does not erase a completed Host effect.
+            const events = await this.stores.runtimeEventStore.readImmutableRuntimeEvents(request.sessionId, admission.runId);
+            recoveredReceipt ??= events.find((event) => event.actions?.coordination)?.actions
+                ?.coordination;
+            turnId = `whretry_${createHash('sha256').update(admission.runId).digest('hex').slice(0, 48)}`;
+        }
+        const receiptToReplay = recoveredReceipt;
+        const started = await this.startWorkHubCoordinationMessage({
+            ...request,
+            turnId,
+            ...(receiptToReplay ? { operation: async () => receiptToReplay } : {}),
+        }, context);
+        if (!started.ok)
+            return started;
+        const active = this.#executions.get(request.sessionId);
+        if (active?.turnId === turnId)
+            await active.done;
+        const snapshot = await this.readCanonicalSnapshot(request.sessionId, turnId, started.result.runId);
+        if (snapshot.status !== 'completed')
+            return operationUnavailable('Coordination operation did not complete');
+        const events = await this.stores.runtimeEventStore.readImmutableRuntimeEvents(request.sessionId, started.result.runId);
+        const receipt = events.find((event) => event.actions?.coordination)?.actions?.coordination;
+        return receipt
+            ? { ok: true, result: receipt }
+            : operationUnavailable('Coordination receipt is unavailable');
+    }
+    coordinationOperation(request, admission) {
+        if (request.execution.kind !== 'workhub_coordination' ||
+            !('operation' in request) ||
+            !request.operation)
+            return undefined;
+        const execute = request.operation;
+        const content = requireHostedExecutionMessageContent(admission);
+        return {
+            sessionId: admission.sessionId,
+            turnId: admission.turnId,
+            runId: admission.runId,
+            userMessageId: admission.userMessageId,
+            execution: admission.execution,
+            content,
+            start: ({ runId, userMessageId, onRunStarted }) => this.manager.runCoordinationOperation(admission.sessionId, { turnId: admission.turnId, ...content }, { runId, userMessageId, onRunStarted }, () => execute(admission.turnId)),
+        };
+    }
+    /** Accepts a model action against the exact live WorkHub root and its durable user input. */
+    readActiveWorkHubRequest(turnId) {
+        const sessionId = WORKHUB_COORDINATION_SESSION_ID;
+        return this.sessionAdmission.run(sessionId, async () => {
+            const active = this.#executions.get(sessionId);
+            if (!active || active.turnId !== turnId)
+                return undefined;
+            const [admission, header] = await Promise.all([
+                this.stores.agentRunStore.readRootTurnAdmission(sessionId, turnId),
+                this.stores.sessionStore.readHeaderSnapshot(sessionId),
+            ]);
+            if (this.#executions.get(sessionId) !== active ||
+                admission?.runId !== active.runId ||
+                admission.execution.kind !== 'workhub_coordination' ||
+                header.toolProfile !== 'workhub-coordination-v2')
+                return undefined;
+            return requireHostedExecutionMessageContent(admission);
+        });
     }
     startRootMessage(request, context) {
         return this.runCommand(async () => {
@@ -1115,7 +1200,7 @@ export class RootTurnCoordinator {
                     if (existing.execution.kind !== request.execution.kind) {
                         return completedStart(operationConflict('Turn identity belongs to a different execution kind'));
                     }
-                    if (!isDeepStrictEqual(existing.execution, request.execution)) {
+                    if (!rootExecutionMatches(existing.execution, request.execution)) {
                         return completedStart(operationConflict('Turn identity belongs to a different execution payload'));
                     }
                     let content;
@@ -1141,7 +1226,7 @@ export class RootTurnCoordinator {
                             return completedStart({ ok: true, result: snapshot });
                         }
                     }
-                    return this.prepareAdmittedTurn(activationInputForAdmission(existing), existing, context.acquireResidency, lease, undefined, undefined, reservation);
+                    return this.prepareAdmittedTurn(activationInputForAdmission(existing), existing, context.acquireResidency, lease, undefined, this.coordinationOperation(request, existing), reservation);
                 }
                 reservation ??= this.reserveRootTurn(request.sessionId);
                 if (!reservation) {
@@ -1186,7 +1271,8 @@ export class RootTurnCoordinator {
                 const attachmentError = await this.attachmentValidator?.validateTurnAttachments(request.sessionId, attachments);
                 if (attachmentError)
                     return completedStart(operationConflict(attachmentError));
-                const binding = request.execution.kind === 'workhub_coordination'
+                const binding = request.execution.kind === 'workhub_coordination' &&
+                    header.toolProfile === 'workhub-coordination-v1'
                     ? undefined
                     : prepared.commitCapabilityBinding
                         ? await prepared.commitCapabilityBinding()
@@ -1226,7 +1312,7 @@ export class RootTurnCoordinator {
                 if (!rootMessageAdmissionMatches(admitted.admission, request, canonicalContent.content, context.turnAdmissionAuthorization)) {
                     return completedStart(operationConflict('Turn identity was already admitted with a different payload'));
                 }
-                return this.prepareAdmittedTurn(activationInputForAdmission(admitted.admission), admitted.admission, context.acquireResidency, lease, undefined, undefined, reservation);
+                return this.prepareAdmittedTurn(activationInputForAdmission(admitted.admission), admitted.admission, context.acquireResidency, lease, undefined, this.coordinationOperation(request, admitted.admission), reservation);
             });
             const disposition = await admissionTask.finally(() => {
                 if (reservation)
@@ -2198,8 +2284,18 @@ function throwHostedStopError(sessionId, outcome) {
             throw new RuntimeHostedRootUnavailableError(sessionId, outcome.error.message);
     }
 }
+/** Compatibility may omit only the action identity absent from an older admission. */
+function rootExecutionMatches(stored, incoming) {
+    if (stored.kind === 'workhub_coordination' &&
+        incoming.kind === 'workhub_coordination' &&
+        stored.actionId === undefined) {
+        const { actionId: _actionId, ...legacyIncoming } = incoming;
+        return isDeepStrictEqual(stored, legacyIncoming);
+    }
+    return isDeepStrictEqual(stored, incoming);
+}
 function rootMessageAdmissionMatches(admission, request, content, authorization) {
-    return (isDeepStrictEqual(admission.execution, request.execution) &&
+    return (rootExecutionMatches(admission.execution, request.execution) &&
         (request.execution.kind === 'external_message' && request.execution.inputDigest
             ? true
             : messageContentsEqual(requireHostedExecutionMessageContent(admission), content)) &&

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

@@ -23,6 +23,7 @@ import { ShellRunPtyControlClosedError, isShellRunResourceRef, } from '@maka/run
 import { defaultShellPlan, ShellPreferenceError } from '@maka/runtime/shell-detect';
 import { isSessionNotFoundError } from '@maka/storage/execution-stores';
 import { decodeRuntimeResourceControllerAcquireResult, decodeRuntimeResourceControllerControlResult, decodeRuntimeResourceQueryResult, decodeRuntimeResourceStopResult, decodeRuntimeResourceStartResult, RUNTIME_RESOURCE_CONTROLLER_ACQUIRE_RESULT_MAX_BYTES, RUNTIME_RESOURCE_MAX_CONTROL_SEQUENCE, } from '../protocol/index.js';
+import { boundedFailureDiagnostic } from './failure-diagnostic.js';
 import { boundedRuntimeResourceSnapshot, canonicalRuntimeResources, createRuntimeResourcePage, runtimeResourceRevision, runtimeResourceSnapshotFromResult, } from './runtime-resource-projection.js';
 const MAX_CONTROL_REPLAYS = 128;
 /** Owns Host Shell/PTY tools plus the connection-scoped Client controller fence. */
@@ -186,8 +187,7 @@ export class HostRuntimeResourceCoordinator {
                 if (isSessionNotFoundError(error)) {
                     return queryFailure('not_found', 'Session was not found');
                 }
-                this.#requestDrain();
-                return queryFailure('internal_failure', 'Session state is unavailable');
+                return this.#canonicalReadFailure(error, 'Session state is unavailable');
             }
             if (input.kind === 'get') {
                 try {
@@ -206,9 +206,8 @@ export class HostRuntimeResourceCoordinator {
                         }),
                     };
                 }
-                catch {
-                    this.#requestDrain();
-                    return queryFailure('internal_failure', 'Runtime Resource state is unavailable');
+                catch (error) {
+                    return this.#canonicalReadFailure(error, 'Runtime Resource state is unavailable');
                 }
             }
             let updates;
@@ -218,9 +217,8 @@ export class HostRuntimeResourceCoordinator {
                     updates = updates.filter((update) => update.sessionId === input.sessionId);
                 }
             }
-            catch {
-                this.#requestDrain();
-                return queryFailure('internal_failure', 'Runtime Resource state is unavailable');
+            catch (error) {
+                return this.#canonicalReadFailure(error, 'Runtime Resource state is unavailable');
             }
             try {
                 const resources = canonicalRuntimeResources(updates);
@@ -251,6 +249,11 @@ export class HostRuntimeResourceCoordinator {
             ? queryFailure('not_found', 'Session was not found')
             : outcome;
     }
+    #canonicalReadFailure(error, message) {
+        console.error(`[runtime-host] canonical Runtime Resource read failed: ${boundedFailureDiagnostic(error)}`);
+        this.#requestDrain();
+        return queryFailure('internal_failure', message);
+    }
     #guestObservationGrantId(context, sessionId) {
         if (context.principalKind !== 'session_guest')
             return;

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

@@ -418,28 +418,38 @@ export class HostScheduledTaskCoordinator {
         }
     }
     async #refresh() {
-        await this.#exclusive(async () => {
-            if (this.#handoffHeld || this.#draining)
-                return;
-            for (const claim of await this.#store.listPendingFires()) {
+        if (this.#handoffHeld || this.#draining)
+            return;
+        // Cover claim admission, native delivery, and persistence, while an idle
+        // schedule or a read-only catalog query does not claim active work.
+        const residency = this.#acquireResidency();
+        try {
+            await this.#exclusive(async () => {
                 if (this.#handoffHeld || this.#draining)
-                    break;
-                if (claim.nativeState === 'waiting_for_provider') {
-                    await this.#fulfill(claim, true);
+                    return;
+                for (const claim of await this.#store.listPendingFires()) {
+                    if (this.#handoffHeld || this.#draining)
+                        break;
+                    if (claim.nativeState === 'waiting_for_provider') {
+                        await this.#fulfill(claim, true);
+                    }
                 }
-            }
-            while (!this.#draining && !this.#handoffHeld) {
-                const scan = await this.#store.claimNextDue(this.#now());
-                for (const expired of scan.expired)
-                    this.#publish('updated', expired.id);
-                const claim = scan.claim;
-                if (!claim)
-                    break;
-                await this.#refreshResidency();
-                await this.#fulfill(claim, false);
-            }
-            await this.#refreshSchedule();
-        });
+                while (!this.#draining && !this.#handoffHeld) {
+                    const scan = await this.#store.claimNextDue(this.#now());
+                    for (const expired of scan.expired)
+                        this.#publish('updated', expired.id);
+                    const claim = scan.claim;
+                    if (!claim)
+                        break;
+                    await this.#refreshResidency();
+                    await this.#fulfill(claim, false);
+                }
+                await this.#refreshSchedule();
+            });
+        }
+        finally {
+            residency.release();
+        }
     }
     async #fulfill(claim, recovering) {
         const incognito = (await this.#runtimePolicy.runtimePolicy.getSnapshot()).policy.privacy
@@ -680,7 +690,7 @@ export class HostScheduledTaskCoordinator {
             (claims.length > 0 ||
                 tasks.some((task) => task.status === 'active' && task.nextFireAt !== null));
         if (shouldHold && !this.#residency)
-            this.#residency = this.#acquireResidency();
+            this.#residency = this.#acquireResidency('idle');
         if (!shouldHold)
             this.#releaseResidency();
     }

package/node_modules/@maka/runtime-host/dist/server/serial-outbound-writer.js

@@ -134,7 +134,7 @@ export class BoundedSerialOutboundWriter {
         if (this.#closed)
             return;
         this.close(error);
-        this.#onFailure();
+        this.#onFailure(error);
     }
     #nextFrame() {
         // Close acknowledgements are fences: no lower-priority subscription

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

@@ -24,7 +24,7 @@ import { thinkingVariantsForConnection } from '@maka/core/model-thinking';
 import { executionBoundaryDisplayMode, } from '@maka/core/sandbox-boundary';
 import { DEFAULT_SESSION_NAME, normalizeUserSessionName } from '@maka/core/session-name';
 import { isSessionStartModeLabel as isExecutionSemanticLabel, sessionStartModeSpec, } from '@maka/core/session-start-mode';
-import { isWorkHubCoordinationSessionId, isWorkHubCoordinationSessionTarget, } from '@maka/core/session';
+import { WORKHUB_COORDINATION_SESSION_ID, isWorkHubCoordinationSession, isWorkHubCoordinationSessionId, isWorkHubCoordinationSessionTarget, } from '@maka/core/session';
 import { isSessionNotFoundError, SessionMetadataConflictError, SessionMetadataVersionConflictError, } from '@maka/storage/execution-stores';
 import { isVisibleSessionMessage } from '@maka/storage/session-message-projection';
 import { SessionConfigurationRevisionConflictError, SessionConfigurationTransitionError, } from '@maka/runtime/session-manager';
@@ -438,15 +438,27 @@ export class HostSessionCatalogCoordinator {
             }
         });
     }
-    async #updateConfiguration(input) {
-        if (isWorkHubCoordinationSessionId(input.sessionId)) {
+    configureWorkHubModel(input) {
+        return this.#updateConfiguration({
+            sessionId: WORKHUB_COORDINATION_SESSION_ID,
+            expectedRevision: input.expectedRevision,
+            patch: { modelTarget: input.modelTarget },
+        }, 'workhub');
+    }
+    async #updateConfiguration(input, authority = 'ordinary') {
+        if (authority === 'ordinary' && isWorkHubCoordinationSessionId(input.sessionId)) {
             return configurationFailure('operation_conflict', 'WorkHub Coordination Session configuration requires WorkHub authority');
         }
         return this.#admission.run(input.sessionId, async (lease) => {
             let commitAttempted = false;
             try {
                 const current = await this.#stores.readHeaderRecordSnapshot(input.sessionId);
-                if (isWorkHubCoordinationSessionTarget(current.header)) {
+                if (authority === 'workhub' &&
+                    (!isWorkHubCoordinationSessionId(current.header.id) ||
+                        !isWorkHubCoordinationSession(current.header))) {
+                    return configurationFailure('operation_conflict', 'WorkHub Coordination Session identity is unavailable');
+                }
+                if (authority === 'ordinary' && isWorkHubCoordinationSessionTarget(current.header)) {
                     return configurationFailure('operation_conflict', 'WorkHub Coordination Session configuration requires WorkHub authority');
                 }
                 if (current.revision !== input.expectedRevision) {
@@ -461,7 +473,7 @@ export class HostSessionCatalogCoordinator {
                 if (!clearsConnectionBlock && sessionConfigurationMatches(current.header, configuration)) {
                     return configurationSuccess({
                         kind: 'committed',
-                        session: projectSessionCatalogRecord(await this.#stores.readCatalogRecord(input.sessionId)),
+                        session: projectSessionCatalogRecord(await this.#stores.readCatalogRecord(input.sessionId, authority === 'workhub' ? 'recoverable' : 'ordinary')),
                     });
                 }
                 commitAttempted = true;
@@ -470,7 +482,7 @@ export class HostSessionCatalogCoordinator {
                     clearConnectionBlock: input.patch.modelTarget !== undefined,
                     configuration,
                 });
-                return configurationSuccess(await this.#committedUpdate(input.sessionId, lease));
+                return configurationSuccess(await this.#committedUpdate(input.sessionId, lease, authority === 'workhub' ? 'recoverable' : 'ordinary'));
             }
             catch (error) {
                 if (!commitAttempted &&
@@ -597,11 +609,11 @@ export class HostSessionCatalogCoordinator {
             position = page.nextPosition;
         }
     }
-    async #committedUpdate(sessionId, lease) {
+    async #committedUpdate(sessionId, lease, roleScope = 'ordinary') {
         await this.#continuity.refreshCanonical(sessionId, lease);
         return {
             kind: 'committed',
-            session: projectSessionCatalogRecord(await this.#stores.readCatalogRecord(sessionId)),
+            session: projectSessionCatalogRecord(await this.#stores.readCatalogRecord(sessionId, roleScope)),
         };
     }
     #metadataMutationFailure(input, error, unknownMessage) {

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

@@ -439,8 +439,11 @@ export class HostSessionRetirementCoordinator {
                 throw new SessionRetirementBusyError(`Session ${sessionId} has a live derived effect`);
             }
             const header = requireFamilyRecord(family, sessionId).header;
-            if (!header.subagentParent && (await this.#graph.hasLiveSessionState(sessionId))) {
-                throw new SessionRetirementBusyError(`Session ${sessionId} has a live Agent Graph`);
+            if (!header.subagentParent) {
+                const graph = await this.#graph.readRetirementDisposition(sessionId);
+                if (graph.kind === 'busy') {
+                    throw new SessionRetirementBusyError(`Session ${sessionId} has an Agent Graph that is ${graph.status}`);
+                }
             }
             if (!header.subagentParent && this.#graphWake.hasLiveSessionState(sessionId)) {
                 throw new SessionRetirementBusyError(`Session ${sessionId} has an active Agent Graph supervisor wake`);

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

@@ -642,6 +642,8 @@ function collectArchivedToolResultPlaceholders(events, messages, copyTurnIds, op
             return true;
         if (!isArchivedToolResultPlaceholder(value))
             return false;
+        if (value.rewriteVersion === 2)
+            return true;
         addDescriptor(value);
         return true;
     };
@@ -684,6 +686,8 @@ function collectArchivedToolResultPlaceholders(events, messages, copyTurnIds, op
             continue;
         }
         if (message.content.kind === 'archived_tool_result') {
+            if (message.content.rewriteVersion === 2 && message.content.resourceRef)
+                continue;
             if (!message.content.artifactId && !message.content.bodySha256)
                 continue;
             if (!message.content.artifactId || !message.content.bodySha256)