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

package/node_modules/@maka/runtime-host/dist/client/host-handoff.js

@@ -55,6 +55,8 @@ export async function runHostHandoff(input) {
     // (or a broken successor) into an automatic replacement storm.
     const attempted = new Set();
     let automaticAttempts = 0;
+    let refusedWork;
+    let replacementCompleted = false;
     let recovery;
     const publish = (next) => {
         view = next;
@@ -102,7 +104,10 @@ export async function runHostHandoff(input) {
                         target: view.target,
                         reason: 'unavailable',
                         mayExitNaturally: false,
-                        diagnostic: boundedDiagnostic(error),
+                        ...(view.manualRecheck ? { manualRecheck: true } : {}),
+                        diagnostic: replacementCompleted
+                            ? `Host replacement completed, but reconnection failed: ${boundedDiagnostic(error)}`
+                            : boundedDiagnostic(error),
                     },
                 };
             }
@@ -124,11 +129,13 @@ export async function runHostHandoff(input) {
             const blocker = observed.blocker;
             if (recovery?.identity !== blocker.identity)
                 recovery = undefined;
+            if (refusedWork !== blocker.identity)
+                refusedWork = undefined;
             const nextSignature = blockerSignature(blocker);
             if (signature !== nextSignature) {
                 signature = nextSignature;
                 choice = undefined;
-                publish(projectBlocker(blocker, randomUUID(), recovery?.diagnostic));
+                publish(projectBlocker(blocker, randomUUID(), recovery?.diagnostic, refusedWork === blocker.identity));
             }
             const current = view;
             const selected = choice;
@@ -142,12 +149,19 @@ export async function runHostHandoff(input) {
             const automatic = !recovery &&
                 automaticAttempts < 3 &&
                 !attempted.has(nextSignature) &&
+                !blocker.replacement?.requiresExplicitSelection &&
                 blocker.replacement?.canReplaceIdle &&
                 blocker.activity &&
                 (isHostActivityIdle(blocker.activity) || cooperative);
             const interrupt = selected?.revision === current.revision && selected.action === 'interrupt';
+            const replace = selected?.revision === current.revision && selected.action === 'replace';
             const retry = selected?.revision === current.revision && selected.action === 'retry';
-            if ((automatic || interrupt || (retry && blocker.replacement?.canReplaceIdle)) &&
+            if ((automatic ||
+                interrupt ||
+                replace ||
+                (retry &&
+                    !blocker.replacement?.requiresExplicitSelection &&
+                    blocker.replacement?.canReplaceIdle)) &&
                 blocker.replacement) {
                 if (automatic) {
                     attempted.add(nextSignature);
@@ -179,6 +193,8 @@ export async function runHostHandoff(input) {
                 finally {
                     attemptAbort = undefined;
                 }
+                replacementCompleted = result.kind === 'completed';
+                refusedWork = result.kind === 'active_work' ? blocker.identity : undefined;
                 recovery =
                     result.kind === 'recovery_required'
                         ? { identity: blocker.identity, diagnostic: result.diagnostic.slice(0, 8_192) }
@@ -195,7 +211,7 @@ export async function runHostHandoff(input) {
                 signature = undefined;
                 continue;
             }
-            const attention = projectBlocker(blocker, current.revision, recovery?.diagnostic);
+            const attention = projectBlocker(blocker, current.revision, recovery?.diagnostic, refusedWork === blocker.identity);
             if (!input.openSurface)
                 throw new HostHandoffRequiredError(attention);
             surface ??= input.openSurface(submit);
@@ -211,7 +227,7 @@ export async function runHostHandoff(input) {
                         resolve();
                 };
                 const abort = () => finish(input.signal?.reason);
-                const timer = setTimeout(finish, interval);
+                const timer = blocker.manualRecheck ? undefined : setTimeout(finish, interval);
                 wake = () => finish();
                 input.signal?.addEventListener('abort', abort, { once: true });
                 if (input.signal?.aborted)
@@ -225,7 +241,7 @@ export async function runHostHandoff(input) {
         surface?.close();
     }
 }
-function projectBlocker(blocker, revision, recovery) {
+function projectBlocker(blocker, revision, recovery, activeWorkRefused = false) {
     const replacement = blocker.replacement;
     return {
         revision,
@@ -237,15 +253,30 @@ function projectBlocker(blocker, revision, recovery) {
                 ? 'repair_required'
                 : !replacement
                     ? 'operator_required'
-                    : !blocker.activity
-                        ? 'activity_unknown'
-                        : isHostActivityIdle(blocker.activity)
-                            ? 'retry_required'
-                            : 'busy',
+                    : replacement.requiresExplicitSelection
+                        ? activeWorkRefused
+                            ? 'busy'
+                            : 'replacement_required'
+                        : !blocker.activity
+                            ? 'activity_unknown'
+                            : isHostActivityIdle(blocker.activity)
+                                ? 'retry_required'
+                                : 'busy',
         ...(blocker.activity ? { activity: blocker.activity } : {}),
         mayExitNaturally: blocker.mayExitNaturally,
+        ...(blocker.manualRecheck ? { manualRecheck: true } : {}),
+        ...(blocker.packageChange ? { packageChange: blocker.packageChange } : {}),
         ...(replacement ? { operation: replacement.kind } : {}),
-        actions: replacement?.canInterrupt ? ['cancel', 'retry', 'interrupt'] : ['cancel', 'retry'],
+        actions: replacement?.requiresExplicitSelection
+            ? [
+                'cancel',
+                'retry',
+                'replace',
+                ...(activeWorkRefused && replacement.canInterrupt ? ['interrupt'] : []),
+            ]
+            : replacement?.canInterrupt
+                ? ['cancel', 'retry', 'interrupt']
+                : ['cancel', 'retry'],
         defaultAction: 'cancel',
         ...(blocker.recoveryBlocker ? { recoveryBlocker: blocker.recoveryBlocker } : {}),
         ...(blocker.operatorStep ? { operatorStep: blocker.operatorStep } : {}),
@@ -265,6 +296,9 @@ function blockerSignature(blocker) {
         blocker.replacement?.kind,
         blocker.replacement?.canReplaceIdle,
         blocker.replacement?.canInterrupt,
+        blocker.replacement?.requiresExplicitSelection,
+        blocker.manualRecheck,
+        blocker.packageChange,
         blocker.operatorStep,
         blocker.recoveryBlocker,
         blocker.diagnostic,

package/node_modules/@maka/runtime-host/dist/operator/setup-frame.js

@@ -41,6 +41,29 @@ const frameBase = {
     schemaVersion: z.literal(1),
     sequence: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
 };
+const environmentBindingFields = {
+    version: boundedString(128),
+    serviceId: z.string().regex(/^[a-f0-9]{64}$/u),
+    deploymentId: z.string().uuid(),
+    operator: z.unknown().transform((value, context) => {
+        try {
+            const command = decodeRuntimeHostOperatorCommand(value);
+            if (command.kind !== 'node') {
+                throw new Error('Runtime Host setup operator must be a Node command');
+            }
+            return command;
+        }
+        catch (error) {
+            context.addIssue({
+                code: 'custom',
+                message: error instanceof Error ? error.message : 'Runtime Host operator is invalid',
+            });
+            return z.NEVER;
+        }
+    }),
+    rootPath: boundedString(4 * 1024).refine((value) => !/[\u0000-\u001f\u007f]/u.test(value)),
+    rootId: z.string().regex(/^[a-f0-9]{64}$/u),
+};
 const SETUP_FRAME_SCHEMA = z.discriminatedUnion('kind', [
     z
         .object({
@@ -53,27 +76,7 @@ const SETUP_FRAME_SCHEMA = z.discriminatedUnion('kind', [
         .object({
         ...frameBase,
         kind: z.literal('complete'),
-        version: boundedString(128),
-        serviceId: z.string().regex(/^[a-f0-9]{64}$/u),
-        deploymentId: z.string().uuid(),
-        operator: z.unknown().transform((value, context) => {
-            try {
-                const command = decodeRuntimeHostOperatorCommand(value);
-                if (command.kind !== 'node') {
-                    throw new Error('Runtime Host setup operator must be a Node command');
-                }
-                return command;
-            }
-            catch (error) {
-                context.addIssue({
-                    code: 'custom',
-                    message: error instanceof Error ? error.message : 'Runtime Host operator is invalid',
-                });
-                return z.NEVER;
-            }
-        }),
-        rootPath: boundedString(4 * 1024).refine((value) => !/[\u0000-\u001f\u007f]/u.test(value)),
-        rootId: z.string().regex(/^[a-f0-9]{64}$/u),
+        ...environmentBindingFields,
         endpoint: boundedString(SETUP_FIELD_MAX_BYTES).refine((value) => parseRuntimeHostSetupEndpoint(value) !== undefined),
         credentialId: boundedString(SETUP_FIELD_MAX_BYTES),
         credential: boundedString(SETUP_CREDENTIAL_MAX_BYTES),
@@ -87,6 +90,13 @@ const SETUP_FRAME_SCHEMA = z.discriminatedUnion('kind', [
             .optional(),
     })
         .strict(),
+    z
+        .object({
+        ...frameBase,
+        kind: z.literal('existing_environment'),
+        ...environmentBindingFields,
+    })
+        .strict(),
     z
         .object({
         ...frameBase,

package/node_modules/@maka/runtime-host/dist/peer-mesh/node.js

@@ -17,7 +17,6 @@
  * under the License.
  */
 import { createHash } from 'node:crypto';
-import { setTimeout as delay } from 'node:timers/promises';
 import { performance } from 'node:perf_hooks';
 import { canonicalPeerMeshMemberAdvertisement, canonicalPeerMeshRoster, createPeerMeshInvitationSecret, validatePeerMeshInvitation, decodeSignedPeerMeshMemberAdvertisement, decodeSignedPeerMeshRoster, generatePeerMeshAuthorityKeyPair, matchesPeerMeshInvitationSecret, PEER_MESH_MAX_MEMBERS, PEER_MESH_MAX_MESHES, PEER_MESH_MAX_INVITATION_RECORDS, PEER_MESH_MAX_PENDING_INVITATIONS, PEER_MESH_MAX_TRANSIT_ADDRESSES_PER_RELAY, PEER_MESH_MAX_TRANSIT_RELAY_ADDRESSES, peerMeshMemberAdvertisementSigningBytes, peerMeshId, peerMeshInvitationSecretDigest, signPeerMeshRoster, } from './model.js';
 import { canonicalPeerMeshDisplayName } from './display-name.js';
@@ -793,19 +792,23 @@ class PeerMeshNodeImpl {
         }
     }
     async #waitForReconciliationTrigger(observedGeneration, signal) {
-        if (this.#reconcileGeneration !== observedGeneration)
+        if (this.#reconcileGeneration !== observedGeneration || signal.aborted)
             return;
         let wake;
         const triggered = new Promise((resolve) => {
             wake = resolve;
             this.#reconcileWaiters.add(wake);
         });
-        if (this.#reconcileGeneration !== observedGeneration)
+        const timeout = setTimeout(wake, RECONCILE_INTERVAL_MS);
+        signal.addEventListener('abort', wake, { once: true });
+        if (this.#reconcileGeneration !== observedGeneration || signal.aborted)
             wake();
         try {
-            await Promise.race([triggered, delay(RECONCILE_INTERVAL_MS, undefined, { signal })]);
+            await triggered;
         }
         finally {
+            clearTimeout(timeout);
+            signal.removeEventListener('abort', wake);
             this.#reconcileWaiters.delete(wake);
         }
     }

package/node_modules/@maka/runtime-host/dist/protocol/artifact.js

@@ -345,7 +345,7 @@ export function decodeArtifactQueryResult(value) {
         if (!isCanonicalBase64(chunkBase64)) {
             throw invalidProtocolFrame('Invalid artifact chunk');
         }
-        const chunkBytes = Buffer.from(chunkBase64, 'base64').byteLength;
+        const chunkBytes = Buffer.byteLength(chunkBase64, 'base64');
         if (chunkBytes > ARTIFACT_READ_CHUNK_MAX_BYTES || offset + chunkBytes > totalBytes) {
             throw invalidProtocolFrame('Invalid artifact chunk bounds');
         }
@@ -466,7 +466,7 @@ function decodeBinaryPreview(value) {
         ]);
         const base64 = boundedText(exact.base64, 'artifact binary base64', base64MaxBytes(), true);
         if (!isCanonicalBase64(base64) ||
-            Buffer.from(base64, 'base64').byteLength > ARTIFACT_PREVIEW_MAX_BYTES) {
+            Buffer.byteLength(base64, 'base64') > ARTIFACT_PREVIEW_MAX_BYTES) {
             throw invalidProtocolFrame('Invalid artifact binary base64');
         }
         return {

package/node_modules/@maka/runtime-host/dist/protocol/index.js

@@ -62,7 +62,16 @@ export const RUNTIME_HOST_REGISTRATION_SCHEMA_VERSION = 1;
 export const RUNTIME_HOST_PROTOCOL_VERSION = 0;
 // Increment when the same protocol version no longer guarantees safe Client-Host
 // interoperability. Mismatches are rejected before domain commands are admitted.
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 135;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 142;
+// 142: Invocable Skill queries expose missing and archived Session refusals explicitly.
+// 141: WorkHub root admissions bind model Intent/Recall decisions before actions.
+// 140: Plugin Platform queries expose scoped Command contribution projections.
+// Epoch-139 peers reject the added query view and result shape.
+// 139: WorkHub recovery preserves the Host-authenticated Desktop capability binding.
+// 138: Removes the unused steering display anchor from canonical MessageContent.
+// 137: Reserved by the former display anchor contract.
+// 136: WorkHub transient proposals distinguish routing dispositions from linked
+// operations. Older peers expect replace/stop_work/resume_work dispositions.
 // 135: WorkHub model Turns replace direct action proposals with active-Turn task tools.
 // 134: Coordination actions own real Runtime Turns. Removes the synthetic record
 // operation, projects typed action receipts and admitted action identities, and

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

@@ -108,7 +108,7 @@ export const PLUGIN_PLATFORM_OPERATION_SPECS = {
 };
 function decodePluginPlatformQueryInput(value) {
     const input = requireShapedRecord(value, 'Plugin Platform query input', ['view'], ['rootId', 'cursor', 'limit']);
-    if (!['status', 'packages', 'entries', 'tools', 'failures'].includes(input.view)) {
+    if (!['status', 'packages', 'entries', 'tools', 'commands', 'failures'].includes(input.view)) {
         throw invalidProtocolFrame('Invalid Plugin Platform query view');
     }
     const view = input.view;
@@ -125,8 +125,8 @@ function decodePluginPlatformQueryInput(value) {
         (input.rootId !== undefined || cursor !== undefined || limit !== undefined)) {
         throw invalidProtocolFrame('Plugin Platform status query does not accept paging');
     }
-    if (input.rootId !== undefined && view !== 'entries' && view !== 'tools') {
-        throw invalidProtocolFrame('Plugin root identity is only valid for Entry and Tool queries');
+    if (input.rootId !== undefined && view !== 'entries' && view !== 'tools' && view !== 'commands') {
+        throw invalidProtocolFrame('Plugin root identity is only valid for Entry, Tool, and Command queries');
     }
     let rootId;
     if (input.rootId !== undefined) {
@@ -190,7 +190,7 @@ function decodePluginPlatformQueryResult(value) {
         ]);
         if (!Array.isArray(output.items) ||
             output.items.length > 64 ||
-            !['packages', 'entries', 'tools', 'failures'].includes(view)) {
+            !['packages', 'entries', 'tools', 'commands', 'failures'].includes(view)) {
             throw invalidProtocolFrame('Invalid Plugin Platform page');
         }
         const nextCursor = output.nextCursor === null
@@ -203,11 +203,36 @@ function decodePluginPlatformQueryResult(value) {
                     ? { view, items: decodeInspections(output.items), nextCursor }
                     : view === 'tools'
                         ? { view, items: output.items.map(decodeToolInspection), nextCursor }
-                        : { view: 'failures', items: output.items.map(decodePlatformFailure), nextCursor };
+                        : view === 'commands'
+                            ? { view, items: output.items.map(decodeCommandInspection), nextCursor }
+                            : { view: 'failures', items: output.items.map(decodePlatformFailure), nextCursor };
     }
     requireEncodedByteLimit(decoded, 'Plugin Platform query result', PLUGIN_PLATFORM_QUERY_RESULT_MAX_BYTES);
     return decoded;
 }
+function decodeCommandInspection(value) {
+    const item = requireExactRecord(value, 'Plugin Command inspection', [
+        'entryId',
+        'scopeId',
+        'extensionId',
+        'generation',
+        'name',
+        'description',
+        'aliases',
+    ]);
+    if (!Array.isArray(item.aliases) || item.aliases.length > 64) {
+        throw invalidProtocolFrame('Invalid Plugin Command aliases');
+    }
+    return {
+        entryId: requireId(item.entryId, 'Plugin Entry identity'),
+        scopeId: requireString(item.scopeId, 'Plugin scope identity', 256),
+        extensionId: requireId(item.extensionId, 'Plugin package identity'),
+        generation: requireCount(item.generation, 'Plugin generation'),
+        name: requireString(item.name, 'Plugin Command name', 128),
+        description: requireString(item.description, 'Plugin Command description', 4096),
+        aliases: item.aliases.map((alias) => requireString(alias, 'Plugin Command alias', 128)),
+    };
+}
 function decodePlatformFailure(value) {
     const failure = requireShapedRecord(value, 'Plugin Platform failure', ['diagnostic'], ['entryId', 'extensionId']);
     if (failure.entryId === undefined && failure.extensionId === undefined) {

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

@@ -165,7 +165,8 @@ export function decodeSessionTranscriptPage(value) {
     assertFragmentOrder(fragments, direction);
     const rawBytes = requireCount(result.rawBytes, 'Session transcript page bytes');
     if (rawBytes > SESSION_TRANSCRIPT_PAGE_MAX_BYTES ||
-        fragments.reduce((total, fragment) => total + Buffer.from(fragment.data, 'base64').byteLength, 0) !== rawBytes) {
+        fragments.reduce((total, fragment) => total + Buffer.byteLength(fragment.data, 'base64'), 0) !==
+            rawBytes) {
         throw invalidProtocolFrame('Invalid Session transcript page byte count');
     }
     const nextCursor = result.nextCursor === null
@@ -231,7 +232,7 @@ function decodeSessionTranscriptFragment(value, source, throughSequence) {
     const byteOffset = requireCount(exact.byteOffset, 'Session transcript fragment byte offset');
     const totalBytes = requireCount(exact.totalBytes, 'Session transcript fragment total bytes');
     const data = requireBase64Fragment(exact.data);
-    const dataBytes = Buffer.from(data, 'base64').byteLength;
+    const dataBytes = Buffer.byteLength(data, 'base64');
     if (totalBytes === 0 ||
         dataBytes === 0 ||
         byteOffset >= totalBytes ||

package/node_modules/@maka/runtime-host/dist/protocol/skill-catalog.js

@@ -42,6 +42,7 @@ const QUERY_ERRORS = [
     'persistence_failed',
     'internal_failure',
 ];
+const INVOCABLE_QUERY_ERRORS = [...QUERY_ERRORS, 'not_found', 'session_archived'];
 const MUTATION_ERRORS = [...QUERY_ERRORS, 'commit_outcome_unknown'];
 export const SKILL_CATALOG_OPERATION_SPECS = {
     'skill.catalog.query': defineHostPathOperation({
@@ -54,7 +55,7 @@ export const SKILL_CATALOG_OPERATION_SPECS = {
     'skill.catalog.invocable.query': defineHostPathOperation({
         mode: 'query',
         availability: 'ready',
-        errors: QUERY_ERRORS,
+        errors: INVOCABLE_QUERY_ERRORS,
         decodeInput: decodeInvocableQueryInput,
         decodeOutput: decodeInvocableQueryResult,
     }, (input) => input.target.kind === 'new_session' && input.target.context.workspace.kind === 'host_path'),

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

@@ -182,8 +182,10 @@ function decodeWorkHubCoordinationActionFields(input) {
     const proposal = decodeWorkHubCoordinationProposal(input.proposal);
     if (input.newWorkDefaults !== undefined &&
         (!isWorkHubCreateDefaults(input.newWorkDefaults) ||
-            !(proposal.disposition === 'create_new' ||
-                (proposal.disposition === 'replace' && proposal.target.disposition === 'create_new')))) {
+            !(('disposition' in proposal && proposal.disposition === 'create_new') ||
+                ('operation' in proposal &&
+                    proposal.operation === 'correct' &&
+                    proposal.target.disposition === 'create_new')))) {
         throw invalidProtocolFrame('Invalid WorkHub creation defaults');
     }
     const delegationText = input.delegationText === undefined
@@ -191,9 +193,7 @@ function decodeWorkHubCoordinationActionFields(input) {
         : requireUtf8String(input.delegationText, 'WorkHub delegation text', WORKHUB_COORDINATION_TEXT_MAX_BYTES);
     if (delegationText !== undefined &&
         (!delegationText.trim() ||
-            (proposal.disposition !== 'delegate_existing' &&
-                proposal.disposition !== 'create_new' &&
-                proposal.disposition !== 'replace'))) {
+            !('disposition' in proposal || ('operation' in proposal && proposal.operation === 'correct')))) {
         throw invalidProtocolFrame('Invalid WorkHub delegation text');
     }
     const base = {
@@ -204,19 +204,19 @@ function decodeWorkHubCoordinationActionFields(input) {
             : {}),
         ...(delegationText === undefined ? {} : { delegationText }),
     };
-    if (proposal.disposition === 'delegate_existing') {
+    if ('disposition' in proposal && proposal.disposition === 'delegate_existing') {
         if (input.create !== undefined || input.candidateSetId === undefined) {
             throw invalidProtocolFrame('Invalid WorkHub delegation context');
         }
         return { ...base, candidateSetId: candidateSetId(input.candidateSetId) };
     }
-    if (proposal.disposition === 'create_new') {
+    if ('disposition' in proposal && proposal.disposition === 'create_new') {
         if (input.candidateSetId !== undefined || input.create === undefined) {
             throw invalidProtocolFrame('Invalid WorkHub creation context');
         }
         return { ...base, create: decodeWorkHubCoordinationCreateContext(input.create) };
     }
-    if (proposal.disposition === 'replace') {
+    if ('operation' in proposal && proposal.operation === 'correct') {
         if (proposal.target.disposition === 'delegate_existing') {
             if (input.candidateSetId === undefined || input.create !== undefined) {
                 throw invalidProtocolFrame('Invalid WorkHub replacement context');
@@ -285,9 +285,9 @@ function decodeWorkHubCoordinationProposal(value) {
             title: requireUtf8String(exact.title, 'WorkHub Session title', COORDINATION_TITLE_MAX_BYTES),
         };
     }
-    if (proposal.disposition === 'replace') {
+    if (proposal.operation === 'correct') {
         const exact = requireExactRecord(proposal, 'WorkHub replacement proposal', [
-            'disposition',
+            'operation',
             'replacesActionId',
             'target',
         ]);
@@ -298,7 +298,7 @@ function decodeWorkHubCoordinationProposal(value) {
                 'candidateRef',
             ]);
             return {
-                disposition: 'replace',
+                operation: 'correct',
                 replacesActionId: requireEntityId(exact.replacesActionId, 'WorkHub replaced action id'),
                 target: {
                     disposition: 'delegate_existing',
@@ -312,7 +312,7 @@ function decodeWorkHubCoordinationProposal(value) {
                 'title',
             ]);
             return {
-                disposition: 'replace',
+                operation: 'correct',
                 replacesActionId: requireEntityId(exact.replacesActionId, 'WorkHub replaced action id'),
                 target: {
                     disposition: 'create_new',
@@ -322,29 +322,31 @@ function decodeWorkHubCoordinationProposal(value) {
         }
         throw invalidProtocolFrame('Invalid WorkHub replacement target');
     }
-    if (proposal.disposition === 'stop_work') {
-        const exact = requireExactRecord(proposal, 'WorkHub stop proposal', ['disposition', 'expects']);
+    if (proposal.operation === 'stop') {
+        const exact = requireExactRecord(proposal, 'WorkHub stop proposal', ['operation', 'expects']);
         return {
-            disposition: 'stop_work',
-            expects: decodeWorkHubCoordinationStopPreconditions(exact.expects),
+            operation: 'stop',
+            expects: decodeWorkHubCoordinationLinkedTargetPreconditions(exact.expects),
         };
     }
-    if (proposal.disposition === 'resume_work') {
+    if (proposal.operation === 'resume') {
         const exact = requireExactRecord(proposal, 'WorkHub resume proposal', [
-            'disposition',
+            'operation',
             'expects',
             'resumesActionId',
         ]);
         return {
-            disposition: 'resume_work',
+            operation: 'resume',
             resumesActionId: requireEntityId(exact.resumesActionId, 'WorkHub resume assignment'),
-            expects: decodeWorkHubCoordinationStopPreconditions(exact.expects),
+            expects: decodeWorkHubCoordinationLinkedTargetPreconditions(exact.expects),
         };
     }
-    throw invalidProtocolFrame('Invalid WorkHub Coordination proposal disposition');
+    throw invalidProtocolFrame('Invalid WorkHub Coordination proposal');
 }
-function decodeWorkHubCoordinationStopPreconditions(value) {
-    const expects = requireExactRecord(value, 'WorkHub stop preconditions', ['targetSessionId']);
+function decodeWorkHubCoordinationLinkedTargetPreconditions(value) {
+    const expects = requireExactRecord(value, 'WorkHub linked-target preconditions', [
+        'targetSessionId',
+    ]);
     return {
         targetSessionId: requireEntityId(expects.targetSessionId, 'WorkHub target Session id'),
     };

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

@@ -85,6 +85,8 @@ export class HostArtifactCoordinator {
     async #ingest(input, context) {
         try {
             if ((await this.#sessions.probeSessionRemoval(input.sessionId)).kind !== 'present') {
+                // Session removal can race an upload; release only this owner's staged bytes.
+                this.#uploads.abort(uploadKey(input.sessionId, input.uploadId), context);
                 return ingestFailure('not_found', 'Session was not found');
             }
             switch (input.kind) {

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

@@ -101,8 +101,8 @@ export class HostClientCapabilityCoordinator {
             },
         };
     }
-    async bindSession(sessionId, initiatingConnectionId) {
-        return this.#bindSession(sessionId, initiatingConnectionId, 'strict');
+    async bindSession(sessionId, initiatingConnectionId, requiredToolNames) {
+        return this.#bindSession(sessionId, initiatingConnectionId, 'strict', requiredToolNames);
     }
     async bindSessionSuccessor(sessionId) {
         const result = await this.#bindSession(sessionId, '', 'degrade');
@@ -129,17 +129,61 @@ export class HostClientCapabilityCoordinator {
                 this.#onModelToolsChanged();
         });
     }
-    async #bindSession(sessionId, initiatingConnectionId, mode) {
+    async #bindSession(sessionId, initiatingConnectionId, mode, requiredToolNames) {
         return this.#activation.runMutation(async () => {
             const selection = this.#selectSessionState(sessionId, initiatingConnectionId, mode);
             if (!selection.ok)
                 return selection;
+            const capabilityBinding = requiredToolNames
+                ? this.#toolProviderBinding(selection.state, requiredToolNames)
+                : undefined;
+            if (requiredToolNames && !capabilityBinding) {
+                return {
+                    ok: false,
+                    message: 'Required Client Capability tools do not have one available provider',
+                };
+            }
             this.#storeSessionState(sessionId, selection.state);
             if (selection.modelToolsChanged)
                 this.#onModelToolsChanged();
-            return { ok: true };
+            return { ok: true, ...(capabilityBinding ? { capabilityBinding } : {}) };
+        });
+    }
+    async bindRecoveredSession(sessionId, binding, toolNames) {
+        return this.#activation.runMutation(() => {
+            const provider = [...this.#providers.values()].find((candidate) => providerAuthorityDigest(candidate) === binding && this.#activeConnection(candidate));
+            if (!provider)
+                return false;
+            const connection = this.#activeConnection(provider);
+            const selection = this.#selectSessionState(sessionId, connection.connectionId, 'strict');
+            if (!selection.ok || this.#toolProviderBinding(selection.state, toolNames) !== binding)
+                return false;
+            this.#storeSessionState(sessionId, selection.state);
+            if (selection.modelToolsChanged)
+                this.#onModelToolsChanged();
+            return true;
         });
     }
+    #toolProviderBinding(state, toolNames) {
+        const missing = new Set(toolNames);
+        let selected;
+        for (const [contractId, binding] of state?.sessionBindings ?? []) {
+            if (binding.kind !== 'bound')
+                continue;
+            const provider = this.#providers.get(binding.providerId);
+            const offer = provider?.current?.offersByContract.get(contractId);
+            if (!provider || !this.#activeConnection(provider) || !offer)
+                continue;
+            for (const tool of offer.offer.tools) {
+                if (!missing.delete(mcpProxyToolName(tool.serverId, tool.name)))
+                    continue;
+                if (selected && selected !== provider)
+                    return undefined;
+                selected = provider;
+            }
+        }
+        return selected && missing.size === 0 ? providerAuthorityDigest(selected) : undefined;
+    }
     async runWithSessionBindingPreview(sessionId, initiatingConnectionId, operation) {
         return this.#activation.runReadActivation(async () => {
             const registryRevision = this.#revision;
@@ -1274,3 +1318,17 @@ function sessionCapabilityStatesEqual(left, right) {
 function asError(value) {
     return value instanceof Error ? value : new Error(String(value));
 }
+/** Registration IDs and connections rotate; authenticated provider authority must not. */
+function providerAuthorityDigest(provider) {
+    return `sha256:${createHash('sha256')
+        .update(JSON.stringify([
+        'maka.client-capability-authority.v1',
+        provider.principalKind,
+        provider.principalId,
+        provider.clientInstanceId,
+        provider.credentialBoundClientInstanceId ?? null,
+        provider.capabilityOwner?.principalId ?? null,
+        provider.capabilityOwner?.clientInstanceId ?? null,
+    ]))
+        .digest('hex')}`;
+}