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

package/node_modules/@maka/runtime/dist/runtime-kernel.js

@@ -530,6 +530,111 @@ export class RuntimeKernel {
             runId: continuation.runId,
         }, options, () => this.revalidateContinuationSafety(continuation), inheritedSandboxBoundaryDenied);
     }
+    /** Host coordination uses the same Run owner and terminal authority without a provider send. */
+    async *runCoordinationOperation(sessionId, input, options, execute) {
+        const execution = this.takeExecutionClaim(sessionId);
+        execution.hostOperation = true;
+        try {
+            await this.enterExecutionClaim(execution);
+            const header = await this.deps.store.readHeader(sessionId);
+            const run = new AgentRun({
+                sessionId,
+                header,
+                userInput: input,
+                runId: options.runId,
+                userMessageId: options.userMessageId,
+                durability: 'required',
+                runStore: this.deps.runStore,
+                runtimeEventStore: this.deps.runtimeEventStore,
+                newId: this.deps.newId,
+                now: this.deps.now,
+                effectiveOrchestration: resolveEffectiveOrchestration('default', undefined),
+                hooks: {
+                    reserveRun: async (id, nextHeader, activeRun) => {
+                        const active = await this.reserveParentRun(id, nextHeader, activeRun, execution);
+                        this.reserveExecutionClaim(execution, active, activeRun);
+                        return active;
+                    },
+                    unregisterRun: (active, activeRun) => this.unregisterParentRun(active, activeRun),
+                    updateHeader: (id, patch) => this.updateHeader(id, patch),
+                    updateStatus: (id, status, reason, ts) => this.updateStatus(id, status, reason, ts),
+                    ...this.messageProjectionHook(),
+                },
+            });
+            this.attachExecutionClaim(execution, run);
+            const owners = this.createRunOwnerScope(run, execution);
+            try {
+                owners.bindMessage(this.deps.messageAuthority, {
+                    sessionId,
+                    turnId: input.turnId,
+                    runId: run.runId,
+                });
+                // Keep the execution claim attached until finalization. Stop/drain can
+                // therefore cancel and await this Run without a provider generation.
+                await run.beginCoordination();
+                await options.onRunStarted?.(run.runId, header);
+            }
+            catch (error) {
+                await this.finalizeFailedRunStart(owners, run, execution, error);
+                return;
+            }
+            try {
+                if (run.isStopped())
+                    return;
+                const executed = await execute();
+                const receipt = {
+                    ...executed,
+                    result: executed.result.disposition === 'clarify'
+                        ? { ...executed.result, coordinationTurnId: input.turnId }
+                        : executed.result,
+                };
+                const receiptEvent = {
+                    id: this.deps.newId(),
+                    sessionId,
+                    turnId: input.turnId,
+                    runId: run.runId,
+                    invocationId: run.runId,
+                    ts: this.deps.now(),
+                    partial: false,
+                    role: 'system',
+                    author: 'host',
+                    modelVisibility: 'hidden',
+                    actions: { coordination: receipt },
+                };
+                await run.recordRuntimeEvents([receiptEvent], { requireDurableWrite: true });
+                if (run.isStopped())
+                    return;
+                const complete = {
+                    type: 'complete',
+                    id: this.deps.newId(),
+                    turnId: input.turnId,
+                    ts: this.deps.now(),
+                    stopReason: 'end_turn',
+                };
+                await run.acceptMappedEvent(complete, mapSessionEventToRuntimeEvent(complete, this.runtimeEventMapContext({
+                    sessionId,
+                    invocationId: run.runId,
+                    runId: run.runId,
+                    turnId: input.turnId,
+                })), { requireTerminalWrite: true });
+                yield complete;
+            }
+            catch (error) {
+                await run.recordFailure(error);
+                throw error;
+            }
+            finally {
+                const failures = new FailureCollector();
+                await failures.capture(() => owners.finalize());
+                await failures.capture(() => owners.releaseMessage());
+                failures.throwIfAny(`Coordination cleanup failed for ${run.runId}`);
+            }
+        }
+        finally {
+            this.releaseExecutionClaim(execution);
+            await this.flushBackendInvalidation(sessionId);
+        }
+    }
     async *compactSession(sessionId, input = {}) {
         const execution = this.takeExecutionClaim(sessionId);
         try {
@@ -1455,24 +1560,26 @@ export class RuntimeKernel {
         const generations = this.backendGenerationsFor(sessionId);
         await Promise.all(generations.map((active) => active.backend.respondToUserQuestion?.(response)));
     }
+    activeRunsFor(sessionId) {
+        const runs = new Set();
+        for (const active of this.backendGenerationsFor(sessionId)) {
+            for (const run of active.activeRuns.values())
+                runs.add(run);
+        }
+        for (const claim of this.executionClaims.get(sessionId) ?? []) {
+            if (claim.hostOperation && claim.run)
+                runs.add(claim.run);
+        }
+        return [...runs];
+    }
     hasActiveRuns(sessionId) {
-        return this.backendGenerationsFor(sessionId).some((active) => active.activeRuns.size > 0);
+        return this.activeRunsFor(sessionId).length > 0;
     }
     runningTurnIds(sessionId) {
-        const turnIds = [];
-        for (const active of this.backendGenerationsFor(sessionId)) {
-            for (const run of active.activeRuns.values()) {
-                if (!turnIds.includes(run.turnId))
-                    turnIds.push(run.turnId);
-            }
-        }
-        return turnIds;
+        return [...new Set(this.activeRunsFor(sessionId).map((run) => run.turnId))];
     }
     hasActiveRun(sessionId, runId, turnId) {
-        return this.backendGenerationsFor(sessionId).some((active) => {
-            const run = active.activeRuns.get(runId);
-            return run !== undefined && (turnId === undefined || run.turnId === turnId);
-        });
+        return this.activeRunsFor(sessionId).some((run) => run.runId === runId && (turnId === undefined || run.turnId === turnId));
     }
     requestRunHandoff(sessionId, runId, pause, signal) {
         if (!this.deps.inspectContinuationSafety)

package/node_modules/@maka/runtime/dist/session-manager.js

@@ -16,17 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-/**
- * SessionManager — the public Runtime API.
- *
- * Ties together:
- *   SessionStore (storage)           — SQLite persistence
- *   AgentBackend (AiSdkBackend etc) — SDK adapter
- *   ExecutionBoundary                — session sandbox authority
- *
- * `SessionStore` comes from `@maka/storage`; its public interface owns
- * persistence and same-session serialization semantics.
- */
 import { createHash } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { setTimeout as delay } from 'node:timers/promises';
@@ -1280,6 +1269,9 @@ export class SessionManager {
             // Operational telemetry must never alter resume correctness.
         }
     }
+    runCoordinationOperation(sessionId, input, options, execute) {
+        return this.runtimeKernel.runCoordinationOperation(sessionId, input, options, execute);
+    }
     async *compactSession(sessionId, input = {}) {
         yield* this.runtimeKernel.compactSession(sessionId, input);
     }
@@ -2314,43 +2306,30 @@ export class SessionManager {
         const hostedAuthority = isRuntimeHostedRootAuthority(this.deps.messageAuthority)
             ? this.deps.messageAuthority
             : undefined;
-        const ownStop = hostedAuthority
+        await this.#stopSessionTree(sessionId, hostedAuthority
             ? hostedAuthority.stopSession(sessionId, input)
-            : this.runtimeKernel.stopSession(sessionId, input);
-        let childStops = [];
-        let childLookupError;
-        try {
-            const children = await this.listChildSessions(sessionId);
-            childStops = await Promise.allSettled(children
-                .filter((child) => child.subagentParent?.lifecycle === 'foreground')
-                .map((child) => hostedAuthority
-                ? hostedAuthority.stopSession(child.id, input)
-                : this.runtimeKernel.stopSession(child.id, input)));
-        }
-        catch (error) {
-            childLookupError = error;
-        }
-        await ownStop;
-        const childStopError = childStops.find((result) => result.status === 'rejected')?.reason;
-        if (childLookupError !== undefined)
-            throw childLookupError;
-        if (childStopError !== undefined)
-            throw childStopError;
+            : this.runtimeKernel.stopSession(sessionId, input), (childSessionId) => hostedAuthority
+            ? hostedAuthority.stopSession(childSessionId, input)
+            : this.runtimeKernel.stopSession(childSessionId, input));
     }
     async deliverHostedRootStop(sessionId, input = {}) {
-        const ownStop = this.runtimeKernel.stopSession(sessionId, input);
         const authority = isRuntimeHostedRootAuthority(this.deps.messageAuthority)
             ? this.deps.messageAuthority
             : undefined;
+        await this.#stopSessionTree(sessionId, this.runtimeKernel.stopSession(sessionId, input), (childSessionId) => authority
+            ? authority.stopSession(childSessionId, input)
+            : this.runtimeKernel.stopSession(childSessionId, input));
+    }
+    async #stopSessionTree(sessionId, ownStop, stopChild) {
+        // Observe immediately while child lookup runs; await below still propagates the original error.
+        void ownStop.catch(() => undefined);
         let childStops = [];
         let childLookupError;
         try {
             const children = await this.listChildSessions(sessionId);
             childStops = await Promise.allSettled(children
                 .filter((child) => child.subagentParent?.lifecycle === 'foreground')
-                .map((child) => authority
-                ? authority.stopSession(child.id, input)
-                : this.runtimeKernel.stopSession(child.id, input)));
+                .map((child) => stopChild(child.id)));
         }
         catch (error) {
             childLookupError = error;
@@ -2385,6 +2364,11 @@ export class SessionManager {
                 goalId: input.execution.goalId,
             };
         }
+        else if (input.execution.kind === 'workhub_coordination' &&
+            input.execution.operation === 'action') {
+            recoveryReason = 'coordination_action_admission_without_run';
+            diagnostic = { executionKind: input.execution.kind, operation: input.execution.operation };
+        }
         else if (input.execution.kind === 'legacy_automation') {
             root = { kind: 'legacy_automation', legacyAutomationId: input.execution.automationId };
             recoveryReason = 'legacy_automation_authority_removed';

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

@@ -78,6 +78,12 @@ export class RuntimeHostRequestInterruptedError extends Error {
         this.retryable = mode === 'query';
     }
 }
+// A Host response can reach the Client before the Host's transport write
+// promise resumes and retires that request. Leave one slot free so replacing
+// the observed response cannot transiently cross the Host's hard limit. The
+// Host serializes outbound writes, so at most one response occupies this
+// acknowledgement window.
+const CLIENT_MAX_IN_FLIGHT_DOMAIN_REQUESTS = RUNTIME_HOST_MAX_IN_FLIGHT_DOMAIN_REQUESTS - 1;
 class RuntimeHostConnectionImpl {
     cooperativeHandoff;
     rootId;
@@ -212,7 +218,7 @@ class RuntimeHostConnectionImpl {
     }
     #drainDomainRequests() {
         while (!this.#terminalError &&
-            this.#inFlightDomainRequests < RUNTIME_HOST_MAX_IN_FLIGHT_DOMAIN_REQUESTS) {
+            this.#inFlightDomainRequests < CLIENT_MAX_IN_FLIGHT_DOMAIN_REQUESTS) {
             const queued = this.#queuedDomainFrames.shift();
             if (!queued)
                 return;
@@ -243,9 +249,28 @@ class RuntimeHostConnectionImpl {
         }
         return status;
     }
-    openSessionSubscription(input, timeoutMs) {
+    async openSessionSubscription(input, timeoutMs) {
+        const deadline = Date.now() + (timeoutMs === undefined ? 30_000 : requireTimeout(timeoutMs, 'timeoutMs'));
+        for (;;) {
+            try {
+                return await this.#openSessionSubscription(input, Math.max(1, deadline - Date.now()), timeoutMs);
+            }
+            catch (error) {
+                if (!(error instanceof RuntimeHostOperationError) ||
+                    error.code !== 'transcript_preparing' ||
+                    input.transcript.kind !== 'tail' ||
+                    this.#terminalError ||
+                    Date.now() >= deadline)
+                    throw error;
+                // Each refusal committed a bounded, resumable index batch. Keep the
+                // caller in its loading state and yield before requesting more work.
+                await new Promise((resolve) => setTimeout(resolve, 25));
+            }
+        }
+    }
+    #openSessionSubscription(input, openTimeoutMs, requestTimeoutMs) {
         const expectedSessionId = input.sessionId;
-        return this.#requestOperation('subscription.open', input, timeoutMs, (result) => {
+        return this.#requestOperation('subscription.open', input, openTimeoutMs, (result) => {
             if (result.hostEpoch !== this.hostEpoch) {
                 throw new RuntimeHostSubscriptionError('host_epoch_changed', 'Session subscription opened for a different Host Epoch');
             }
@@ -255,9 +280,9 @@ class RuntimeHostConnectionImpl {
             if (this.#subscriptions.has(result.subscriptionId)) {
                 throw new RuntimeHostSubscriptionError('correlation_changed', 'Runtime Host returned a duplicate subscription identity');
             }
-            const subscription = new ClientSessionSubscription(result, () => this.#closeSessionSubscription(result.subscriptionId), (query) => this.request('session.transcript.page', query, timeoutMs), async () => {
+            const subscription = new ClientSessionSubscription(result, () => this.#closeSessionSubscription(result.subscriptionId), (query) => this.request('session.transcript.page', query, requestTimeoutMs), async () => {
                 try {
-                    await this.request('session.transcript.overlay.release', { subscriptionId: result.subscriptionId }, timeoutMs);
+                    await this.request('session.transcript.overlay.release', { subscriptionId: result.subscriptionId }, requestTimeoutMs);
                 }
                 catch (error) {
                     this.#fail(asError(error));

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

@@ -90,6 +90,20 @@ export function formatHostHandoff(view, locale) {
         descriptions.operator_required = guidance[view.recoveryBlocker];
     }
     const activity = view.activity;
+    const background = activity?.drainResidencies;
+    const backgroundFacts = !activity
+        ? ''
+        : background !== undefined
+            ? tw
+                ? `${background} 個背景工作`
+                : zh
+                    ? `${background} 个后台工作`
+                    : `${background} background activities`
+            : tw
+                ? '背景工作數量未知'
+                : zh
+                    ? '后台工作数量未知'
+                    : 'Background activity count unknown';
     const facts = activity
         ? tw
             ? `${activity.connections} 個連線 · ${activity.activeOperations} 個進行中的操作`
@@ -173,7 +187,9 @@ export function formatHostHandoff(view, locale) {
                 : zh
                     ? '正在完成交接或安全收尾，请稍候。'
                     : 'Finishing the handoff or its safe recovery. Please wait.'
-            : [facts, waiting, repairNotice, view.operatorStep].filter(Boolean).join('\n'),
+            : [facts, backgroundFacts, waiting, repairNotice, view.operatorStep]
+                .filter(Boolean)
+                .join('\n'),
         actions: view.actions.map((action) => ({ action, label: labels[action] })),
     };
 }

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

@@ -23,7 +23,7 @@
  * transport detail here so lifecycle owners can model the operation as
  * retirement instead of spreading update-specific authority.
  */
-export async function prepareConnectedRuntimeHostRetirement(connection, mode, timeoutMs, signal) {
+export async function prepareConnectedRuntimeHostRetirement(connection, mode, timeoutMs, signal, options) {
     signal?.throwIfAborted();
     // Retirement uses a dedicated lifecycle connection. Closing it cancels the
     // Host's reversible preparation; a committed retirement remains committed.
@@ -35,7 +35,9 @@ export async function prepareConnectedRuntimeHostRetirement(connection, mode, ti
         return await connection.request('host.upgrade.prepare', {
             expectedHostEpoch: connection.hostEpoch,
             allowInterruptActiveTasks: mode === 'interrupt_active_work',
-            ...(mode === 'refuse_active_work' && connection.cooperativeHandoff
+            ...(mode === 'refuse_active_work' &&
+                connection.cooperativeHandoff &&
+                options?.allowCooperativeHandoff !== false
                 ? { allowCooperativeHandoff: true }
                 : {}),
         }, timeoutMs);

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

@@ -149,6 +149,23 @@ class RuntimeHostPeerClientImpl {
         };
     }
     subscribeRoutes(peerId, listener) {
+        const snapshot = () => this.#connectionResolution({ peerId, routeHints: [], directDeadlineMs: 0 }, 'application', false);
+        let previous = snapshot();
+        let connected = this.isConnected(peerId);
+        return this.#subscribeRouteResolution(peerId, () => {
+            const next = snapshot();
+            const nextConnected = this.isConnected(peerId);
+            const available = next.state === 'available' &&
+                (!sameCandidates(previous, next) || (nextConnected && !connected));
+            previous = next;
+            connected = nextConnected;
+            // A dial's own recovery sweep toggles recovering/exhausted. Waking its
+            // reconnect owner for those transitions would bypass every backoff.
+            if (available)
+                listener();
+        });
+    }
+    #subscribeRouteResolution(peerId, listener) {
         const listeners = this.#routeListeners.get(peerId) ?? new Set();
         const first = listeners.size === 0;
         listeners.add(listener);
@@ -362,7 +379,7 @@ class RuntimeHostPeerClientImpl {
             updateTail = updateTail.then(() => updatePeerConnect(endpoint, requestId, candidates, () => settled), () => updatePeerConnect(endpoint, requestId, candidates, () => settled));
             void updateTail.catch(() => undefined);
         };
-        const unsubscribe = kind === 'application' ? this.subscribeRoutes(input.peerId, update) : undefined;
+        const unsubscribe = kind === 'application' ? this.#subscribeRouteResolution(input.peerId, update) : undefined;
         let connection;
         try {
             connection = endpoint[kind === 'application' ? 'connect' : 'connectMeshControl']({

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

@@ -62,7 +62,11 @@ 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 = 133;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 135;
+// 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
+// distinguishes stale candidate refusals and resumable transcript preparation.
 // 133: WorkHub actions carry attachments and new-Work model/permission defaults.
 // Epoch-132 peers reject these additional fields on strict action shapes.
 // 132: new Tool Result archives use versioned ledger references, not Artifact payloads.

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

@@ -218,9 +218,10 @@ export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
     'usage.query',
     'web-search.execute',
     'workhub.coordination.answer',
-    'workhub.coordination.act',
+    'workhub.coordination.actFromTurn',
     'workhub.coordination.candidates',
-    'workhub.coordination.record',
+    'workhub.coordination.configureModel',
+    'workhub.coordination.query',
     'workhub.coordination.resolve',
 ]);
 const REMOTE_OWNER_OPERATION_GRANT_SET = new Set(REMOTE_OWNER_OPERATION_GRANTS);

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

@@ -56,6 +56,7 @@ export const SESSION_DOMAINS = [
 ];
 export const SESSION_RUNTIME_RESOURCE_CHANGES_MAX = 64;
 const SUBSCRIPTION_OPEN_ERRORS = [
+    'transcript_preparing',
     'host_not_ready',
     'host_draining',
     'operation_unavailable',