@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/runtime/remote/distributed-runtime-work.js

@@ -0,0 +1,257 @@
+import { randomUUID } from 'node:crypto';
+import { buildAudit, sanitizePeer, sortWork, summarizeValue, } from './distributed-runtime-utils.js';
+import { persistDistributedRuntime, pruneAndPersistDistributedRuntime, publishDistributedRuntimeEvent, recordDistributedRuntimeAudit, resolveDistributedRuntimeWaiters, startDistributedRuntime, waitForDistributedWork, } from './distributed-runtime-store.js';
+export async function enqueueDistributedWork(state, input) {
+    await startDistributedRuntime(state);
+    const peer = state.peers.get(input.peerId);
+    if (!peer)
+        throw new Error(`Unknown distributed peer: ${input.peerId}`);
+    const now = Date.now();
+    const work = {
+        id: `rwork-${randomUUID().slice(0, 8)}`,
+        peerId: peer.id,
+        peerKind: peer.kind,
+        type: input.type ?? 'invoke',
+        command: input.command.trim() || 'invoke',
+        priority: input.priority ?? 'normal',
+        status: 'queued',
+        payload: input.payload,
+        createdAt: now,
+        updatedAt: now,
+        queuedBy: input.actor ?? 'operator',
+        timeoutMs: input.timeoutMs,
+        sessionId: input.sessionId,
+        routeId: input.routeId,
+        automationRunId: input.automationRunId,
+        automationJobId: input.automationJobId,
+        approvalId: input.approvalId,
+        metadata: input.metadata ?? {},
+    };
+    state.work.set(work.id, work);
+    recordDistributedRuntimeAudit(state, buildAudit('work-queued', input.actor ?? 'operator', {
+        peerId: peer.id,
+        workId: work.id,
+        note: `${work.command} -> ${peer.label}`,
+    }));
+    await bridgeQueuedDistributedWork(state, peer, work);
+    await pruneAndPersistDistributedRuntime(state);
+    publishDistributedRuntimeEvent(state, 'remote-work-queued', {
+        peer: sanitizePeer(peer),
+        work,
+    });
+    return work;
+}
+export async function invokeDistributedPeer(state, input) {
+    const work = await enqueueDistributedWork(state, {
+        peerId: input.peerId,
+        command: input.command,
+        payload: input.payload,
+        priority: input.priority,
+        actor: input.actor,
+        timeoutMs: input.timeoutMs,
+        sessionId: input.sessionId,
+        routeId: input.routeId,
+        automationRunId: input.automationRunId,
+        automationJobId: input.automationJobId,
+        approvalId: input.approvalId,
+        metadata: input.metadata,
+    });
+    if (!input.waitMs || input.waitMs <= 0) {
+        return { work, completed: false };
+    }
+    const settled = await waitForDistributedWork(state, work.id, input.waitMs);
+    return {
+        work: settled ?? work,
+        completed: Boolean(settled && settled.status !== 'queued' && settled.status !== 'claimed'),
+    };
+}
+export async function claimDistributedWork(state, auth, input = {}) {
+    await startDistributedRuntime(state);
+    const peer = state.peers.get(auth.peer.id);
+    if (!peer)
+        return [];
+    const maxItems = Math.min(10, Math.max(1, Math.trunc(input.maxItems ?? 4)));
+    const leaseMs = Math.max(5_000, Math.trunc(input.leaseMs ?? 45_000));
+    const queued = sortWork(state.work.values())
+        .filter((item) => item.peerId === peer.id && item.status === 'queued')
+        .slice(0, maxItems);
+    const now = Date.now();
+    const claimed = [];
+    for (const item of queued) {
+        const next = {
+            ...item,
+            status: 'claimed',
+            claimTokenId: auth.token.id,
+            claimedAt: now,
+            leaseExpiresAt: now + leaseMs,
+            updatedAt: now,
+        };
+        state.work.set(item.id, next);
+        claimed.push(next);
+        recordDistributedRuntimeAudit(state, buildAudit('work-claimed', peer.id, {
+            peerId: peer.id,
+            workId: item.id,
+            note: item.command,
+        }));
+    }
+    await pruneAndPersistDistributedRuntime(state);
+    if (claimed.length > 0) {
+        publishDistributedRuntimeEvent(state, 'remote-work-claimed', {
+            peer: sanitizePeer(state.peers.get(peer.id)),
+            workIds: claimed.map((item) => item.id),
+        });
+    }
+    return claimed;
+}
+export async function completeDistributedWork(state, auth, workId, input = {}) {
+    await startDistributedRuntime(state);
+    const current = state.work.get(workId);
+    if (!current || current.peerId !== auth.peer.id)
+        return null;
+    if (current.claimTokenId && current.claimTokenId !== auth.token.id)
+        return null;
+    const status = input.status ?? (input.error ? 'failed' : 'completed');
+    const updated = {
+        ...current,
+        status,
+        result: input.result,
+        error: input.error,
+        telemetry: input.telemetry,
+        completedAt: Date.now(),
+        updatedAt: Date.now(),
+        leaseExpiresAt: undefined,
+        metadata: {
+            ...current.metadata,
+            ...(input.metadata ?? {}),
+        },
+    };
+    state.work.set(workId, updated);
+    const peer = state.peers.get(auth.peer.id);
+    if (peer) {
+        state.peers.set(peer.id, {
+            ...peer,
+            status: 'connected',
+            lastSeenAt: Date.now(),
+            lastConnectedAt: Date.now(),
+        });
+    }
+    const actor = auth.peer.id;
+    recordDistributedRuntimeAudit(state, buildAudit(status === 'completed' ? 'work-completed' : status === 'failed' ? 'work-failed' : 'work-cancelled', actor, {
+        peerId: auth.peer.id,
+        workId,
+        note: status === 'completed' ? summarizeValue(input.result) || 'no result' : (input.error ?? status),
+    }));
+    await bridgeCompletedDistributedWork(state, state.peers.get(auth.peer.id) ?? ensurePlaceholderPeer(state, auth.peer.id, current.peerKind), updated);
+    await pruneAndPersistDistributedRuntime(state);
+    publishDistributedRuntimeEvent(state, 'remote-work-settled', {
+        peer: sanitizePeer(state.peers.get(auth.peer.id)),
+        work: updated,
+    });
+    resolveDistributedRuntimeWaiters(state, updated);
+    return updated;
+}
+export async function cancelDistributedWork(state, workId, input = {}) {
+    await startDistributedRuntime(state);
+    const current = state.work.get(workId);
+    if (!current)
+        return null;
+    if (current.status === 'completed' || current.status === 'failed' || current.status === 'cancelled') {
+        return current;
+    }
+    const updated = {
+        ...current,
+        status: 'cancelled',
+        error: input.reason ?? current.error ?? 'operator-cancelled',
+        completedAt: Date.now(),
+        updatedAt: Date.now(),
+        leaseExpiresAt: undefined,
+    };
+    state.work.set(workId, updated);
+    recordDistributedRuntimeAudit(state, buildAudit('work-cancelled', input.actor ?? 'operator', {
+        peerId: updated.peerId,
+        workId,
+        note: updated.error,
+    }));
+    await bridgeCompletedDistributedWork(state, state.peers.get(updated.peerId) ?? ensurePlaceholderPeer(state, updated.peerId, updated.peerKind), updated);
+    await pruneAndPersistDistributedRuntime(state);
+    publishDistributedRuntimeEvent(state, 'remote-work-cancelled', updated);
+    resolveDistributedRuntimeWaiters(state, updated);
+    return updated;
+}
+async function bridgeQueuedDistributedWork(state, peer, work) {
+    if (work.sessionId && state.sessionBridge) {
+        await state.sessionBridge.appendSystemMessage(work.sessionId, `Queued remote ${peer.kind} work on ${peer.label}: ${work.command}`, {
+            remotePeerId: peer.id,
+            remotePeerKind: peer.kind,
+            remoteWorkId: work.id,
+            remoteWorkStatus: work.status,
+            automationRunId: work.automationRunId,
+            approvalId: work.approvalId,
+        });
+    }
+}
+async function bridgeCompletedDistributedWork(state, peer, work) {
+    const statusLabel = work.status === 'completed'
+        ? 'completed'
+        : work.status === 'failed'
+            ? 'failed'
+            : 'cancelled';
+    const summary = work.status === 'completed'
+        ? summarizeValue(work.result) || 'no result'
+        : (work.error ?? statusLabel);
+    if (work.sessionId && state.sessionBridge) {
+        await state.sessionBridge.appendSystemMessage(work.sessionId, `Remote ${peer.kind} ${peer.label} ${statusLabel}: ${work.command}${summary ? `\n${summary}` : ''}`, {
+            remotePeerId: peer.id,
+            remotePeerKind: peer.kind,
+            remoteWorkId: work.id,
+            remoteWorkStatus: work.status,
+            automationRunId: work.automationRunId,
+            approvalId: work.approvalId,
+        });
+    }
+    if (work.approvalId && state.approvalBridge) {
+        await state.approvalBridge.recordRemoteUpdate(work.approvalId, {
+            actor: peer.id,
+            actorSurface: 'service',
+            note: `Remote ${peer.kind} ${peer.label} ${statusLabel}: ${work.command}`,
+            metadata: {
+                remotePeerId: peer.id,
+                remoteWorkId: work.id,
+                remoteWorkStatus: work.status,
+            },
+        });
+    }
+    if (work.automationRunId && state.automationBridge) {
+        await state.automationBridge.recordExternalRunResult(work.automationRunId, {
+            status: work.status === 'completed' ? 'completed' : work.status === 'failed' ? 'failed' : 'cancelled',
+            result: work.result,
+            error: work.error,
+            telemetry: work.telemetry,
+            metadata: {
+                remotePeerId: peer.id,
+                remoteWorkId: work.id,
+                remotePeerKind: peer.kind,
+            },
+        });
+    }
+}
+function ensurePlaceholderPeer(state, peerId, kind) {
+    const existing = state.peers.get(peerId);
+    if (existing)
+        return existing;
+    const peer = {
+        id: peerId,
+        kind,
+        label: peerId,
+        requestedId: peerId,
+        capabilities: [],
+        commands: [],
+        permissions: undefined,
+        status: 'idle',
+        pairedAt: Date.now(),
+        tokens: [],
+        metadata: {},
+    };
+    state.peers.set(peer.id, peer);
+    return peer;
+}

package/dist/_internal/platform/runtime/remote/distributed-runtime.d.ts

@@ -0,0 +1,4 @@
+export type { DistributedPeerKind, DistributedPairRequestStatus, DistributedPeerStatus, DistributedWorkPriority, DistributedWorkStatus, DistributedWorkType, DistributedSessionBridge, DistributedApprovalBridge, DistributedAutomationBridge, DistributedRuntimePairRequest, DistributedPeerTokenRecord, DistributedPeerRecord, DistributedPendingWork, DistributedRuntimeAuditRecord, DistributedRuntimeSnapshotStore, DistributedPeerAuth, DistributedNodeHostContract, } from './distributed-runtime-types.js';
+export { getDistributedNodeHostContract, } from './distributed-runtime-contract.js';
+export { DistributedRuntimeManager, } from './distributed-runtime-manager.js';
+//# sourceMappingURL=distributed-runtime.d.ts.map

package/dist/_internal/platform/runtime/remote/distributed-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributed-runtime.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/remote/distributed-runtime.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,4BAA4B,EAC5B,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,2BAA2B,EAC3B,6BAA6B,EAC7B,0BAA0B,EAC1B,qBAAqB,EACrB,sBAAsB,EACtB,6BAA6B,EAC7B,+BAA+B,EAC/B,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,gCAAgC,CAAC;AAExC,OAAO,EACL,8BAA8B,GAC/B,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EACL,yBAAyB,GAC1B,MAAM,kCAAkC,CAAC"}

package/dist/_internal/platform/runtime/remote/distributed-runtime.js

@@ -0,0 +1,2 @@
+export { getDistributedNodeHostContract, } from './distributed-runtime-contract.js';
+export { DistributedRuntimeManager, } from './distributed-runtime-manager.js';

package/dist/_internal/platform/runtime/remote/heartbeat.d.ts

@@ -0,0 +1,10 @@
+import type { AcpConnection } from '../store/domains/acp.js';
+import type { RemoteRunnerContract } from './types.js';
+export interface RemoteHeartbeatSnapshot {
+    readonly status: 'fresh' | 'stale' | 'offline';
+    readonly lastSeenAt?: number;
+    readonly ageMs?: number;
+    readonly detail: string;
+}
+export declare function deriveRemoteHeartbeat(connection?: AcpConnection | null, contract?: RemoteRunnerContract | null): RemoteHeartbeatSnapshot;
+//# sourceMappingURL=heartbeat.d.ts.map

package/dist/_internal/platform/runtime/remote/heartbeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/remote/heartbeat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,qBAAqB,CACnC,UAAU,CAAC,EAAE,aAAa,GAAG,IAAI,EACjC,QAAQ,CAAC,EAAE,oBAAoB,GAAG,IAAI,GACrC,uBAAuB,CA+BzB"}

package/dist/_internal/platform/runtime/remote/heartbeat.js

@@ -0,0 +1,32 @@
+export function deriveRemoteHeartbeat(connection, contract) {
+    const lastSeenAt = connection?.connectedAt ?? contract?.transport.connectedAt;
+    if (!lastSeenAt) {
+        return {
+            status: 'offline',
+            detail: 'No heartbeat has been observed yet.',
+        };
+    }
+    const ageMs = Math.max(0, Date.now() - lastSeenAt);
+    if (connection?.transportState === 'terminal_failure' || connection?.transportState === 'disconnected') {
+        return {
+            status: 'offline',
+            lastSeenAt,
+            ageMs,
+            detail: 'Transport is offline and requires reattach or redispatch.',
+        };
+    }
+    if (ageMs > 5 * 60_000) {
+        return {
+            status: 'stale',
+            lastSeenAt,
+            ageMs,
+            detail: 'Heartbeat is stale; remote recovery should be reviewed.',
+        };
+    }
+    return {
+        status: 'fresh',
+        lastSeenAt,
+        ageMs,
+        detail: 'Heartbeat is within the healthy freshness window.',
+    };
+}

package/dist/_internal/platform/runtime/remote/identity.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Remote Substrate — Durable Identity Manager
+ *
+ * Implements globally unique, stable identifiers for
+ * sessionId, taskId, and agentId that survive transport changes and reconnects.
+ *
+ * The identity manager maintains the canonical set of IDs for a remote
+ * substrate instance. Reconnects do not change these IDs — only explicit
+ * refresh calls (for new tasks) increment the generation counter.
+ */
+import type { DurableIdentity } from './types.js';
+/** Serializable snapshot for persistence across process restarts. */
+export interface IdentitySnapshot {
+    readonly sessionId: string;
+    readonly taskId: string;
+    readonly agentId: string;
+    readonly createdAt: number;
+    readonly generation: number;
+}
+/**
+ * DurableIdentityManager — creates and maintains stable IDs across reconnects.
+ *
+ * Once created, the sessionId is permanent for the lifetime of this manager.
+ * The taskId and agentId can be refreshed (incrementing generation) when
+ * starting a new remote task, but remain stable across reconnects within
+ * the same task.
+ *
+ * @example
+ * ```ts
+ * const identity = new DurableIdentityManager();
+ * // sessionId/taskId/agentId are stable — safe to pass across reconnects
+ * const { sessionId, taskId } = identity.current;
+ *
+ * // After reconnect — same IDs
+ * await reconnect();
+ * identity.current.sessionId === sessionId; // true
+ *
+ * // Starting a new task — refresh task/agent IDs
+ * identity.refreshTaskIdentity();
+ * identity.current.taskId !== taskId; // true
+ * ```
+ */
+export declare class DurableIdentityManager {
+    private _current;
+    constructor(snapshot?: IdentitySnapshot);
+    /**
+     * The current durable identity snapshot.
+     *
+     * This reference is stable across reconnects — the same object is returned
+     * until `refreshTaskIdentity()` is called.
+     */
+    get current(): DurableIdentity;
+    /**
+     * Refresh the task and agent identifiers for a new remote task.
+     *
+     * The sessionId is preserved. The generation counter increments.
+     * Call this when starting a new task on the remote substrate —
+     * not when reconnecting to an existing task.
+     *
+     * @returns The new durable identity.
+     */
+    refreshTaskIdentity(): DurableIdentity;
+    /**
+     * Serialize the current identity for persistence.
+     *
+     * Store the snapshot and pass it to the constructor on restart to
+     * restore identity continuity across process restarts.
+     *
+     * @returns A plain-object snapshot safe for JSON serialization.
+     */
+    toSnapshot(): IdentitySnapshot;
+    /**
+     * Restore identity from a plain snapshot object.
+     *
+     * Use this when rehydrating a remote substrate after a process restart.
+     * This is equivalent to constructing with a snapshot but can be called
+     * on an existing instance.
+     *
+     * @param snapshot - Previously serialized identity snapshot.
+     */
+    restoreFromSnapshot(snapshot: IdentitySnapshot): void;
+}
+//# sourceMappingURL=identity.d.ts.map

package/dist/_internal/platform/runtime/remote/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/remote/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,qEAAqE;AACrE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAkB;gBAEtB,QAAQ,CAAC,EAAE,gBAAgB;IA2BvC;;;;;OAKG;IACH,IAAI,OAAO,IAAI,eAAe,CAE7B;IAED;;;;;;;;OAQG;IACH,mBAAmB,IAAI,eAAe;IAgBtC;;;;;;;OAOG;IACH,UAAU,IAAI,gBAAgB;IAU9B;;;;;;;;OAQG;IACH,mBAAmB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;CAatD"}

package/dist/_internal/platform/runtime/remote/identity.js

@@ -0,0 +1,137 @@
+/**
+ * Remote Substrate — Durable Identity Manager
+ *
+ * Implements globally unique, stable identifiers for
+ * sessionId, taskId, and agentId that survive transport changes and reconnects.
+ *
+ * The identity manager maintains the canonical set of IDs for a remote
+ * substrate instance. Reconnects do not change these IDs — only explicit
+ * refresh calls (for new tasks) increment the generation counter.
+ */
+import { randomUUID } from 'node:crypto';
+import { logger } from '../../utils/logger.js';
+/**
+ * DurableIdentityManager — creates and maintains stable IDs across reconnects.
+ *
+ * Once created, the sessionId is permanent for the lifetime of this manager.
+ * The taskId and agentId can be refreshed (incrementing generation) when
+ * starting a new remote task, but remain stable across reconnects within
+ * the same task.
+ *
+ * @example
+ * ```ts
+ * const identity = new DurableIdentityManager();
+ * // sessionId/taskId/agentId are stable — safe to pass across reconnects
+ * const { sessionId, taskId } = identity.current;
+ *
+ * // After reconnect — same IDs
+ * await reconnect();
+ * identity.current.sessionId === sessionId; // true
+ *
+ * // Starting a new task — refresh task/agent IDs
+ * identity.refreshTaskIdentity();
+ * identity.current.taskId !== taskId; // true
+ * ```
+ */
+export class DurableIdentityManager {
+    _current;
+    constructor(snapshot) {
+        if (snapshot) {
+            this._current = Object.freeze({
+                sessionId: snapshot.sessionId,
+                taskId: snapshot.taskId,
+                agentId: snapshot.agentId,
+                createdAt: snapshot.createdAt,
+                generation: snapshot.generation,
+            });
+            logger.debug('DurableIdentityManager: restored from snapshot', {
+                sessionId: snapshot.sessionId,
+                generation: snapshot.generation,
+            });
+        }
+        else {
+            this._current = Object.freeze({
+                sessionId: randomUUID(),
+                taskId: randomUUID(),
+                agentId: randomUUID(),
+                createdAt: Date.now(),
+                generation: 1,
+            });
+            logger.debug('DurableIdentityManager: created new identity', {
+                sessionId: this._current.sessionId,
+            });
+        }
+    }
+    /**
+     * The current durable identity snapshot.
+     *
+     * This reference is stable across reconnects — the same object is returned
+     * until `refreshTaskIdentity()` is called.
+     */
+    get current() {
+        return this._current;
+    }
+    /**
+     * Refresh the task and agent identifiers for a new remote task.
+     *
+     * The sessionId is preserved. The generation counter increments.
+     * Call this when starting a new task on the remote substrate —
+     * not when reconnecting to an existing task.
+     *
+     * @returns The new durable identity.
+     */
+    refreshTaskIdentity() {
+        const prev = this._current;
+        this._current = Object.freeze({
+            sessionId: prev.sessionId,
+            taskId: randomUUID(),
+            agentId: randomUUID(),
+            createdAt: prev.createdAt,
+            generation: prev.generation + 1,
+        });
+        logger.debug('DurableIdentityManager: task identity refreshed', {
+            sessionId: this._current.sessionId,
+            generation: this._current.generation,
+        });
+        return this._current;
+    }
+    /**
+     * Serialize the current identity for persistence.
+     *
+     * Store the snapshot and pass it to the constructor on restart to
+     * restore identity continuity across process restarts.
+     *
+     * @returns A plain-object snapshot safe for JSON serialization.
+     */
+    toSnapshot() {
+        return {
+            sessionId: this._current.sessionId,
+            taskId: this._current.taskId,
+            agentId: this._current.agentId,
+            createdAt: this._current.createdAt,
+            generation: this._current.generation,
+        };
+    }
+    /**
+     * Restore identity from a plain snapshot object.
+     *
+     * Use this when rehydrating a remote substrate after a process restart.
+     * This is equivalent to constructing with a snapshot but can be called
+     * on an existing instance.
+     *
+     * @param snapshot - Previously serialized identity snapshot.
+     */
+    restoreFromSnapshot(snapshot) {
+        this._current = Object.freeze({
+            sessionId: snapshot.sessionId,
+            taskId: snapshot.taskId,
+            agentId: snapshot.agentId,
+            createdAt: snapshot.createdAt,
+            generation: snapshot.generation,
+        });
+        logger.debug('DurableIdentityManager: identity restored from snapshot', {
+            sessionId: snapshot.sessionId,
+            generation: snapshot.generation,
+        });
+    }
+}

package/dist/_internal/platform/runtime/remote/negotiation.d.ts

@@ -0,0 +1,12 @@
+import type { AcpConnection } from '../store/domains/acp.js';
+import type { RemoteRunnerContract } from './types.js';
+export interface RemoteNegotiationSnapshot {
+    readonly transport: 'acp' | 'daemon';
+    readonly executionProtocol: 'direct' | 'gather-plan-apply';
+    readonly reviewMode: 'none' | 'wrfc';
+    readonly communicationLane: 'parent-only' | 'parent-and-children' | 'cohort' | 'direct';
+    readonly trustClass: string;
+    readonly detail: string;
+}
+export declare function deriveRemoteNegotiation(contract?: RemoteRunnerContract | null, connection?: AcpConnection | null): RemoteNegotiationSnapshot;
+//# sourceMappingURL=negotiation.d.ts.map

package/dist/_internal/platform/runtime/remote/negotiation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/remote/negotiation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,KAAK,GAAG,QAAQ,CAAC;IACrC,QAAQ,CAAC,iBAAiB,EAAE,QAAQ,GAAG,mBAAmB,CAAC;IAC3D,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IACrC,QAAQ,CAAC,iBAAiB,EAAE,aAAa,GAAG,qBAAqB,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACxF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,CAAC,EAAE,oBAAoB,GAAG,IAAI,EACtC,UAAU,CAAC,EAAE,aAAa,GAAG,IAAI,GAChC,yBAAyB,CAqB3B"}

package/dist/_internal/platform/runtime/remote/negotiation.js

@@ -0,0 +1,22 @@
+export function deriveRemoteNegotiation(contract, connection) {
+    if (!contract) {
+        return {
+            transport: 'acp',
+            executionProtocol: 'direct',
+            reviewMode: 'none',
+            communicationLane: 'direct',
+            trustClass: connection ? 'connection-only' : 'unknown',
+            detail: connection
+                ? 'Transport is active but no runner contract has been registered yet.'
+                : 'No remote contract or connection is available.',
+        };
+    }
+    return {
+        transport: contract.sourceTransport,
+        executionProtocol: contract.capabilityCeiling.executionProtocol,
+        reviewMode: contract.capabilityCeiling.reviewMode,
+        communicationLane: contract.capabilityCeiling.communicationLane,
+        trustClass: contract.trustClass,
+        detail: `${contract.template} runner negotiated ${contract.capabilityCeiling.executionProtocol}/${contract.capabilityCeiling.reviewMode} on ${contract.sourceTransport}.`,
+    };
+}