maka-agent 0.2.0-dev.14.20260902 → 0.2.0-dev.16.20260903

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

@@ -0,0 +1,119 @@
+/*
+ * 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.
+ */
+import { chmod, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { acquireFileLifetimeOwner, } from '@maka/storage/file-lifetime-owner';
+import { createRuntimeHostPeerClient } from '../client/peer-client.js';
+import { RuntimeHostPermanentReconnectError } from '../client/reconnect-lifecycle.js';
+import { openPeerReachabilityPublisher, PeerReachabilityPostCommitError, } from './publisher.js';
+const REACHABILITY_WATCH_TIMEOUT_MS = 60_000;
+const REACHABILITY_RETRY_INTERVAL_MS = 5_000;
+export async function openRuntimeHostPeerEndpointOwner(input) {
+    await mkdir(input.dataRoot, { recursive: true, mode: 0o700 });
+    if (process.platform !== 'win32')
+        await chmod(input.dataRoot, 0o700);
+    const rootOwner = await acquireFileLifetimeOwner(join(input.dataRoot, 'peer-endpoint.owner'));
+    let client;
+    let reachability;
+    try {
+        client = createRuntimeHostPeerClient({
+            nativePath: input.nativePath,
+            keyPath: input.keyPath,
+            relayAnchorPath: join(input.dataRoot, 'relay-anchors.json'),
+            ...(input.expectedPeerId ? { expectedPeerId: input.expectedPeerId } : {}),
+            ...(input.listenAddresses ? { listenAddresses: input.listenAddresses } : {}),
+            ...(input.coordinationRelays ? { coordinationRelays: input.coordinationRelays } : {}),
+            ...(input.automaticRelayDiscovery === undefined
+                ? {}
+                : { automaticRelayDiscovery: input.automaticRelayDiscovery }),
+            ...(input.webRtcStunUrls === undefined ? {} : { webRtcStunUrls: input.webRtcStunUrls }),
+        });
+        const peerId = client.identity().peerId;
+        reachability = await openPeerReachabilityPublisher({
+            dataRoot: join(input.dataRoot, peerId),
+            peer: client,
+        });
+    }
+    catch (error) {
+        await reachability?.close().catch(() => undefined);
+        await client?.close().catch(() => undefined);
+        await rootOwner.close().catch(() => undefined);
+        throw error;
+    }
+    let closeTask;
+    const ownedClient = client;
+    const ownedReachability = reachability;
+    const lifetime = new AbortController();
+    const maintenance = maintainReachability(ownedClient, ownedReachability, lifetime.signal, input.onBackgroundReachabilityError);
+    void maintenance.catch(() => undefined);
+    return Object.freeze({
+        client: ownedClient,
+        reachability: ownedReachability,
+        closed: maintenance,
+        close: () => {
+            lifetime.abort();
+            closeTask ??= closeEndpointOwner(ownedClient, ownedReachability, rootOwner, maintenance);
+            return closeTask;
+        },
+    });
+}
+async function closeEndpointOwner(client, reachability, rootOwner, maintenance) {
+    const errors = [];
+    await client.close().catch((error) => errors.push(error));
+    await maintenance.catch((error) => errors.push(error));
+    await reachability.close().catch((error) => errors.push(error));
+    await rootOwner.close().catch((error) => errors.push(error));
+    if (errors.length === 1)
+        throw errors[0];
+    if (errors.length > 1) {
+        throw new AggregateError(errors, 'Unable to close Runtime Host peer endpoint owner');
+    }
+}
+async function maintainReachability(client, publisher, signal, onError) {
+    let generation = client.reachability().generation;
+    while (!signal.aborted) {
+        try {
+            await publisher.refresh();
+            const observed = await client.watchReachability(generation, REACHABILITY_WATCH_TIMEOUT_MS);
+            generation = observed.generation;
+        }
+        catch (error) {
+            if (signal.aborted)
+                return;
+            if (error instanceof PeerReachabilityPostCommitError ||
+                error instanceof RuntimeHostPermanentReconnectError) {
+                throw error;
+            }
+            try {
+                onError?.(error);
+            }
+            catch {
+                // A diagnostic observer cannot control the endpoint lifetime.
+            }
+            try {
+                await delay(REACHABILITY_RETRY_INTERVAL_MS, undefined, { signal });
+            }
+            catch {
+                if (signal.aborted)
+                    return;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,245 @@
+/*
+ * 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.
+ */
+import { chmod, lstat, mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+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';
+const STATE_FILE = 'peer-reachability.json';
+const MAX_STATE_BYTES = 64 * 1_024;
+export async function openPeerReachabilityPublisher(input) {
+    await mkdir(input.dataRoot, { recursive: true, mode: 0o700 });
+    if (process.platform !== 'win32')
+        await chmod(input.dataRoot, 0o700);
+    const now = input.now ?? Date.now;
+    const monotonicNow = input.monotonicNow ?? performance.now.bind(performance);
+    const current = await readState(join(input.dataRoot, STATE_FILE), input.peer);
+    const publisher = new PeerReachabilityPublisherImpl(join(input.dataRoot, STATE_FILE), input.peer, now, monotonicNow, current);
+    await publisher.refresh();
+    return publisher;
+}
+class PeerReachabilityPublisherImpl {
+    path;
+    peer;
+    now;
+    monotonicNow;
+    #current;
+    #receipt;
+    #tail = Promise.resolve();
+    #failure;
+    #closed = false;
+    #closeTask;
+    #listeners = new Set();
+    constructor(path, peer, now, monotonicNow, current) {
+        this.path = path;
+        this.peer = peer;
+        this.now = now;
+        this.monotonicNow = monotonicNow;
+        this.#current = current;
+        if (current) {
+            this.#receipt = peerReachabilityLeaseReceipt({
+                signed: current,
+                wallNow: this.now(),
+                monotonicNow: this.monotonicNow(),
+            });
+        }
+    }
+    current() {
+        this.#assertOpen();
+        if (!this.#current)
+            throw new Error('Peer reachability publisher is not initialized');
+        return this.#current;
+    }
+    subscribe(listener) {
+        this.#assertOpen();
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    }
+    refresh() {
+        this.#assertOpen();
+        const task = this.#tail.then(async () => {
+            this.#assertOpen();
+            const identity = this.peer.identity();
+            const reachability = this.peer.reachability();
+            const now = this.now();
+            const monotonicNow = this.monotonicNow();
+            if (this.#current &&
+                this.#current.lease.peerId === identity.peerId &&
+                this.#current.lease.issuedAt <= now &&
+                this.#current.lease.expiresAt > now + PEER_REACHABILITY_REFRESH_LEAD_MS &&
+                isPeerReachabilityLeaseCurrent(this.#current, this.#receipt, monotonicNow + PEER_REACHABILITY_REFRESH_LEAD_MS) &&
+                samePeerReachabilityRoutes(this.#current.lease, reachability)) {
+                return this.#current;
+            }
+            const revision = (this.#current?.lease.revision ?? 0) + 1;
+            const lease = canonicalPeerReachabilityLease({
+                version: 1,
+                peerId: identity.peerId,
+                revision,
+                issuedAt: now,
+                expiresAt: now + PEER_REACHABILITY_LEASE_TTL_MS,
+                directRoutes: reachability.listenAddresses,
+                coordinationRoutes: reachability.activeCoordinationRelays,
+            });
+            const identityProof = await this.peer.signIdentity(peerReachabilityLeaseSigningBytes(lease));
+            const signed = decodeSignedPeerReachabilityLease({
+                lease,
+                publicKey: identityProof.publicKey.toString('base64url'),
+                signature: identityProof.signature.toString('base64url'),
+            });
+            verifySignedPeerReachabilityLease({
+                value: signed,
+                expectedPeerId: identity.peerId,
+                now,
+                verifyIdentity: this.peer.verifyIdentity.bind(this.peer),
+            });
+            try {
+                await writeState(this.path, signed);
+                this.#adopt(signed, now, monotonicNow);
+            }
+            catch (error) {
+                if (error instanceof PeerReachabilityPostCommitError) {
+                    this.#adopt(signed, now, monotonicNow);
+                    this.#notify(signed);
+                    this.#failure = error;
+                    throw error;
+                }
+                throw new PeerReachabilityPersistenceError(error);
+            }
+            this.#notify(signed);
+            return signed;
+        });
+        this.#tail = task.then(() => undefined, () => undefined);
+        return task;
+    }
+    close() {
+        this.#closeTask ??= this.#close();
+        return this.#closeTask;
+    }
+    async #close() {
+        this.#closed = true;
+        await this.#tail;
+        this.#listeners.clear();
+    }
+    #notify(lease) {
+        for (const listener of this.#listeners) {
+            try {
+                listener(lease);
+            }
+            catch {
+                // Reachability publication remains authoritative even if an observer fails.
+            }
+        }
+    }
+    #assertOpen() {
+        if (this.#closed)
+            throw new Error('Peer reachability publisher is closed');
+        if (this.#failure)
+            throw this.#failure;
+    }
+    #adopt(signed, wallNow, monotonicNow) {
+        this.#current = signed;
+        this.#receipt = peerReachabilityLeaseReceipt({ signed, wallNow, monotonicNow });
+    }
+}
+async function readState(path, peer) {
+    try {
+        const stat = await lstat(path);
+        if (!stat.isFile() || stat.size > MAX_STATE_BYTES) {
+            throw new Error('Invalid peer reachability state file');
+        }
+        const document = JSON.parse(await readFile(path, 'utf8'));
+        if (!document || typeof document !== 'object' || Array.isArray(document)) {
+            throw new Error('Invalid peer reachability state document');
+        }
+        const record = document;
+        if (record.version !== 1 || Object.keys(record).length !== 2) {
+            throw new Error('Invalid peer reachability state document');
+        }
+        return authenticateSignedPeerReachabilityLease({
+            value: record.current,
+            expectedPeerId: peer.identity().peerId,
+            verifyIdentity: peer.verifyIdentity.bind(peer),
+        });
+    }
+    catch (error) {
+        if (isNodeError(error, 'ENOENT'))
+            return undefined;
+        throw error;
+    }
+}
+async function writeState(path, current) {
+    const document = `${JSON.stringify({ version: 1, current }, null, 2)}\n`;
+    if (Buffer.byteLength(document) > MAX_STATE_BYTES) {
+        throw new Error('Peer reachability state is too large');
+    }
+    const temporary = `${path}.tmp`;
+    let replaced = false;
+    try {
+        await unlink(temporary).catch((error) => {
+            if (!isNodeError(error, 'ENOENT'))
+                throw error;
+        });
+        const handle = await open(temporary, 'wx', 0o600);
+        try {
+            await handle.writeFile(document, 'utf8');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        if (process.platform !== 'win32')
+            await chmod(temporary, 0o600);
+        await rename(temporary, path);
+        replaced = true;
+        try {
+            await syncDirectory(dirname(path));
+        }
+        catch (error) {
+            throw new PeerReachabilityPostCommitError(error);
+        }
+    }
+    finally {
+        if (!replaced)
+            await unlink(temporary).catch(() => undefined);
+    }
+}
+export class PeerReachabilityPersistenceError extends Error {
+    constructor(cause) {
+        super('Peer reachability state could not be persisted', { cause });
+    }
+}
+export class PeerReachabilityPostCommitError extends Error {
+    constructor(cause) {
+        super('Peer reachability state was replaced but its durability could not be confirmed; reopen it', { cause });
+    }
+}
+async function syncDirectory(path) {
+    if (process.platform === 'win32')
+        return;
+    const handle = await open(path, 'r');
+    try {
+        await handle.sync();
+    }
+    finally {
+        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/agent-graph.js

@@ -673,7 +673,9 @@ function decodeSignal(value) {
     const record = requireShapedRecord(value, 'agent graph signal', ['kind'], ['reason', 'status']);
     if (record.kind === 'attention') {
         requireExactRecord(record, 'agent graph attention signal', ['kind', 'reason']);
-        if (record.reason !== 'permission_request' && record.reason !== 'user_question_request') {
+        if (record.reason !== 'permission_request' &&
+            record.reason !== 'user_question_request' &&
+            record.reason !== 'form_request') {
             throw invalidProtocolFrame('Invalid agent graph attention reason');
         }
         return { kind: record.kind, reason: record.reason };
@@ -854,6 +856,7 @@ function requireFacet(value) {
         value === 'permission_request' ||
         value === 'permission_decision' ||
         value === 'user_question_request' ||
+        value === 'form_request' ||
         value === 'transfer' ||
         value === 'usage' ||
         value === 'completed' ||

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

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { TOOL_ACTIVITY_KINDS } from '@maka/core/events';
+import { decodeInteractionAnswer, projectInteractionFormRequest, } from '@maka/core/interaction';
 import { assertExactKeys, requireCount, requireEntityId, requireExactRecord, requireRecord, requireString, } from './codec.js';
 import { invalidProtocolFrame } from './errors.js';
 import { defineHostPathOperation, defineOperation } from './operation-spec.js';
@@ -241,6 +242,19 @@ export function decodeClientCapabilityClientFrame(value) {
                 data,
             };
         }
+        case 'client.capability.interaction_request':
+            assertExactKeys(frame, 'Client Capability interaction request frame', [
+                'kind',
+                'invocationId',
+                'interactionId',
+                'request',
+            ]);
+            return {
+                kind: frame.kind,
+                invocationId: requireEntityId(frame.invocationId, 'invocationId'),
+                interactionId: requireEntityId(frame.interactionId, 'interactionId'),
+                request: decodeClientCapabilityFormRequest(frame.request),
+            };
         default:
             throw invalidProtocolFrame('Invalid Client Capability client frame kind');
     }
@@ -330,6 +344,19 @@ export function decodeClientCapabilityHostFrame(value) {
                 kind: frame.kind,
                 invocationId: requireEntityId(frame.invocationId, 'invocationId'),
             };
+        case 'client.capability.interaction_result':
+            assertExactKeys(frame, 'Client Capability interaction result frame', [
+                'kind',
+                'invocationId',
+                'interactionId',
+                'result',
+            ]);
+            return {
+                kind: frame.kind,
+                invocationId: requireEntityId(frame.invocationId, 'invocationId'),
+                interactionId: requireEntityId(frame.interactionId, 'interactionId'),
+                result: decodeClientCapabilityFormResult(frame.result),
+            };
         case 'client.capability.registration_release':
             assertExactKeys(frame, 'Client Capability registration release frame', [
                 'kind',
@@ -359,6 +386,45 @@ export function decodeClientCapabilityResult(value) {
             : {}),
     };
 }
+function decodeClientCapabilityFormRequest(value) {
+    const record = requireExactRecord(value, 'Client Capability form request', [
+        'message',
+        'requester',
+        'fields',
+    ]);
+    let request;
+    try {
+        request = projectInteractionFormRequest({
+            toolUseId: 'client-capability-interaction',
+            message: record.message,
+            requester: record.requester,
+            fields: record.fields,
+        });
+    }
+    catch {
+        throw invalidProtocolFrame('Invalid Client Capability form request');
+    }
+    return {
+        message: request.message,
+        requester: request.requester,
+        fields: request.fields,
+    };
+}
+function decodeClientCapabilityFormResult(value) {
+    const record = requireRecord(value, 'Client Capability form result');
+    let answer;
+    try {
+        answer = decodeInteractionAnswer({ kind: 'form', ...record });
+    }
+    catch {
+        throw invalidProtocolFrame('Invalid Client Capability form result');
+    }
+    if (answer.kind !== 'form')
+        throw invalidProtocolFrame('Invalid Client Capability form result');
+    return answer.action === 'accept'
+        ? { action: 'accept', values: answer.values }
+        : { action: answer.action };
+}
 function decodeClientCapabilityOffer(value) {
     const record = requireRecord(value, 'Client Capability offer');
     assertOptionalExactKeys(record, 'Client Capability offer', ['offerId', 'version', 'affinity', 'hostPathAccess', 'label', 'tools'], ['description']);
@@ -820,6 +886,7 @@ const CLIENT_CAPABILITY_CLIENT_FRAME_KINDS = new Set([
     'client.capability.result',
     'client.capability.result_start',
     'client.capability.result_chunk',
+    'client.capability.interaction_request',
 ]);
 const CLIENT_CAPABILITY_HOST_FRAME_KINDS = new Set([
     'client.capability.call',
@@ -828,4 +895,5 @@ const CLIENT_CAPABILITY_HOST_FRAME_KINDS = new Set([
     'client.capability.release',
     'client.capability.registration_release',
     'client.capability.admitted',
+    'client.capability.interaction_result',
 ]);

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

@@ -16,8 +16,8 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { CONNECTION_CATALOG_MAX_MODELS_PER_CONNECTION, decodeConnectionModelId, decodeConnectionModel, decodeConnectionSlug, decodeProviderType, decodeConnectionTestSummary, decodeConnectionVersionBasis, RuntimePolicyDomainDecodeError, } from '@maka/core/runtime-policy';
-import { requireCount, requireEntityId, requireExactRecord, requireRecord, requireString, } from './codec.js';
+import { CONNECTION_CATALOG_MAX_MODELS_PER_CONNECTION, decodeConnectionModelId, decodeConnectionModel, decodeConnectionName, decodeConnectionSlug, decodeProviderType, decodeConnectionTestSummary, decodeConnectionVersionBasis, RuntimePolicyDomainDecodeError, } from '@maka/core/runtime-policy';
+import { requireCount, requireEntityId, requireExactRecord, requireRecord, requireShapedRecord, requireString, } from './codec.js';
 import { invalidProtocolFrame } from './errors.js';
 import { defineOperation } from './operation-spec.js';
 const EFFECT_ERRORS = [
@@ -91,9 +91,8 @@ export function decodeConnectionOnboardingSaveInput(value) {
         baseUrl: input.baseUrl,
     });
     if (!Array.isArray(input.enabledModelIds) ||
-        input.enabledModelIds.length === 0 ||
         input.enabledModelIds.length > CONNECTION_CATALOG_MAX_MODELS_PER_CONNECTION) {
-        throw invalidProtocolFrame('Connection onboarding requires at least one enabled model');
+        throw invalidProtocolFrame('Connection onboarding enabled models exceed the limit');
     }
     const enabledModelIds = input.enabledModelIds.map((modelId) => decodeDomain(() => decodeConnectionModelId(modelId)));
     if (new Set(enabledModelIds).size !== enabledModelIds.length) {
@@ -140,6 +139,7 @@ export function decodeConnectionOnboardingSaveResult(value) {
             rejected.reason !== 'base_url_not_configured' &&
             rejected.reason !== 'catalog_full' &&
             rejected.reason !== 'model_unavailable' &&
+            rejected.reason !== 'slug_taken' &&
             rejected.reason !== 'superseded')) {
         throw invalidProtocolFrame('Invalid connection onboarding save rejection');
     }
@@ -164,13 +164,19 @@ export function decodeConnectionOnboardingVerifyInput(value) {
 function decodeConnectionOnboardingTarget(value) {
     const target = requireRecord(value, 'connection onboarding target');
     if (target.kind === 'create') {
-        const exact = requireExactRecord(target, 'create connection onboarding target', [
-            'kind',
-            'providerType',
-        ]);
+        // slug/name are optional so a surface that accepts the derived identity
+        // can keep talking to any Host vintage; a surface that lets the user name
+        // the connection must tolerate an older Host rejecting the extra fields.
+        const exact = requireShapedRecord(target, 'create connection onboarding target', ['kind', 'providerType'], ['slug', 'name']);
         return {
             kind: 'create',
             providerType: decodeDomain(() => decodeProviderType(exact.providerType)),
+            ...(exact.slug === undefined
+                ? {}
+                : { slug: decodeDomain(() => decodeConnectionSlug(exact.slug)) }),
+            ...(exact.name === undefined
+                ? {}
+                : { name: decodeDomain(() => decodeConnectionName(exact.name)) }),
         };
     }
     if (target.kind === 'existing') {
@@ -216,6 +222,7 @@ export function decodeConnectionOnboardingVerifyResult(value) {
             rejected.reason !== 'connection_not_found' &&
             rejected.reason !== 'credential_not_configured' &&
             rejected.reason !== 'base_url_not_configured' &&
+            rejected.reason !== 'slug_taken' &&
             rejected.reason !== 'catalog_full')) {
         throw invalidProtocolFrame('Invalid connection onboarding rejection');
     }

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

@@ -19,6 +19,7 @@
 import { invalidProtocolFrame } from './errors.js';
 import { requireCount, requireEncodedByteLimit, requireExactRecord, requireId, requireRecord, requireString, requireUtf8String, } from './codec.js';
 import { defineOperation } from './operation-spec.js';
+import { decodeSignedPeerReachabilityLease, } from '../peer-reachability/model.js';
 export function isHostActivityIdle(activity) {
     return (activity.connections === 0 &&
         activity.activeOperations === 0 &&
@@ -27,9 +28,6 @@ export function isHostActivityIdle(activity) {
 export const HOST_DIAGNOSTICS_RESULT_MAX_BYTES = 72 * 1024;
 export const HOST_DIAGNOSTIC_LOG_MAX_ENTRIES = 256;
 export const HOST_DIAGNOSTIC_LOG_MAX_ENTRY_BYTES = 10 * 1024;
-const HOST_PEER_ID_MAX_BYTES = 160;
-const HOST_PEER_ADDRESS_MAX_BYTES = 2 * 1024;
-const HOST_PEER_ROUTE_MAX = 16;
 export const HOST_BOOTSTRAP_OPERATION_SPECS = {
     'host.status': defineOperation({
         mode: 'query',
@@ -53,16 +51,6 @@ export const HOST_BOOTSTRAP_OPERATION_SPECS = {
         decodeOutput: decodeHostUpgradePrepareResult,
     }),
 };
-function decodePeerAddresses(value, label) {
-    if (!Array.isArray(value) || value.length > HOST_PEER_ROUTE_MAX) {
-        throw invalidProtocolFrame(`Invalid ${label}`);
-    }
-    const addresses = value.map((address) => requireString(address, label, HOST_PEER_ADDRESS_MAX_BYTES));
-    if (new Set(addresses).size !== addresses.length) {
-        throw invalidProtocolFrame(`Duplicate ${label}`);
-    }
-    return Object.freeze(addresses);
-}
 function decodeEmptyHostInput(value, label) {
     requireExactRecord(value, label, []);
     return {};
@@ -205,16 +193,12 @@ function decodeHostStatusFields(record) {
     };
 }
 function decodeHostPeerEndpoint(value) {
-    const record = requireExactRecord(value, 'Runtime Host peer endpoint', [
-        'peerId',
-        'routeHints',
-        'coordinationRelays',
-    ]);
-    return {
-        peerId: requireString(record.peerId, 'Runtime Host peer id', HOST_PEER_ID_MAX_BYTES),
-        routeHints: decodePeerAddresses(record.routeHints, 'Runtime Host peer route hints'),
-        coordinationRelays: decodePeerAddresses(record.coordinationRelays, 'Runtime Host peer coordination relays'),
-    };
+    try {
+        return decodeSignedPeerReachabilityLease(value);
+    }
+    catch {
+        throw invalidProtocolFrame('Invalid Runtime Host peer reachability lease');
+    }
 }
 function requirePlatform(value) {
     if (value === 'aix' ||

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

@@ -61,7 +61,53 @@ 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 = 96;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 109;
+// 109: accepted Client Capability invocations may carry one bounded nested form
+// Interaction request/result round trip.
+// 108: Session Interaction snapshots, forwarded Runtime events, and Agent Graph
+// activity may carry the provider-neutral `form` request/answer contract.
+// 107: `token_usage` anchors record the model and connection that produced
+// them. The record decodes against a closed allowlist, so an older client
+// rejects the two new keys and, with them, the Session that carries them.
+// 106: Session transcripts gain five `system_note` kinds
+// (`context_provider_dropping`, `context_window_suggestion`,
+// `context_window_overrun`, `context_reported_window_exceeded`,
+// `context_overflow_after_compaction`) and
+// `token_usage` records reshape `lastRequestAnchor` to
+// `{ inputTokens, outputTokens }`, all behind closed allowlists in
+// @maka/core. An older client that handshakes would fail
+// `decodeStoredMessage` on the first transcript carrying them, so the pair
+// must refuse each other at the handshake instead (#4559).
+// 105: Usage summaries may carry the recorded call-time total and per-Session
+// tool-invocation totals. Older Clients reject the unknown fields, so a newer
+// Host's usage summary is unreadable to them.
+// 104: WorkHub Coordination actions add closed direct-stop proposals,
+// confirmations, expected-state preconditions, and outcomes. Older peers
+// reject these strict shapes.
+// 103: `github-copilot` joins `OAUTH_LOGIN_PROVIDERS`, the Host answers the
+// closed `oauth.enrollment.query`, and `connection.onboarding.save` admits
+// canonical OAuth material with an empty enable-all-discovered selection.
+// Older peers reject these wire values, so incompatible pairs must fail the
+// handshake. Re-derived from current `main`; epoch 102 is claimed by open PRs.
+// 101: Session Turn requests can carry regeneration intents and Guests can
+// atomically withdraw pending requests. Older peers do not share this command
+// vocabulary or the expanded Guest operation grant.
+// 100: `session.branch.create` makes `sourceTurnId` optional, so a side
+// conversation can fork with an empty context (no copied messages, no
+// fabricated `branchOfTurnId`) instead of requiring a settled turn. An older
+// Host's required-field check rejects the request that omits `sourceTurnId`;
+// the handshake keeps mixed-version peers apart. `session.revision.create`
+// still requires `sourceTurnId`, and its wire shape and fingerprint are
+// unchanged.
+// 99: ScheduledTask Agent execution templates carry immutable Connection
+// identity. Older peers cannot preserve the ID/slug/model binding and could
+// silently route a deleted Connection to a same-slug replacement.
+// 98: Peer Mesh invitations carry signed reachability leases and member route
+// projections use the convergent recovery state machine. Older peers decode a
+// different strict wire shape.
+// 97: Host status replaces unsigned route arrays with a self-signed, bounded
+// reachability lease. Older peers cannot validate the locator revision or its
+// target identity before retaining it for reconnect.
 // 96: Read image tool results may carry durable `session_context` refs.
 // 95: Catalog entries carry `describedByMetadata`, so a client asks the
 // Host-resolved entry — not its own bundled table — whether a model needs a