@timurproko/a1 0.1.8-dev.472 → 0.1.8-dev.508

package/dist/foundation/native-host-protocol/messages.js

@@ -1,149 +0,0 @@
-import { NATIVE_HOST_PROTOCOL_VERSION, assertNativeHostCommand, assertTerminalSessionLaunch, } from "../../contracts/workspace/index.js";
-import { PRODUCT_IDENTITY } from "../../product-identity.js";
-export const NATIVE_HOST_PROTOCOL_NAME = PRODUCT_IDENTITY.protocol.nativeHostSchema;
-export const MAX_NATIVE_HOST_MESSAGE_BYTES = 1024 * 1024;
-export function negotiateNativeHostHello(value) {
-    if (value.protocolVersion !== NATIVE_HOST_PROTOCOL_VERSION) {
-        return negotiation(false, [], `unsupported native-host protocol version ${value.protocolVersion}`);
-    }
-    if (!isText(value.hostInstanceId, 128) || !isText(value.buildId, 256)) {
-        return negotiation(false, [], "native host instance and build identities must be bounded non-empty values");
-    }
-    if (!["windows", "macos", "linux"].includes(value.platform)) {
-        return negotiation(false, [], `unsupported native-host platform ${String(value.platform)}`);
-    }
-    const required = ["exact-command", "revisioned-topology", "native-input", "native-rendering", "retained-terminal-state"];
-    const capabilities = new Set(value.capabilities);
-    const missing = required.filter(capability => !capabilities.has(capability));
-    if (missing.length > 0)
-        return negotiation(false, [...capabilities].sort(), `native host lacks required capabilities: ${missing.join(", ")}`);
-    return negotiation(true, [...capabilities].sort(), "native host handshake accepted");
-}
-export function createFixedTwoByTwoCommand(input) {
-    if (input.panes.length !== 4)
-        throw new RangeError("fixed 2x2 proof requires exactly four panes");
-    const paneIds = new Set();
-    const sessions = [];
-    for (const pane of input.panes) {
-        if (paneIds.has(pane.paneId))
-            throw new TypeError(`duplicate proof pane id: ${pane.paneId}`);
-        paneIds.add(pane.paneId);
-        assertTerminalSessionLaunch(pane.session);
-        sessions.push(pane.session);
-    }
-    const [topLeft, topRight, bottomLeft, bottomRight] = input.panes;
-    const topology = {
-        hostInstanceId: input.hostInstanceId,
-        revision: input.expectedRevision,
-        windows: [{
-                id: input.windowId,
-                activeTabId: input.tabId,
-                tabs: [{
-                        id: input.tabId,
-                        rootNodeId: "root",
-                        focusedPaneId: topLeft.paneId,
-                        panes: input.panes.map(pane => ({ id: pane.paneId, sessionId: pane.session.id })),
-                        nodes: [
-                            { id: "root", kind: "split", axis: "horizontal", ratio: 0.5, first: "top", second: "bottom" },
-                            { id: "top", kind: "split", axis: "vertical", ratio: 0.5, first: "leaf-top-left", second: "leaf-top-right" },
-                            { id: "bottom", kind: "split", axis: "vertical", ratio: 0.5, first: "leaf-bottom-left", second: "leaf-bottom-right" },
-                            { id: "leaf-top-left", kind: "leaf", paneId: topLeft.paneId },
-                            { id: "leaf-top-right", kind: "leaf", paneId: topRight.paneId },
-                            { id: "leaf-bottom-left", kind: "leaf", paneId: bottomLeft.paneId },
-                            { id: "leaf-bottom-right", kind: "leaf", paneId: bottomRight.paneId },
-                        ],
-                    }],
-            }],
-        sessions,
-    };
-    const command = {
-        type: "apply-topology",
-        correlationId: input.correlationId,
-        expectedRevision: input.expectedRevision,
-        topology,
-    };
-    assertNativeHostCommand(command);
-    return command;
-}
-export function nativeHostCommandResult(correlationId, revision) {
-    return { type: "command-result", correlationId, accepted: true, revision, failure: null };
-}
-export function nativeHostFailure(code, message, retryable = false) {
-    if (!isText(code, 128) || !isText(message, 4_096))
-        throw new TypeError("native-host failure outcome is invalid");
-    return Object.freeze({ code, message, retryable });
-}
-export function nativeHostTimedOut(deadlineAt, now) {
-    if (!Number.isSafeInteger(deadlineAt) || deadlineAt < 0 || !Number.isSafeInteger(now) || now < 0) {
-        throw new RangeError("native-host deadline and clock must be non-negative safe integers");
-    }
-    return now >= deadlineAt;
-}
-export function assertNativeHostProofMessage(message) {
-    switch (message.type) {
-        case "hello": {
-            const result = negotiateNativeHostHello(message.hello);
-            if (!result.accepted)
-                throw new TypeError(result.diagnostic);
-            return;
-        }
-        case "hello-result":
-            if (typeof message.accepted !== "boolean" || !Array.isArray(message.negotiatedCapabilities) || !isText(message.diagnostic, 4_096)) {
-                throw new TypeError("native-host hello result is invalid");
-            }
-            return;
-        case "command":
-            assertNativeHostCommand(message.command);
-            return;
-        case "command-result":
-            if (!isText(message.correlationId, 128) || typeof message.accepted !== "boolean")
-                throw new TypeError("native-host command result is invalid");
-            if (message.revision !== null && (!Number.isSafeInteger(message.revision) || message.revision < 0))
-                throw new RangeError("native-host result revision is invalid");
-            if (message.accepted && message.failure !== null)
-                throw new TypeError("accepted native-host result cannot carry a failure");
-            if (!message.accepted && message.failure === null)
-                throw new TypeError("rejected native-host result requires a failure");
-            if (message.failure !== null)
-                assertFailure(message.failure);
-            return;
-        case "event":
-            assertNativeHostEvent(message.event);
-            return;
-        case "error":
-            assertFailure(message.failure);
-    }
-}
-function assertNativeHostEvent(event) {
-    switch (event.type) {
-        case "topology-changed":
-            assertNativeHostCommand({ type: "apply-topology", correlationId: "topology-validation", expectedRevision: event.topology.revision, topology: event.topology });
-            return;
-        case "pane-ready":
-            if (!isText(event.paneId, 128) || !isText(event.sessionId, 128))
-                throw new TypeError("pane-ready event is invalid");
-            return;
-        case "process-exited":
-            if (!isText(event.paneId, 128) || !isText(event.sessionId, 128))
-                throw new TypeError("process-exited event is invalid");
-            if (event.exitCode !== null && (!Number.isSafeInteger(event.exitCode) || event.exitCode < 0))
-                throw new RangeError("process exit code is invalid");
-            if (event.signal !== null && !isText(event.signal, 64))
-                throw new TypeError("process exit signal is invalid");
-            return;
-        case "host-degraded":
-            if (!isText(event.code, 128) || !isText(event.message, 4_096))
-                throw new TypeError("host-degraded event is invalid");
-    }
-}
-function assertFailure(failure) {
-    if (!isText(failure.code, 128) || !isText(failure.message, 4_096) || typeof failure.retryable !== "boolean") {
-        throw new TypeError("native-host failure outcome is invalid");
-    }
-}
-function negotiation(accepted, negotiatedCapabilities, diagnostic) {
-    return Object.freeze({ accepted, negotiatedCapabilities: Object.freeze(negotiatedCapabilities), diagnostic });
-}
-function isText(value, maximum) {
-    return typeof value === "string" && value.length > 0 && value.length <= maximum && !value.includes("\0");
-}

package/dist/foundation/native-host-protocol/proof-gate.d.ts

@@ -1,13 +0,0 @@
-import { type NativeSpikeEvidence } from "./evidence.js";
-export declare const NATIVE_SPIKE_ACCEPTANCE_LIMITS: Readonly<{
-    inputToProcessP95Ms: 16;
-    outputToPresentP95Ms: 33;
-    missedFrames: 0;
-    resizePaintGaps: 0;
-}>;
-export interface NativeSpikeGateDecision {
-    readonly decision: "go" | "stop";
-    readonly integrationAllowed: boolean;
-    readonly reasons: readonly string[];
-}
-export declare function evaluateNativeSpikeGate(evidence: NativeSpikeEvidence): NativeSpikeGateDecision;

package/dist/foundation/native-host-protocol/proof-gate.js

@@ -1,33 +0,0 @@
-import { assertNativeSpikeEvidence } from "./evidence.js";
-export const NATIVE_SPIKE_ACCEPTANCE_LIMITS = Object.freeze({
-    inputToProcessP95Ms: 16,
-    outputToPresentP95Ms: 33,
-    missedFrames: 0,
-    resizePaintGaps: 0,
-});
-export function evaluateNativeSpikeGate(evidence) {
-    assertNativeSpikeEvidence(evidence);
-    const reasons = [];
-    if (evidence.summary.technical !== "passed")
-        reasons.push(`technical proof is ${evidence.summary.technical}`);
-    if (evidence.physical.verdict !== "accepted")
-        reasons.push(`physical verdict is ${evidence.physical.verdict}`);
-    if (evidence.physical.method === "not-run")
-        reasons.push("manual or isolated-worker physical evidence has not run");
-    if (evidence.summary.overall !== "accepted")
-        reasons.push(`overall proof summary is ${evidence.summary.overall}`);
-    if (evidence.latency.inputToProcessMs.p95 > NATIVE_SPIKE_ACCEPTANCE_LIMITS.inputToProcessP95Ms) {
-        reasons.push(`input p95 exceeds ${NATIVE_SPIKE_ACCEPTANCE_LIMITS.inputToProcessP95Ms} ms`);
-    }
-    if (evidence.latency.outputToPresentMs.p95 > NATIVE_SPIKE_ACCEPTANCE_LIMITS.outputToPresentP95Ms) {
-        reasons.push(`output presentation p95 exceeds ${NATIVE_SPIKE_ACCEPTANCE_LIMITS.outputToPresentP95Ms} ms`);
-    }
-    if (evidence.paint.missedFrames > NATIVE_SPIKE_ACCEPTANCE_LIMITS.missedFrames)
-        reasons.push("missed frames are present");
-    if (evidence.paint.resizePaintGaps > NATIVE_SPIKE_ACCEPTANCE_LIMITS.resizePaintGaps)
-        reasons.push("resize paint gaps are present");
-    if (reasons.length > 0) {
-        return Object.freeze({ decision: "stop", integrationAllowed: false, reasons: Object.freeze(reasons) });
-    }
-    return Object.freeze({ decision: "go", integrationAllowed: true, reasons: Object.freeze(["technical and physical proof accepted"]) });
-}

package/dist/foundation/structured-agent-runtime/backpressure.d.ts

@@ -1,47 +0,0 @@
-import { type StructuredCapabilityContract } from "../../contracts/workspace/index.js";
-export type StructuredBackpressureResource = "events" | "commands" | "snapshots" | "attachments" | "reconnect-replay";
-export type StructuredBackpressureAction = "none" | "reject-payload" | "pause-adapter" | "reject-request" | "disconnect-adapter";
-export interface StructuredResourceLease {
-    readonly id: string;
-    readonly resource: StructuredBackpressureResource;
-    readonly units: number;
-    readonly bytes: number;
-}
-export interface StructuredResourceUsage {
-    readonly resource: StructuredBackpressureResource;
-    readonly units: number;
-    readonly bytes: number;
-    readonly unitLimit: number;
-    readonly byteLimit: number;
-}
-export type StructuredBackpressureAcquireResult = {
-    readonly kind: "accepted";
-    readonly lease: StructuredResourceLease;
-    readonly usage: StructuredResourceUsage;
-} | {
-    readonly kind: "rejected";
-    readonly code: "invalid-request" | "payload-too-large" | "resource-exhausted" | "replay-exhausted";
-    readonly action: Exclude<StructuredBackpressureAction, "none">;
-    readonly usage: StructuredResourceUsage;
-    readonly diagnostic: string;
-};
-export type StructuredBackpressureReleaseResult = {
-    readonly kind: "released";
-    readonly usage: StructuredResourceUsage;
-} | {
-    readonly kind: "rejected";
-    readonly code: "unknown-lease" | "invalid-request";
-    readonly diagnostic: string;
-};
-/** Issues bounded resource leases and selects the negotiated backpressure action on exhaustion. */
-export declare class StructuredBackpressureController {
-    #private;
-    readonly adapterId: string;
-    constructor(adapterId: string, capability: StructuredCapabilityContract);
-    acquire(resource: StructuredBackpressureResource, units?: number, bytes?: number): StructuredBackpressureAcquireResult;
-    release(lease: StructuredResourceLease): StructuredBackpressureReleaseResult;
-    resetReconnectReplay(): void;
-    usage(resource: StructuredBackpressureResource): StructuredResourceUsage;
-    leaseCount(): number;
-    replayExhausted(): boolean;
-}

package/dist/foundation/structured-agent-runtime/backpressure.js

@@ -1,119 +0,0 @@
-import { assertStructuredCapability, } from "../../contracts/workspace/index.js";
-/** Issues bounded resource leases and selects the negotiated backpressure action on exhaustion. */
-export class StructuredBackpressureController {
-    adapterId;
-    #budgets;
-    #usage = {
-        events: { units: 0, bytes: 0 },
-        commands: { units: 0, bytes: 0 },
-        snapshots: { units: 0, bytes: 0 },
-        attachments: { units: 0, bytes: 0 },
-        "reconnect-replay": { units: 0, bytes: 0 },
-    };
-    #leases = new Map();
-    #nextLeaseSequence = 0;
-    #replayExhausted = false;
-    constructor(adapterId, capability) {
-        this.adapterId = adapterId;
-        assertStructuredCapability(capability);
-        if (!adapterId || adapterId !== capability.adapterId)
-            throw new TypeError("structured backpressure adapter identity is invalid");
-        this.#budgets = Object.freeze({
-            events: budget(capability.flow.maxQueuedEvents, capability.flow.maxQueuedEvents * capability.flow.maxEventBytes, capability.flow.maxEventBytes, "pause-adapter"),
-            commands: budget(capability.flow.maxConcurrentCommands, capability.flow.maxConcurrentCommands * capability.flow.maxEventBytes, capability.flow.maxEventBytes, "reject-request"),
-            snapshots: budget(1, capability.flow.maxSnapshotBytes, capability.flow.maxSnapshotBytes, "reject-request"),
-            attachments: budget(capability.flow.maxConcurrentCommands, capability.flow.maxAttachmentBytes, capability.flow.maxAttachmentBytes, "reject-request"),
-            "reconnect-replay": budget(capability.flow.maxReconnectEvents, capability.flow.maxReconnectEvents * capability.flow.maxEventBytes, capability.flow.maxEventBytes, "disconnect-adapter"),
-        });
-    }
-    acquire(resource, units = 1, bytes = 0) {
-        const budget = this.#budget(resource);
-        if (!isPositiveSafeInteger(units) || !isSafeNonNegativeInteger(bytes)) {
-            return this.#reject(resource, "invalid-request", "reject-request", "resource units and bytes must be bounded safe integers");
-        }
-        if (bytes > budget.perPayloadByteLimit) {
-            return this.#reject(resource, "payload-too-large", "reject-payload", `${resource} payload exceeds its negotiated ${budget.perPayloadByteLimit} byte limit`);
-        }
-        if (resource === "reconnect-replay" && this.#replayExhausted) {
-            return this.#reject(resource, "replay-exhausted", "disconnect-adapter", "reconnect replay is already exhausted for this adapter");
-        }
-        const usage = this.#usage[resource];
-        if (usage.units + units > budget.unitLimit || usage.bytes + bytes > budget.byteLimit) {
-            if (resource === "reconnect-replay") {
-                this.#replayExhausted = true;
-                return this.#reject(resource, "replay-exhausted", "disconnect-adapter", "reconnect replay exceeded its negotiated event or byte window");
-            }
-            return this.#reject(resource, "resource-exhausted", budget.action, `${resource} exceeded its negotiated count or byte window`);
-        }
-        usage.units += units;
-        usage.bytes += bytes;
-        this.#nextLeaseSequence += 1;
-        const lease = Object.freeze({
-            id: `lease-${this.adapterId}-${this.#nextLeaseSequence}`,
-            resource,
-            units,
-            bytes,
-        });
-        this.#leases.set(lease.id, lease);
-        return { kind: "accepted", lease, usage: this.usage(resource) };
-    }
-    release(lease) {
-        if (!lease || typeof lease.id !== "string" || !isPositiveSafeInteger(lease.units) || !isSafeNonNegativeInteger(lease.bytes)) {
-            return { kind: "rejected", code: "invalid-request", diagnostic: "resource lease is malformed" };
-        }
-        const owned = this.#leases.get(lease.id);
-        if (!owned || owned.resource !== lease.resource || owned.units !== lease.units || owned.bytes !== lease.bytes) {
-            return { kind: "rejected", code: "unknown-lease", diagnostic: `resource lease is unknown: ${lease.id}` };
-        }
-        this.#leases.delete(lease.id);
-        const usage = this.#usage[lease.resource];
-        usage.units -= lease.units;
-        usage.bytes -= lease.bytes;
-        return { kind: "released", usage: this.usage(lease.resource) };
-    }
-    resetReconnectReplay() {
-        const usage = this.#usage["reconnect-replay"];
-        usage.units = 0;
-        usage.bytes = 0;
-        this.#replayExhausted = false;
-        for (const [id, lease] of this.#leases) {
-            if (lease.resource === "reconnect-replay")
-                this.#leases.delete(id);
-        }
-    }
-    usage(resource) {
-        const usage = this.#usage[resource];
-        const budget = this.#budget(resource);
-        return Object.freeze({
-            resource,
-            units: usage.units,
-            bytes: usage.bytes,
-            unitLimit: budget.unitLimit,
-            byteLimit: budget.byteLimit,
-        });
-    }
-    leaseCount() {
-        return this.#leases.size;
-    }
-    replayExhausted() {
-        return this.#replayExhausted;
-    }
-    #budget(resource) {
-        const budget = this.#budgets[resource];
-        if (!budget)
-            throw new TypeError(`unknown structured backpressure resource: ${String(resource)}`);
-        return budget;
-    }
-    #reject(resource, code, action, diagnostic) {
-        return { kind: "rejected", code, action, usage: this.usage(resource), diagnostic };
-    }
-}
-function budget(unitLimit, byteLimit, perPayloadByteLimit, action) {
-    return Object.freeze({ unitLimit, byteLimit, perPayloadByteLimit, action });
-}
-function isPositiveSafeInteger(value) {
-    return Number.isSafeInteger(value) && value > 0;
-}
-function isSafeNonNegativeInteger(value) {
-    return Number.isSafeInteger(value) && value >= 0;
-}

package/dist/foundation/structured-agent-runtime/commands.d.ts

@@ -1,53 +0,0 @@
-import { type StructuredCapabilityContract, type WorkspaceCommand } from "../../contracts/workspace/index.js";
-export type StructuredCommandRequest = Extract<WorkspaceCommand, {
-    readonly type: "structured-command";
-}>;
-export type StructuredCancelRequest = Extract<WorkspaceCommand, {
-    readonly type: "cancel-structured-command";
-}>;
-export type StructuredCommandTerminalOutcome = "completed" | "failed" | "timed-out" | "cancelled";
-export interface StructuredCommandRecord {
-    readonly agentId: string;
-    readonly correlationId: string;
-    readonly command: string;
-    readonly payload: unknown;
-    readonly startedAt: number;
-    readonly terminalAt: number | null;
-    readonly outcome: "active" | StructuredCommandTerminalOutcome;
-    readonly revision: number;
-}
-export type StructuredCommandStartResult = {
-    readonly kind: "accepted";
-    readonly record: StructuredCommandRecord;
-    readonly activeCount: number;
-} | {
-    readonly kind: "outcome";
-    readonly record: StructuredCommandRecord;
-    readonly idempotent: true;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-export type StructuredCommandOutcomeResult = {
-    readonly kind: "outcome";
-    readonly record: StructuredCommandRecord;
-    readonly idempotent: boolean;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-/** Tracks structured commands by correlation identity through one idempotent terminal outcome. */
-export declare class StructuredCommandTracker {
-    #private;
-    readonly agentId: string;
-    constructor(agentId: string, capability: StructuredCapabilityContract, commandTimeoutMs?: number);
-    start(command: StructuredCommandRequest, startedAt?: number): StructuredCommandStartResult;
-    complete(correlationId: string, outcome: "completed" | "failed", completedAt?: number): StructuredCommandOutcomeResult;
-    cancel(request: StructuredCancelRequest, cancelledAt?: number): StructuredCommandOutcomeResult;
-    expire(now: number): readonly StructuredCommandRecord[];
-    outcomeFor(correlationId: string): StructuredCommandRecord | null;
-    activeCount(): number;
-    terminalCount(): number;
-}

package/dist/foundation/structured-agent-runtime/commands.js

@@ -1,165 +0,0 @@
-import { assertStructuredCapability, assertWorkspaceCommand, } from "../../contracts/workspace/index.js";
-/** Tracks structured commands by correlation identity through one idempotent terminal outcome. */
-export class StructuredCommandTracker {
-    agentId;
-    #capability;
-    #commandTimeoutMs;
-    #records = new Map();
-    #terminalOrder = [];
-    constructor(agentId, capability, commandTimeoutMs = 30_000) {
-        this.agentId = agentId;
-        assertStructuredCapability(capability);
-        if (!agentId || agentId.includes("\0"))
-            throw new TypeError("structured command agent id is invalid");
-        if (!Number.isSafeInteger(commandTimeoutMs) || commandTimeoutMs <= 0)
-            throw new RangeError("structured command timeout must be positive");
-        this.#capability = capability;
-        this.#commandTimeoutMs = commandTimeoutMs;
-    }
-    start(command, startedAt = 0) {
-        try {
-            assertWorkspaceCommand(command);
-        }
-        catch (error) {
-            return rejected("malformed-command", error);
-        }
-        if (command.agentId !== this.agentId)
-            return rejected("agent-mismatch", new Error("structured command agent does not match the tracker identity"));
-        if (!this.#capability.commands.includes(command.command)) {
-            return rejected("unsupported-command", new Error(`structured command is not negotiated: ${command.command}`));
-        }
-        if (payloadBytes(command.payload) > this.#capability.flow.maxEventBytes) {
-            return rejected("command-too-large", new Error(`structured command exceeds the negotiated ${this.#capability.flow.maxEventBytes} byte payload limit`));
-        }
-        try {
-            assertTime(startedAt, "command start time");
-        }
-        catch (error) {
-            return rejected("invalid-time", error);
-        }
-        const existing = this.#records.get(command.correlationId);
-        if (existing) {
-            if (existing.outcome !== "active" && existing.command === command.command && stableJson(existing.payload) === stableJson(command.payload)) {
-                return { kind: "outcome", record: freezeRecord(existing), idempotent: true };
-            }
-            return rejected(existing.outcome === "active" ? "duplicate-correlation" : "correlation-conflict", new Error(`structured correlation id is already in use: ${command.correlationId}`));
-        }
-        if (this.activeCount() >= this.#capability.flow.maxConcurrentCommands) {
-            return rejected("concurrency-limit", new Error(`structured command concurrency exceeds the negotiated ${this.#capability.flow.maxConcurrentCommands} command limit`));
-        }
-        const record = {
-            agentId: command.agentId,
-            correlationId: command.correlationId,
-            command: command.command,
-            payload: command.payload,
-            startedAt,
-            terminalAt: null,
-            outcome: "active",
-            revision: 1,
-        };
-        this.#records.set(record.correlationId, record);
-        return { kind: "accepted", record: freezeRecord(record), activeCount: this.activeCount() };
-    }
-    complete(correlationId, outcome, completedAt = 0) {
-        if (outcome !== "completed" && outcome !== "failed")
-            return rejected("malformed-outcome", new Error("structured completion outcome is invalid"));
-        try {
-            assertTime(completedAt, "command completion time");
-        }
-        catch (error) {
-            return rejected("invalid-time", error);
-        }
-        const record = this.#records.get(correlationId);
-        if (!record)
-            return rejected("unknown-correlation", new Error(`structured correlation id is unknown: ${correlationId}`));
-        return this.#settle(record, outcome, completedAt);
-    }
-    cancel(request, cancelledAt = 0) {
-        try {
-            assertWorkspaceCommand(request);
-        }
-        catch (error) {
-            return rejected("malformed-cancellation", error);
-        }
-        if (request.agentId !== this.agentId)
-            return rejected("agent-mismatch", new Error("structured cancellation agent does not match the tracker identity"));
-        if (this.#capability.cancellation !== "correlated")
-            return rejected("cancellation-unsupported", new Error("the negotiated adapter capability does not support correlated cancellation"));
-        try {
-            assertTime(cancelledAt, "command cancellation time");
-        }
-        catch (error) {
-            return rejected("invalid-time", error);
-        }
-        const record = this.#records.get(request.targetCorrelationId);
-        if (!record)
-            return rejected("unknown-correlation", new Error(`structured correlation id is unknown: ${request.targetCorrelationId}`));
-        return this.#settle(record, "cancelled", cancelledAt);
-    }
-    expire(now) {
-        assertTime(now, "command timeout clock");
-        const expired = [];
-        for (const record of this.#records.values()) {
-            if (record.outcome === "active" && now - record.startedAt >= this.#commandTimeoutMs) {
-                const result = this.#settle(record, "timed-out", record.startedAt + this.#commandTimeoutMs);
-                if (result.kind === "outcome")
-                    expired.push(result.record);
-            }
-        }
-        return Object.freeze(expired);
-    }
-    outcomeFor(correlationId) {
-        const record = this.#records.get(correlationId);
-        return record ? freezeRecord(record) : null;
-    }
-    activeCount() {
-        let count = 0;
-        for (const record of this.#records.values())
-            if (record.outcome === "active")
-                count += 1;
-        return count;
-    }
-    terminalCount() {
-        return this.#terminalOrder.length;
-    }
-    #settle(record, outcome, at) {
-        if (record.outcome !== "active")
-            return { kind: "outcome", record: freezeRecord(record), idempotent: true };
-        if (at < record.startedAt)
-            return rejected("invalid-time", new Error("structured command outcome cannot precede its start"));
-        record.outcome = outcome;
-        record.terminalAt = at;
-        record.revision += 1;
-        this.#terminalOrder.push(record.correlationId);
-        this.#boundTerminalOutcomes();
-        return { kind: "outcome", record: freezeRecord(record), idempotent: false };
-    }
-    #boundTerminalOutcomes() {
-        const retention = this.#capability.flow.maxQueuedEvents;
-        while (this.#terminalOrder.length > retention) {
-            const oldest = this.#terminalOrder.shift();
-            if (oldest === undefined)
-                return;
-            this.#records.delete(oldest);
-        }
-    }
-}
-function rejected(code, error) {
-    return { kind: "rejected", code, diagnostic: error instanceof Error ? error.message : String(error) };
-}
-function freezeRecord(record) {
-    return Object.freeze({ ...record });
-}
-function assertTime(value, name) {
-    if (!Number.isSafeInteger(value) || value < 0)
-        throw new RangeError(`${name} must be a non-negative safe integer`);
-}
-function payloadBytes(payload) {
-    return new TextEncoder().encode(stableJson(payload)).byteLength;
-}
-function stableJson(value) {
-    const encoded = JSON.stringify(value);
-    if (encoded === undefined)
-        throw new TypeError("structured payload must be JSON serializable");
-    return encoded;
-}

package/dist/foundation/structured-agent-runtime/handshake.d.ts

@@ -1,41 +0,0 @@
-import { type AdapterId, type StructuredCapabilityContract, type StructuredFlowLimits } from "../../contracts/workspace/index.js";
-export declare const STRUCTURED_ADAPTER_ENVELOPE: string;
-export declare const STRUCTURED_ADAPTER_ENVELOPE_REVISION: 1;
-export declare const REQUIRED_STRUCTURED_FEATURES: readonly ["identity.adapter.v1", "commands.correlated.v1", "events.typed.v1", "flow-control.limits.v1"];
-export declare const OPTIONAL_STRUCTURED_FEATURES: readonly ["snapshots.authoritative.v1", "resume.position.v1", "resume.snapshot.v1", "commands.cancellable.v1", "attachments.typed.v1"];
-export type StructuredProtocolFeature = typeof REQUIRED_STRUCTURED_FEATURES[number] | typeof OPTIONAL_STRUCTURED_FEATURES[number];
-export declare const STRUCTURED_FLOW_LIMITS: StructuredFlowLimits;
-export interface StructuredAdapterHello {
-    readonly envelope: typeof STRUCTURED_ADAPTER_ENVELOPE;
-    readonly envelopeRevision: typeof STRUCTURED_ADAPTER_ENVELOPE_REVISION;
-    readonly adapterId: AdapterId;
-    readonly buildId: string;
-    readonly requiredFeatures: readonly string[];
-    readonly optionalFeatures: readonly string[];
-    readonly capability: StructuredCapabilityContract;
-}
-export interface StructuredAdapterPeerHello {
-    readonly envelope: typeof STRUCTURED_ADAPTER_ENVELOPE;
-    readonly envelopeRevision: typeof STRUCTURED_ADAPTER_ENVELOPE_REVISION;
-    readonly requiredFeatures: readonly string[];
-    readonly optionalFeatures: readonly string[];
-    readonly flowLimits: StructuredFlowLimits;
-}
-export type StructuredHandshakeErrorCode = "invalid-message" | "unsupported-version" | "invalid-identity" | "invalid-capability" | "unsupported-feature" | "incompatible-features";
-export interface StructuredHandshakeAccepted {
-    readonly accepted: true;
-    readonly adapterId: AdapterId;
-    readonly negotiatedFeatures: readonly string[];
-    readonly capability: StructuredCapabilityContract;
-    readonly diagnostic: string;
-}
-export interface StructuredHandshakeRejected {
-    readonly accepted: false;
-    readonly code: StructuredHandshakeErrorCode;
-    readonly missingFromAdapter: readonly string[];
-    readonly missingFromServer: readonly string[];
-    readonly diagnostic: string;
-}
-export type StructuredHandshakeResult = StructuredHandshakeAccepted | StructuredHandshakeRejected;
-export declare function localStructuredAdapterHello(): StructuredAdapterPeerHello;
-export declare function negotiateStructuredAdapter(value: unknown, server?: StructuredAdapterPeerHello): StructuredHandshakeResult;