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

package/node_modules/@maka/runtime/dist/tool-result-archive.js

@@ -17,9 +17,28 @@
  * under the License.
  */
 import { createHash } from 'node:crypto';
-import { buildToolResultArchiveResourceRef, TOOL_RESULT_ARCHIVE_READ_INSTRUCTIONS, } from './tool-result-archive-resource.js';
+import { buildToolResultArchiveResourceRef, TOOL_RESULT_ARCHIVE_READ_INSTRUCTIONS, isLedgerArchiveIdentity, } from './tool-result-archive-resource.js';
 export const ARCHIVED_TOOL_RESULT_PLACEHOLDER_KIND = 'maka.archived_tool_result';
 export const ARCHIVED_TOOL_RESULT_REWRITE_VERSION = 1;
+export function buildLedgerArchivedToolResultPlaceholder(input) {
+    return {
+        storage: 'ledger',
+        runtimeEventId: input.runtimeEventId,
+        toolCallId: input.toolCallId,
+        toolName: input.toolName,
+        sourceProjectionDigest: input.sourceProjectionDigest,
+        ...(input.previousTransitionId ? { previousTransitionId: input.previousTransitionId } : {}),
+        bodySha256: input.bodySha256,
+        originalBytes: input.originalBytes,
+        originalEstimatedTokens: input.originalEstimatedTokens,
+        reason: input.reason,
+        ...(input.supersession ? { supersession: input.supersession } : {}),
+        kind: ARCHIVED_TOOL_RESULT_PLACEHOLDER_KIND,
+        rewriteVersion: 2,
+        resourceRef: buildToolResultArchiveResourceRef(input),
+        readInstructions: TOOL_RESULT_ARCHIVE_READ_INSTRUCTIONS,
+    };
+}
 export function stableToolResultArchiveArtifactId(event) {
     return `tool-result-archive-${createHash('sha256')
         .update(JSON.stringify({
@@ -57,10 +76,12 @@ export function isArchivedToolResultPlaceholder(value) {
     if (!value || typeof value !== 'object')
         return false;
     const candidate = value;
+    const ledgerIdentity = isLedgerArchiveIdentity(value);
     return (candidate.kind === ARCHIVED_TOOL_RESULT_PLACEHOLDER_KIND &&
-        candidate.rewriteVersion === ARCHIVED_TOOL_RESULT_REWRITE_VERSION &&
-        typeof candidate.artifactId === 'string' &&
-        candidate.artifactId.length > 0 &&
+        ((candidate.rewriteVersion === 1 &&
+            typeof candidate.artifactId === 'string' &&
+            candidate.artifactId.length > 0) ||
+            (candidate.rewriteVersion === 2 && ledgerIdentity)) &&
         typeof candidate.runtimeEventId === 'string' &&
         candidate.runtimeEventId.length > 0 &&
         typeof candidate.toolCallId === 'string' &&
@@ -100,6 +121,8 @@ function isValidSupersession(value) {
 export function withToolResultArchiveResourceRef(value) {
     if (!isArchivedToolResultPlaceholder(value))
         return value;
+    if (value.rewriteVersion === 2)
+        return buildLedgerArchivedToolResultPlaceholder(value);
     return {
         ...value,
         resourceRef: buildToolResultArchiveResourceRef({

package/node_modules/@maka/runtime/package.json

@@ -78,6 +78,7 @@
     "./plugin-composition-loader": "./dist/plugin-composition-loader.js",
     "./plugin-kernel": "./dist/plugin-kernel.js",
     "./plugin-runtime": "./dist/plugin-runtime.js",
+    "./plugin-tool-service": "./dist/plugin-tool-service.js",
     "./process-tree-terminator": "./dist/process-tree-terminator.js",
     "./provider-request-telemetry": "./dist/provider-request-telemetry.js",
     "./request-customization-fetch": "./dist/request-customization-fetch.js",

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

@@ -24,7 +24,7 @@ export function formatHostHandoff(view, locale) {
         ? {
             busy: '背景服務仍在使用中',
             activity_unknown: '需要確認是否停止背景服務',
-            operator_required: '需要在服務所在位置處理',
+            operator_required: '背景服務需要手動更新',
             repair_required: '背景服務需要修復',
             retry_required: '暫時無法完成交接',
         }
@@ -32,41 +32,78 @@ export function formatHostHandoff(view, locale) {
             ? {
                 busy: '后台服务仍在使用中',
                 activity_unknown: '需要确认是否停止后台服务',
-                operator_required: '需要在服务所在位置处理',
+                operator_required: '后台服务需要手动更新',
                 repair_required: '后台服务需要修复',
                 retry_required: '暂时无法完成交接',
             }
             : {
                 busy: 'Your background service is still in use',
                 activity_unknown: 'Confirm before stopping the service',
-                operator_required: 'Action is needed where the service runs',
+                operator_required: 'The background service needs a manual update',
                 repair_required: 'Your background service needs repair',
                 retry_required: 'The handoff could not finish yet',
             };
     const descriptions = tw
         ? {
             busy: '其他連線或正在執行的工作阻止了自動交接。停止並繼續可能中斷這些工作。',
-            activity_unknown: '這個版本無法提供足夠的活動資訊。停止服務可能中斷其他視窗或裝置上的工作。',
-            operator_required: `目前的用戶端沒有替換此服務的權限。請在 ${view.target.name} 上，由管理該服務的使用者更新或停止服務。`,
+            activity_unknown: '背景服務與目前用戶端不相容，且無法確認有哪些工作仍在執行。停止並繼續會重新啟動服務，可能中斷其他視窗或裝置上的工作。',
+            operator_required: `目前無法從這裡更新背景服務。請透過 ${view.target.name} 上管理此服務的應用程式或命令更新，再重試。`,
             repair_required: '上次啟動或交接未能完成。可以安全重試；若仍失敗，請複製診斷資訊。',
             retry_required: '服務狀態發生了變化，或交接尚未完成。可以安全重試，不會預設中斷工作。',
         }
         : zh
             ? {
                 busy: '其它连接或正在执行的工作阻止了自动交接。停止并继续可能中断这些工作。',
-                activity_unknown: '这个版本无法提供足够的活动信息。停止服务可能中断其它窗口或设备上的工作。',
-                operator_required: `当前客户端没有替换此服务的权限。请在 ${view.target.name} 上，由管理该服务的用户更新或停止服务。`,
+                activity_unknown: '后台服务与当前客户端不兼容，且无法确认有哪些工作仍在运行。停止并继续会重新启动服务，可能中断其他窗口或设备上的工作。',
+                operator_required: `目前无法从这里更新后台服务。请通过 ${view.target.name} 上管理此服务的应用或命令更新，然后重试。`,
                 repair_required: '上次启动或交接未能完成。可以安全重试；若仍失败，请复制诊断信息。',
                 retry_required: '服务状态发生了变化，或交接尚未完成。可以安全重试，不会默认中断工作。',
             }
             : {
                 busy: 'Other connections or work in progress prevent an automatic handoff. Stopping the service may interrupt that work.',
-                activity_unknown: 'This version cannot provide enough activity information. Stopping it may interrupt work in other windows or on other devices.',
-                operator_required: `This client cannot replace the service. Ask its operator to update or stop it on ${view.target.name}.`,
+                activity_unknown: 'The background service is incompatible with this client, and its active work is unknown. Stop and continue restarts it and may interrupt work in other windows or devices.',
+                operator_required: `This client cannot update the background service here. Use its managing app or operator command on ${view.target.name}, then retry.`,
                 repair_required: 'The last startup or handoff did not finish. Retry safely, or copy diagnostics if it still fails.',
                 retry_required: 'The service changed or the handoff has not finished. A safe retry will not interrupt work by default.',
             };
+    if (view.recoveryBlocker && view.reason === 'operator_required') {
+        const guidance = zh
+            ? tw
+                ? {
+                    managed: '此背景服務由已安裝的管理程式維護。請在服務的管理應用程式中更新，再回到這裡重試。',
+                    owner: '此背景服務屬於另一個 Maka 安裝。請使用管理它的 Maka 安裝更新，再重試。',
+                    installation: '這次啟動使用暫存安裝，無法接管現有背景服務。請使用已安裝的 Maka 更新服務，再重試。',
+                    identity: '無法確認舊背景服務的處理程序身分，因此不能安全停止它。請關閉啟動它的 Maka 或透過其管理程式停止服務，再重試。',
+                }
+                : {
+                    managed: '此后台服务由已安装的管理程序维护。请在服务的管理应用中更新，再回到这里重试。',
+                    owner: '此后台服务属于另一个 Maka 安装。请使用管理它的 Maka 安装更新，然后重试。',
+                    installation: '本次启动使用临时安装，无法接管现有后台服务。请使用已安装的 Maka 更新服务，然后重试。',
+                    identity: '无法确认旧后台服务的进程身份，因此不能安全停止它。请关闭启动它的 Maka 或通过其管理程序停止服务，然后重试。',
+                }
+            : {
+                managed: 'An installed operator manages this background service. Update it through its managing app, then return here and retry.',
+                owner: 'Another Maka installation owns this background service. Update it using that installation, then retry.',
+                installation: 'This temporary installation cannot take over the existing background service. Update it using an installed Maka, then retry.',
+                identity: 'The old background process could not be identified safely. Close the Maka instance that started it or stop it through its operator, then retry.',
+            };
+        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} 個進行中的操作`
@@ -81,10 +118,10 @@ export function formatHostHandoff(view, locale) {
                 ? 'Maka 会持续检查，并在可以安全继续时自动继续。'
                 : 'Maka keeps checking and continues automatically when it is safe.'
         : tw
-            ? 'Maka 會持續檢查。常駐服務不會僅因等待而結束，可能需要你採取操作。'
+            ? 'Maka 會持續檢查。若狀態沒有改變，等待或重試不會解決此問題。'
             : zh
-                ? 'Maka 会持续检查。常驻服务不会仅因等待而退出，可能需要你采取操作。'
-                : 'Maka keeps checking. A persistent service will not exit just because you wait; action may be needed.';
+                ? 'Maka 会持续检查。若状态没有变化，等待或重试不会解决此问题。'
+                : 'Maka keeps checking. Waiting or retrying will not resolve this unless the service state changes.';
     const repairNotice = view.operation === 'repair'
         ? tw
             ? '修復將使用目前應用程式配套的版本，可能替換現有服務版本。'
@@ -150,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-handoff.js

@@ -247,6 +247,7 @@ function projectBlocker(blocker, revision, recovery) {
         ...(replacement ? { operation: replacement.kind } : {}),
         actions: replacement?.canInterrupt ? ['cancel', 'retry', 'interrupt'] : ['cancel', 'retry'],
         defaultAction: 'cancel',
+        ...(blocker.recoveryBlocker ? { recoveryBlocker: blocker.recoveryBlocker } : {}),
         ...(blocker.operatorStep ? { operatorStep: blocker.operatorStep } : {}),
         ...((recovery ?? blocker.diagnostic)
             ? { diagnostic: redactSecrets((recovery ?? blocker.diagnostic)).slice(0, 8_192) }
@@ -265,6 +266,7 @@ function blockerSignature(blocker) {
         blocker.replacement?.canReplaceIdle,
         blocker.replacement?.canInterrupt,
         blocker.operatorStep,
+        blocker.recoveryBlocker,
         blocker.diagnostic,
     ]);
 }

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/client/session-subscription.js

@@ -43,6 +43,7 @@ export class ClientSessionSubscription {
     #expectedSessionId;
     #queue = [];
     #ptyListeners = new Set();
+    #sessionDomainListeners = new Set();
     #queuedBytes = 0;
     #expectedSequence;
     #latestProjectionRevision;
@@ -79,6 +80,12 @@ export class ClientSessionSubscription {
         this.#ptyListeners.add(listener);
         return () => this.#ptyListeners.delete(listener);
     }
+    subscribeSessionDomainChanges(listener) {
+        if (this.#done || this.#terminalError || this.#closing)
+            return () => undefined;
+        this.#sessionDomainListeners.add(listener);
+        return () => this.#sessionDomainListeners.delete(listener);
+    }
     next() {
         const queued = this.#queue.shift();
         if (queued) {
@@ -369,12 +376,23 @@ export class ClientSessionSubscription {
             }
             this.#latestTranscriptThroughSequence = frame.throughSequence;
         }
+        if (frame.kind === 'subscription.session_domain_changed') {
+            for (const listener of this.#sessionDomainListeners) {
+                try {
+                    listener(frame);
+                }
+                catch {
+                    /* An invalidation consumer cannot terminate Session state. */
+                }
+            }
+        }
         this.#offer(frame);
         if (frame.kind === 'subscription.closed')
             this.#doneAfterQueue = true;
     }
     finish() {
         this.#ptyListeners.clear();
+        this.#sessionDomainListeners.clear();
         if (this.#done || this.#terminalError)
             return;
         this.#doneAfterQueue = true;
@@ -386,6 +404,7 @@ export class ClientSessionSubscription {
     }
     fail(error) {
         this.#ptyListeners.clear();
+        this.#sessionDomainListeners.clear();
         if (this.#done || this.#terminalError)
             return;
         this.#terminalError = error;

package/node_modules/@maka/runtime-host/dist/control/endpoint.js

@@ -21,6 +21,7 @@ import { chmod, lstat, mkdtemp, readdir, rm, rmdir, unlink } from 'node:fs/promi
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { truncateUtf8 } from '@maka/core/diagnostic-log';
+import { isNodeError } from '../node-error.js';
 const FALLBACK_ENDPOINT_ROOT = '/tmp';
 const PORTABLE_UNIX_SOCKET_PATH_LIMIT = 100;
 const ENDPOINT_SOCKET_NAME = 'h.sock';
@@ -302,6 +303,3 @@ function currentUid() {
     }
     return process.getuid();
 }
-function isNodeError(error, code) {
-    return (error instanceof Error && 'code' in error && error.code === code);
-}

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

@@ -0,0 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/** Narrows a caught value to a Node errno error with one exact error code. */
+export function isNodeError(error, code) {
+    return error instanceof Error && 'code' in error && error.code === code;
+}

package/node_modules/@maka/runtime-host/dist/operator/managed-deployment.js

@@ -27,6 +27,7 @@ import { z } from 'zod';
 import { isCanonicalRuntimeHostWebSocketPath } from '../protocol/websocket-path.js';
 import { runtimeHostWebRtcStunPolicySchema } from '../webrtc-stun-policy.js';
 import { isProductReleaseVersion, isSha512PackageIntegrity, resolveRuntimeHostNpmDeploymentLayout, } from './update-package-evidence.js';
+import { isNodeError } from '../node-error.js';
 export const RUNTIME_HOST_MANAGED_DEPLOYMENT_CONFIG_FILE = 'runtime-host-deployment.json';
 const SCHEMA_VERSION = 1;
 const MAX_DOCUMENT_BYTES = 256 * 1024;
@@ -824,6 +825,3 @@ function deploymentIo(message, cause) {
             cause,
         });
 }
-function isNodeError(error, code) {
-    return error instanceof Error && 'code' in error && error.code === code;
-}

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

@@ -20,7 +20,6 @@ export const PEER_MESH_MAX_MEMBERS = 64;
 export const PEER_MESH_MAX_MESHES = 16;
 export const PEER_MESH_MAX_PENDING_INVITATIONS = 32;
 export const PEER_MESH_MAX_INVITATION_RECORDS = PEER_MESH_MAX_PENDING_INVITATIONS * 3;
-export const PEER_MESH_MAX_ROUTE_HINTS = 16;
 export const PEER_MESH_MAX_TRANSIT_RELAY_ADDRESSES = 256;
 export const PEER_MESH_MAX_TRANSIT_ADDRESSES_PER_RELAY = 4;
 export const PEER_MESH_MEMBER_ADVERTISEMENT_MAX_BYTES = 2 * 1024;

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

@@ -20,7 +20,7 @@ import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, ran
 import { decodePeerMeshInvitation as decodePeerMeshInvitationWire, } from '../protocol/peer-mesh.js';
 import { PEER_MESH_MEMBER_ADVERTISEMENT_MAX_BYTES, PEER_MESH_MAX_MEMBERS } from './limits.js';
 import { canonicalPeerMeshDisplayName } from './display-name.js';
-export { PEER_MESH_MAX_INVITATION_RECORDS, PEER_MESH_MAX_MEMBERS, PEER_MESH_MAX_MESHES, PEER_MESH_MAX_PENDING_INVITATIONS, PEER_MESH_MAX_ROUTE_HINTS, PEER_MESH_MAX_TRANSIT_ADDRESSES_PER_RELAY, PEER_MESH_MAX_TRANSIT_RELAY_ADDRESSES, PEER_MESH_MEMBER_ADVERTISEMENT_MAX_BYTES, } from './limits.js';
+export { PEER_MESH_MAX_INVITATION_RECORDS, PEER_MESH_MAX_MEMBERS, PEER_MESH_MAX_MESHES, PEER_MESH_MAX_PENDING_INVITATIONS, PEER_MESH_MAX_TRANSIT_ADDRESSES_PER_RELAY, PEER_MESH_MAX_TRANSIT_RELAY_ADDRESSES, } from './limits.js';
 export function generatePeerMeshAuthorityKeyPair() {
     const { publicKey, privateKey } = generateKeyPairSync('ed25519');
     return Object.freeze({

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

@@ -20,6 +20,7 @@ import { chmod, lstat, mkdir, open, readFile, rename, unlink } from 'node:fs/pro
 import { dirname, join } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { authenticateSignedPeerReachabilityLease, canonicalPeerReachabilityLease, decodeSignedPeerReachabilityLease, isPeerReachabilityLeaseCurrent, PEER_REACHABILITY_LEASE_TTL_MS, PEER_REACHABILITY_REFRESH_LEAD_MS, peerReachabilityLeaseReceipt, peerReachabilityLeaseSigningBytes, samePeerReachabilityRoutes, verifySignedPeerReachabilityLease, } from './model.js';
+import { isNodeError } from '../node-error.js';
 const STATE_FILE = 'peer-reachability.json';
 const MAX_STATE_BYTES = 64 * 1_024;
 export async function openPeerReachabilityPublisher(input) {
@@ -240,6 +241,3 @@ async function syncDirectory(path) {
         await handle.close();
     }
 }
-function isNodeError(error, code) {
-    return error instanceof Error && 'code' in error && error.code === code;
-}

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

@@ -62,7 +62,15 @@ 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 = 130;
+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.
+// 131: Logical model steps bind durable Request Composition identities.
 // 130: Turn contributions carry the optional bounded `failureMessage` diagnostic.
 // Epoch-129 peers reject this added field on the strict contribution shape.
 // 129: Turn states and Turn records drop `partialOutputRetained`. The fact was

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/plan.js

@@ -34,6 +34,7 @@ const QUERY_ERRORS = [
 ];
 const CONTROL_ERRORS = [
     ...QUERY_ERRORS,
+    'unauthorized',
     'session_busy',
     'operation_conflict',
     'persistence_failed',

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', 'failures'].includes(input.view)) {
+    if (!['status', 'packages', 'entries', 'tools', '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') {
-        throw invalidProtocolFrame('Plugin root identity is only valid for Entry queries');
+    if (input.rootId !== undefined && view !== 'entries' && view !== 'tools') {
+        throw invalidProtocolFrame('Plugin root identity is only valid for Entry and Tool 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', 'failures'].includes(view)) {
+            !['packages', 'entries', 'tools', 'failures'].includes(view)) {
             throw invalidProtocolFrame('Invalid Plugin Platform page');
         }
         const nextCursor = output.nextCursor === null
@@ -201,7 +201,9 @@ function decodePluginPlatformQueryResult(value) {
                 ? { view, items: output.items.map(decodePackageProjection), nextCursor }
                 : view === 'entries'
                     ? { view, items: decodeInspections(output.items), nextCursor }
-                    : { view: 'failures', items: output.items.map(decodePlatformFailure), nextCursor };
+                    : view === 'tools'
+                        ? { view, items: output.items.map(decodeToolInspection), nextCursor }
+                        : { view: 'failures', items: output.items.map(decodePlatformFailure), nextCursor };
     }
     requireEncodedByteLimit(decoded, 'Plugin Platform query result', PLUGIN_PLATFORM_QUERY_RESULT_MAX_BYTES);
     return decoded;
@@ -443,6 +445,26 @@ function decodeInspections(value) {
         };
     });
 }
+function decodeToolInspection(value) {
+    const inspection = requireExactRecord(value, 'Plugin Tool inspection', [
+        'entryId',
+        'scopeId',
+        'extensionId',
+        'generation',
+        'toolName',
+        'activeCalls',
+        'retired',
+    ]);
+    return {
+        entryId: requireId(inspection.entryId, 'Plugin Tool Entry identity'),
+        scopeId: decodeRootId(inspection.scopeId),
+        extensionId: requireId(inspection.extensionId, 'Plugin Tool package identity'),
+        generation: requireCount(inspection.generation, 'Plugin Tool generation'),
+        toolName: requireString(inspection.toolName, 'Plugin Tool name', 128),
+        activeCalls: requireCount(inspection.activeCalls, 'Plugin Tool active call count'),
+        retired: requireBoolean(inspection.retired),
+    };
+}
 function decodeEntries(value) {
     if (!Array.isArray(value))
         throw invalidProtocolFrame('Invalid Plugin Entry list');

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

@@ -24,14 +24,14 @@ export const PROJECT_CATALOG_PAGE_MAX_ITEMS = 64;
 export const PROJECT_CATALOG_PAGE_MAX_BYTES = 48 * 1024;
 export const PROJECT_CATALOG_CURSOR_MAX_BYTES = 128;
 export const PROJECT_CATALOG_NAME_MAX_BYTES = 16 * 1024;
-export const PROJECT_CATALOG_PATH_MAX_BYTES = 4 * 1024;
+const PROJECT_CATALOG_PATH_MAX_BYTES = 4 * 1024;
 export const PROJECT_DIRECTORY_PAGE_MAX_ITEMS = 128;
 export const PROJECT_DIRECTORY_PAGE_MAX_BYTES = 32 * 1024;
 export const PROJECT_DIRECTORY_MAX_ENTRIES = 4_096;
 export const PROJECT_DIRECTORY_MAX_ROOTS = 8;
 export const PROJECT_DIRECTORY_MAX_SEGMENTS = 64;
 export const PROJECT_DIRECTORY_ROOT_LABEL_MAX_BYTES = 128;
-export const PROJECT_DIRECTORY_ROOT_PATH_MAX_BYTES = PROJECT_CATALOG_PATH_MAX_BYTES;
+const PROJECT_DIRECTORY_ROOT_PATH_MAX_BYTES = PROJECT_CATALOG_PATH_MAX_BYTES;
 export const PROJECT_DIRECTORY_SEGMENT_MAX_BYTES = 255;
 const PROJECT_DIRECTORY_ROOT_TEXT_ENCODER = new TextEncoder();
 export function canonicalProjectDirectoryRootSpec(root) {

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',