maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

package/node_modules/@maka/runtime-host/dist/adapter/session-projector.js

@@ -19,8 +19,8 @@
 import { isDeepStrictEqual } from 'node:util';
 export function createRuntimeHostSessionProjectionSeed(transcript, snapshot) {
     return {
-        durableSteeringMessages: transcript
-            .filter((message) => message.type === 'user' && message.steeringEventId !== undefined)
+        durableUserMessages: transcript
+            .filter((message) => message.type === 'user')
             .map((message) => ({ messageId: message.id, turnId: message.turnId })),
         activeAssistantMessages: snapshot.rootTurn === null
             ? []
@@ -30,7 +30,7 @@ export function createRuntimeHostSessionProjectionSeed(transcript, snapshot) {
 export class RuntimeHostSessionProjector {
     #snapshot;
     #now;
-    #durableSteeringTurnByMessage;
+    #durableTurnByMessage;
     // Only live/synthesized messages for the current root belong here. Durable
     // transcript identity stays in the admission map above, so this render
     // ledger cannot grow with the lifetime of the session.
@@ -40,7 +40,7 @@ export class RuntimeHostSessionProjector {
     constructor(snapshot, seed, now = Date.now, activeAssistantStreams = [], projectMessageAdmissions = false) {
         this.#snapshot = structuredClone(snapshot);
         this.#now = now;
-        this.#durableSteeringTurnByMessage = new Map(seed.durableSteeringMessages.map(({ messageId, turnId }) => [messageId, turnId]));
+        this.#durableTurnByMessage = new Map(seed.durableUserMessages.map(({ messageId, turnId }) => [messageId, turnId]));
         this.#projectMessageAdmissions = projectMessageAdmissions;
         const root = snapshot.rootTurn;
         if (!root)
@@ -95,13 +95,21 @@ export class RuntimeHostSessionProjector {
         if (!root)
             return [];
         const events = [];
+        const queueEvents = this.#projectMessageAdmissions || queueHasEntries(this.#snapshot.queue)
+            ? [projectQueueUpdate(this.#snapshot.queue, root.turnId, this.#now())]
+            : [];
         if (this.#projectMessageAdmissions) {
-            events.push(...projectMessageAdmissionEvents(root, [...this.#durableSteeringTurnByMessage]
+            events.push(...projectMessageAdmissionEvents(root, [...this.#durableTurnByMessage]
                 .filter(([, turnId]) => turnId === root.turnId)
                 .map(([messageId]) => messageId), this.#now()));
         }
         if (isRuntimeHostTerminalTurn(root))
-            return events;
+            return [...events, ...queueEvents];
+        // Re-derive the running compaction row on reconnect / restart: the Host keeps
+        // the compaction Turn alive, so a reconnecting client learns of it here.
+        if (root.rootExecutionKind === 'context_compact') {
+            events.push(contextCompactionStartedEvent(root, this.#now()));
+        }
         let seededAssistantText = false;
         if (includeAssistantText) {
             for (const accumulator of this.#accumulators.values()) {
@@ -126,7 +134,7 @@ export class RuntimeHostSessionProjector {
             events.push(...projectRuntimeHostInteractionRequest(interaction, this.#now()));
         }
         for (const entry of rootQueueInFlight(this.#snapshot.queue)) {
-            if (this.#durableSteeringTurnByMessage.has(entry.messageId) ||
+            if (this.#durableTurnByMessage.has(entry.messageId) ||
                 this.#renderedSteeringMessageIds.has(entry.messageId))
                 continue;
             this.#renderedSteeringMessageIds.add(entry.messageId);
@@ -139,23 +147,20 @@ export class RuntimeHostSessionProjector {
                 content: structuredClone(entry.content),
             });
         }
-        if (queueHasEntries(this.#snapshot.queue)) {
-            events.push(projectQueueUpdate(this.#snapshot.queue, root.turnId, this.#now()));
-        }
-        return events;
+        return [...events, ...queueEvents];
     }
     noteDurableTranscriptMessages(messages) {
         const events = [];
         for (const message of messages) {
-            if (message.type !== 'user' || message.steeringEventId === undefined)
+            if (message.type !== 'user')
                 continue;
-            const previousTurnId = this.#durableSteeringTurnByMessage.get(message.id);
-            this.#durableSteeringTurnByMessage.set(message.id, message.turnId);
+            const previousTurnId = this.#durableTurnByMessage.get(message.id);
+            this.#durableTurnByMessage.set(message.id, message.turnId);
             if (!this.#projectMessageAdmissions || previousTurnId === message.turnId)
                 continue;
             events.push({
                 type: 'message_admission',
-                id: `host-admission:${message.steeringEventId}`,
+                id: `host-admission:${message.turnId}:${message.id}`,
                 turnId: message.turnId,
                 ts: this.#now(),
                 messageId: message.id,
@@ -314,7 +319,7 @@ export class RuntimeHostSessionProjector {
         if (frame.kind === 'subscription.session_event') {
             const event = projectSessionEvent(frame);
             if (event.type === 'steering_message') {
-                if (this.#durableSteeringTurnByMessage.has(event.messageId) ||
+                if (this.#durableTurnByMessage.has(event.messageId) ||
                     this.#renderedSteeringMessageIds.has(event.messageId)) {
                     return emptyUpdate(events);
                 }
@@ -340,12 +345,9 @@ export class RuntimeHostSessionProjector {
         const enteredActiveTurn = root && queueChanged(previousSnapshot.queue, next.queue)
             ? newlyInFlight(previousSnapshot.queue, next.queue)
             : [];
-        if (this.#projectMessageAdmissions) {
-            events.push(...projectMessageRetractionEvents(previousSnapshot, next, this.#now()));
-        }
         if (root && queueChanged(previousSnapshot.queue, next.queue)) {
             for (const entry of enteredActiveTurn) {
-                if (this.#durableSteeringTurnByMessage.has(entry.messageId) ||
+                if (this.#durableTurnByMessage.has(entry.messageId) ||
                     this.#renderedSteeringMessageIds.has(entry.messageId))
                     continue;
                 this.#renderedSteeringMessageIds.add(entry.messageId);
@@ -362,6 +364,18 @@ export class RuntimeHostSessionProjector {
         }
         if (startedTurn)
             this.#accumulators.clear();
+        // Emit the presentation-only compaction-started event when the root Turn
+        // FIRST becomes a `context_compact` run, not only when the runId changes.
+        // The real lifecycle is `admitted (no rootExecutionKind) → running/
+        // context_compact` at the SAME runId, so gating on startedTurn would miss
+        // the live transition and only surface the row on reconnect via seedActive.
+        const rootIsCompaction = !!root && !isRuntimeHostTerminalTurn(root) && root.rootExecutionKind === 'context_compact';
+        const previousWasCompaction = !!previousRoot &&
+            !isRuntimeHostTerminalTurn(previousRoot) &&
+            previousRoot.rootExecutionKind === 'context_compact';
+        if (root && rootIsCompaction && !previousWasCompaction) {
+            events.push(contextCompactionStartedEvent(root, this.#now()));
+        }
         const retry = liveProviderRetryEvent(previousRoot, root, this.#now());
         if (retry)
             events.push(retry);
@@ -399,6 +413,13 @@ export class RuntimeHostSessionProjector {
                 turnId: root.turnId,
                 ts: this.#now(),
                 stopReason: 'end_turn',
+                // Forward the typed compaction outcome already carried by the canonical
+                // Turn snapshot so the renderer can settle the running toast and show the
+                // terminal state. This projects an existing snapshot field (no turn-state
+                // persistence), so checkpointId stays a string.
+                ...(root.contextCompactionOutcome
+                    ? { contextCompactionOutcome: root.contextCompactionOutcome }
+                    : {}),
             });
         }
         else if (root.status === 'failed') {
@@ -410,9 +431,6 @@ export class RuntimeHostSessionProjector {
                 recoverable: false,
                 reason: root.failureClass,
                 message: root.failureMessage ?? `Turn failed: ${root.failureClass}`,
-                ...(root.contextBudgetExhaustedDetail
-                    ? { details: { contextBudgetExhaustedDetail: root.contextBudgetExhaustedDetail } }
-                    : {}),
             });
         }
         else {
@@ -440,21 +458,19 @@ function projectMessageAdmissionEvents(root, messageIds, ts) {
         outcome: 'admitted',
     }));
 }
-function projectMessageRetractionEvents(previous, next, ts) {
-    const root = next.rootTurn ?? previous.rootTurn;
-    if (!root || previous.queue.hostEpoch !== next.queue.hostEpoch)
-        return [];
-    const retained = new Set([...next.queue.steering, ...next.queue.followup].map((entry) => entry.messageId));
-    return [...previous.queue.steering, ...previous.queue.followup]
-        .filter((entry) => entry.state === 'queued' && !retained.has(entry.messageId))
-        .map((entry) => ({
-        type: 'message_admission',
-        id: `host-retraction:${next.queue.hostEpoch}:${next.queue.queueRevision}:${entry.messageId}`,
-        turnId: root.turnId,
-        ts,
-        messageId: entry.messageId,
-        outcome: 'retracted',
-    }));
+/**
+ * Presentation-only event that drives the renderer's live "compacting" row.
+ * Emitted on both the live transition (`accept`) and reconnect (`seedActive`)
+ * with a deterministic id keyed on the run, so a reconnect re-emits it
+ * idempotently.
+ */
+function contextCompactionStartedEvent(turn, now) {
+    return {
+        type: 'context_compaction_started',
+        id: `host-compaction-started:${turn.runId}`,
+        turnId: turn.turnId,
+        ts: now,
+    };
 }
 export function projectRuntimeHostInteractionRequest(interaction, now) {
     const base = {
@@ -478,6 +494,17 @@ export function projectRuntimeHostInteractionRequest(interaction, now) {
             },
         ];
     }
+    if (interaction.request.kind === 'form') {
+        return [
+            {
+                type: 'form_request',
+                ...base,
+                message: interaction.request.message,
+                requester: structuredClone(interaction.request.requester),
+                fields: structuredClone(interaction.request.fields),
+            },
+        ];
+    }
     if (interaction.request.kind === 'sandbox_boundary') {
         return [
             {
@@ -488,6 +515,16 @@ export function projectRuntimeHostInteractionRequest(interaction, now) {
             },
         ];
     }
+    if (interaction.request.kind === 'client_capability') {
+        return [
+            {
+                type: 'client_capability_request',
+                ...base,
+                capability: interaction.request.target.capability,
+                scope: structuredClone(interaction.request.target.scope),
+            },
+        ];
+    }
     return [];
 }
 function projectSessionEvent(frame) {

package/node_modules/@maka/runtime-host/dist/candidate-entry.js

@@ -42,7 +42,12 @@ export async function runExecutionCandidateEntry(argv, entrypointUrl, hooks = {}
         rootId = parsed.expectedRootId;
         const { startupAttemptId: parsedStartupAttemptId, ...options } = parsed;
         startupAttemptId = parsedStartupAttemptId;
-        result = await startExecutionRuntimeHostCandidate(hooks.overrideOptions ? hooks.overrideOptions(options) : options, {
+        result = await startExecutionRuntimeHostCandidate({
+            ...(hooks.overrideOptions ? hooks.overrideOptions(options) : options),
+            ...(launchOwnerGuard?.admission
+                ? { initialClientAdmission: launchOwnerGuard.admission }
+                : {}),
+        }, {
             ...hooks.dependencies,
             processLaunch: {
                 executablePath: process.execPath,
@@ -69,7 +74,10 @@ export async function runExecutionCandidateEntry(argv, entrypointUrl, hooks = {}
         await launchOwnerGuard?.dispose();
         process.exit(2);
     }
-    launchOwnerGuard?.bind(() => result.host.close());
+    // A launcher that disappears without releasing this Host (Desktop quit,
+    // launcher crash) is an intentional retirement of an owned ephemeral Host,
+    // not a crash — closing with the retirement reason keeps the exit truthful.
+    launchOwnerGuard?.bind(() => result.host.close({ reason: 'retirement' }));
     const stopWatch = hooks.onWon?.(result.host);
     try {
         await runRuntimeHostProcessLifecycle(result.host);

package/node_modules/@maka/runtime-host/dist/candidate-launch-owner-guard.js

@@ -19,6 +19,7 @@
 import { closeSync } from 'node:fs';
 export const RUNTIME_HOST_LAUNCH_OWNER_LEASE_FD_ENV = 'MAKA_RUNTIME_HOST_LAUNCH_OWNER_LEASE_FD';
 export const RUNTIME_HOST_LAUNCH_OWNER_GUARD_ENV = 'MAKA_RUNTIME_HOST_LAUNCH_OWNER_GUARD';
+export const RUNTIME_HOST_LAUNCH_OWNER_CLIENT_ID_ENV = 'MAKA_RUNTIME_HOST_LAUNCH_OWNER_CLIENT_ID';
 export const RUNTIME_HOST_LAUNCH_OWNER_RELEASE_KIND = 'runtime-host-launch-owner-release';
 /**
  * Closes a launcher-owned Host if its launcher disappears. An optional updater
@@ -37,6 +38,17 @@ export function createRuntimeHostLaunchOwnerGuard(env = process.env) {
             throw new Error('Runtime Host launch-owner authority descriptor is invalid');
         }
     }
+    const clientInstanceId = env[RUNTIME_HOST_LAUNCH_OWNER_CLIENT_ID_ENV];
+    if (leaseFd !== undefined && !clientInstanceId) {
+        throw new Error('Runtime Host launch-owner Client identity is missing');
+    }
+    const admission = leaseFd === undefined
+        ? undefined
+        : {
+            isClientAdmitted(candidateClientInstanceId) {
+                return state === 'released' || candidateClientInstanceId === clientInstanceId;
+            },
+        };
     let state = process.connected ? 'owned' : 'lost';
     let closeHost;
     let lossSettlement;
@@ -75,6 +87,7 @@ export function createRuntimeHostLaunchOwnerGuard(env = process.env) {
     process.on('message', onMessage);
     process.once('disconnect', onDisconnect);
     return {
+        ...(admission ? { admission } : {}),
         bind(close) {
             closeHost = close;
             settleLoss();

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

@@ -30,6 +30,16 @@ export class RuntimeHostCatalogReadError extends Error {
         this.name = 'RuntimeHostCatalogReadError';
     }
 }
+export class RuntimeHostSessionCatalogRevisionChangedError extends Error {
+    expectedRevision;
+    actualRevision;
+    constructor(expectedRevision, actualRevision) {
+        super('Runtime Host Session catalog revision changed');
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+        this.name = 'RuntimeHostSessionCatalogRevisionChangedError';
+    }
+}
 export async function readRuntimeHostConnectionCatalog(connection) {
     const { first, pages } = await collectStablePages('connection', async () => {
         const result = await connection.request('connection.catalog.query', { kind: 'start' });
@@ -105,21 +115,38 @@ export async function readRuntimeHostInvocableSkills(connection, target) {
     return pages.flatMap((page) => page.items);
 }
 export async function readRuntimeHostSessions(connection) {
-    const { pages } = await collectStablePages('session', async () => {
-        const result = await connection.request('session.catalog.query', {
-            kind: 'list_start',
-        });
-        return result.kind === 'page' ? result : null;
-    }, async (revision, cursor) => {
-        const result = await connection.request('session.catalog.query', {
-            kind: 'list_continue',
-            revision,
-            cursor,
-        });
-        return result.kind === 'page' ? result : null;
-    });
+    const readPageOrRestart = async (cursor) => {
+        try {
+            return await readRuntimeHostSessionCatalogPage(connection, cursor);
+        }
+        catch (error) {
+            if (error instanceof RuntimeHostSessionCatalogRevisionChangedError)
+                return null;
+            throw error;
+        }
+    };
+    const { pages } = await collectStablePages('session', () => readPageOrRestart(), (_revision, cursor) => readPageOrRestart(cursor));
     return pages.flatMap((page) => page.sessions);
 }
+export async function readRuntimeHostSessionCatalogPage(connection, cursor) {
+    const result = await connection.request('session.catalog.query', cursor
+        ? { kind: 'list_continue', revision: cursor.revision, cursor: cursor.cursor }
+        : { kind: 'list_start' });
+    if (result.kind === 'revision_changed') {
+        throw new RuntimeHostSessionCatalogRevisionChangedError(result.expectedRevision, result.actualRevision);
+    }
+    if (result.kind !== 'page' || (cursor && result.revision !== cursor.revision)) {
+        throw new RuntimeHostCatalogReadError('session', 'invalid_projection');
+    }
+    if (cursor && result.nextCursor === cursor.cursor) {
+        throw new RuntimeHostCatalogReadError('session', 'repeated_cursor');
+    }
+    return {
+        revision: result.revision,
+        sessions: result.sessions,
+        nextCursor: result.nextCursor === null ? null : { revision: result.revision, cursor: result.nextCursor },
+    };
+}
 export async function readRuntimeHostProjects(connection) {
     return readRuntimeHostProjectCatalog(connection, 'summary');
 }
@@ -277,7 +304,8 @@ function assembleConnectionCatalog(first, items) {
             header: item,
             enabledModelIds: new Map(),
             models: new Map(),
-            relayProfiles: new Map(),
+            catalogEntries: new Map(),
+            modelOverrides: new Map(),
         });
     }
     for (const item of items) {
@@ -286,21 +314,30 @@ function assembleConnectionCatalog(first, items) {
         const entry = entries.get(item.connectionIndex);
         if (!entry)
             throw new RuntimeHostCatalogReadError('connection', 'invalid_projection');
-        const values = item.kind === 'enabled_model_id' ? entry.enabledModelIds : entry.models;
-        const expectedCount = item.kind === 'enabled_model_id' ? entry.header.enabledModelIdCount : entry.header.modelCount;
+        const values = item.kind === 'enabled_model_id'
+            ? entry.enabledModelIds
+            : item.kind === 'model'
+                ? entry.models
+                : entry.catalogEntries;
+        const expectedCount = item.kind === 'enabled_model_id'
+            ? entry.header.enabledModelIdCount
+            : item.kind === 'model'
+                ? entry.header.modelCount
+                : entry.header.catalogEntryCount;
         if (item.itemIndex >= expectedCount || values.has(item.itemIndex)) {
             throw new RuntimeHostCatalogReadError('connection', 'invalid_projection');
         }
         if (item.kind === 'enabled_model_id') {
             entry.enabledModelIds.set(item.itemIndex, item.modelId);
-            // Reassemble the profile table the projector spread across items; the
-            // downstream type is the per-model map, not the wire's per-item shape.
-            if (item.relayProfile !== undefined)
-                entry.relayProfiles.set(item.modelId, item.relayProfile);
         }
-        else {
+        else if (item.kind === 'model') {
             entry.models.set(item.itemIndex, item.model);
         }
+        else {
+            entry.catalogEntries.set(item.itemIndex, item.entry);
+            if (item.modelOverride !== undefined)
+                entry.modelOverrides.set(item.entry.id, item.modelOverride);
+        }
     }
     if (entries.size !== first.connectionCount) {
         throw new RuntimeHostCatalogReadError('connection', 'invalid_projection');
@@ -309,17 +346,19 @@ function assembleConnectionCatalog(first, items) {
         .sort(([left], [right]) => left - right)
         .map(([, entry]) => {
         if (entry.enabledModelIds.size !== entry.header.enabledModelIdCount ||
-            entry.models.size !== entry.header.modelCount) {
+            entry.models.size !== entry.header.modelCount ||
+            entry.catalogEntries.size !== entry.header.catalogEntryCount) {
             throw new RuntimeHostCatalogReadError('connection', 'invalid_projection');
         }
-        const { kind: _kind, connectionIndex: _index, enabledModelIdCount: _enabledCount, modelCount: _modelCount, ...header } = entry.header;
+        const { kind: _kind, connectionIndex: _index, enabledModelIdCount: _enabledCount, modelCount: _modelCount, catalogEntryCount: _catalogEntryCount, ...header } = entry.header;
         return {
             ...header,
             enabledModelIds: orderedValues(entry.enabledModelIds),
             models: orderedValues(entry.models),
-            ...(entry.relayProfiles.size === 0
+            catalogEntries: orderedValues(entry.catalogEntries),
+            ...(entry.modelOverrides.size === 0
                 ? {}
-                : { relayModelProfiles: Object.fromEntries(entry.relayProfiles) }),
+                : { modelOverrides: Object.fromEntries(entry.modelOverrides) }),
         };
     });
     return { revision: first.revision, defaultTarget: first.defaultTarget, connections };

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

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
-import { CLIENT_CAPABILITY_MAX_RESULT_BYTES, CLIENT_CAPABILITY_RESULT_CHUNK_MAX_BYTES, decodeClientCapabilityReplaceInput, decodeClientCapabilityResult, } from '../protocol/index.js';
+import { CLIENT_CAPABILITY_MAX_RESULT_BYTES, CLIENT_CAPABILITY_RESULT_CHUNK_MAX_BYTES, decodeClientCapabilityClientFrame, decodeClientCapabilityReplaceInput, decodeClientCapabilityResult, } from '../protocol/index.js';
 /** Client-owned registration, reverse invocation, and teardown lifecycle. */
 export class ClientCapabilityChannel {
     #options;
@@ -110,6 +110,7 @@ export class ClientCapabilityChannel {
                 invocation.released = true;
                 invocation.controller.abort(new DOMException('Client Capability invocation was cancelled', 'AbortError'));
                 invocation.admission?.reject(capabilityInvocationAbortReason(invocation));
+                invocation.interaction?.reject(capabilityInvocationAbortReason(invocation));
                 return;
             }
             case 'client.capability.release': {
@@ -119,6 +120,7 @@ export class ClientCapabilityChannel {
                 invocation.released = true;
                 invocation.controller.abort(new DOMException('Client Capability invocation was released', 'AbortError'));
                 invocation.admission?.reject(capabilityInvocationAbortReason(invocation));
+                invocation.interaction?.reject(capabilityInvocationAbortReason(invocation));
                 this.#invocations.delete(frame.invocationId);
                 return;
             }
@@ -133,6 +135,16 @@ export class ClientCapabilityChannel {
                 }
                 return;
             }
+            case 'client.capability.interaction_result': {
+                const invocation = this.#invocations.get(frame.invocationId);
+                const interaction = invocation?.interaction;
+                if (!interaction ||
+                    interaction.interactionId !== frame.interactionId ||
+                    !interaction.resolve(frame.result)) {
+                    throw new Error('Runtime Host returned an unmatched capability interaction result');
+                }
+                return;
+            }
         }
     }
     close(error) {
@@ -143,6 +155,7 @@ export class ClientCapabilityChannel {
             invocation.released = true;
             invocation.controller.abort(error);
             invocation.admission?.reject(error);
+            invocation.interaction?.reject(error);
         }
         this.#invocations.clear();
         const providers = new Set([...this.#registrations.values()].map((registration) => registration.provider));
@@ -215,7 +228,7 @@ export class ClientCapabilityChannel {
     async #runInvocation(invocationId, invocation, execute) {
         let accepted = false;
         let accepting;
-        const accept = () => {
+        const accept = (evidence) => {
             if (invocation.released) {
                 return Promise.reject(capabilityInvocationAbortReason(invocation));
             }
@@ -224,6 +237,7 @@ export class ClientCapabilityChannel {
                 this.#options.write({
                     kind: 'client.capability.accepted',
                     invocationId,
+                    admissionEvidence: evidence,
                 }),
                 admission.promise,
             ]).then(() => {
@@ -253,14 +267,54 @@ export class ClientCapabilityChannel {
                 })
                     .catch((error) => this.#options.onFailure(asError(error)));
             };
+            const requestInteraction = async (request) => {
+                if (!accepted) {
+                    throw new Error('Client Capability interaction requires an admitted invocation');
+                }
+                if (invocation.released)
+                    throw capabilityInvocationAbortReason(invocation);
+                if (invocation.interaction) {
+                    throw new Error('Client Capability invocation already has a pending interaction');
+                }
+                const interactionId = randomUUID();
+                const frame = decodeClientCapabilityClientFrame({
+                    kind: 'client.capability.interaction_request',
+                    invocationId,
+                    interactionId,
+                    request,
+                });
+                if (frame.kind !== 'client.capability.interaction_request') {
+                    throw new Error('Client Capability interaction request was not canonical');
+                }
+                const interaction = createClientCapabilityPendingInteraction(interactionId);
+                invocation.interaction = interaction;
+                try {
+                    try {
+                        await this.#options.write(frame);
+                    }
+                    catch (error) {
+                        interaction.reject(error);
+                        throw error;
+                    }
+                    return await interaction.promise;
+                }
+                finally {
+                    if (invocation.interaction === interaction)
+                        invocation.interaction = undefined;
+                }
+            };
             const result = decodeClientCapabilityResult(await execute({
                 signal: invocation.controller.signal,
                 accept,
                 progress,
+                requestInteraction,
             }));
             if (invocation.released)
                 return;
-            await accept();
+            if (invocation.interaction) {
+                throw new Error('Client Capability provider returned with a pending interaction');
+            }
+            await accept({ kind: 'none' });
             await this.#sendResult(invocationId, result, invocation);
         }
         catch (error) {
@@ -365,6 +419,36 @@ function createClientCapabilityAdmission() {
         },
     };
 }
+function createClientCapabilityPendingInteraction(interactionId) {
+    let state = 'pending';
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+    // A buggy provider may start but not await the callback. The invocation still
+    // fails closed, while channel teardown must not create an unhandled rejection.
+    void promise.catch(() => undefined);
+    return {
+        interactionId,
+        promise,
+        resolve: (result) => {
+            if (state !== 'pending')
+                return false;
+            state = 'resolved';
+            resolvePromise(result);
+            return true;
+        },
+        reject: (error) => {
+            if (state !== 'pending')
+                return false;
+            state = 'rejected';
+            rejectPromise(error);
+            return true;
+        },
+    };
+}
 function capabilityInvocationAbortReason(invocation) {
     return (invocation.controller.signal.reason ??
         new DOMException('Client Capability invocation was released', 'AbortError'));

package/node_modules/@maka/runtime-host/dist/client/connect-or-spawn.js

@@ -248,7 +248,15 @@ export async function connectOrSpawnRuntimeHostWithDependencies(input, dependenc
                 }
                 const managedLaunchRejection = runtimeHostManagedLaunchRejection(managedDeployment, managedLaunchClaim, 'on_demand');
                 if (managedLaunchRejection !== undefined) {
-                    return { kind: 'failed', reason: managedLaunchRejection };
+                    // A managed endpoint that accepted a connection but did not answer
+                    // is temporarily unavailable, not evidence that the client needs a
+                    // new operator. Keep reconnecting without ever launching a replacement.
+                    return {
+                        kind: 'failed',
+                        reason: managedLaunchRejection === 'managed_root_requires_operator' && sawUnresponsiveEndpoint
+                            ? 'host_unresponsive'
+                            : managedLaunchRejection,
+                    };
                 }
                 try {
                     const remaining = deadline - performance.now();
@@ -267,7 +275,10 @@ export async function connectOrSpawnRuntimeHostWithDependencies(input, dependenc
                         ...(input.onExit === undefined ? {} : { onExit: input.onExit }),
                         ...(input.inheritableAuthorityLeaseFd === undefined
                             ? {}
-                            : { inheritableAuthorityLeaseFd: input.inheritableAuthorityLeaseFd }),
+                            : {
+                                inheritableAuthorityLeaseFd: input.inheritableAuthorityLeaseFd,
+                                launchOwnerClientInstanceId: clientInstanceId,
+                            }),
                         ...(input.closeOnLauncherExit === undefined
                             ? {}
                             : { closeOnLauncherExit: input.closeOnLauncherExit }),