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

package/dist/contracts/workspace/validation.js

@@ -1,335 +0,0 @@
-import { NATIVE_HOST_PROTOCOL_VERSION, WORKSPACE_CONTRACT_VERSION } from "./model.js";
-const MAX_ID_LENGTH = 128;
-const MAX_LABEL_LENGTH = 256;
-const MAX_COLLECTION_LENGTH = 10_000;
-const MAX_ENVIRONMENT_ENTRIES = 512;
-const MAX_ARGUMENTS = 1_024;
-const MAX_POSITION = Number.MAX_SAFE_INTEGER;
-const MAX_LIMIT = 1_000_000_000;
-export function assertManagedAgentDescriptor(agent) {
-    assertId(agent.id, "agent id");
-    assertText(agent.displayName, "agent display name", MAX_LABEL_LENGTH);
-    assertId(agent.adapterId, "adapter id");
-    assertIsoDate(agent.createdAt, "agent creation time");
-    if (agent.recoveryReferenceId !== null)
-        assertId(agent.recoveryReferenceId, "recovery reference id");
-    assertAgentCapability(agent.capability);
-    if (agent.runtime !== agent.capability.kind)
-        throw new TypeError("agent runtime must match its capability kind");
-}
-export function assertAgentCapability(capability) {
-    if (capability.kind === "structured") {
-        assertStructuredCapability(capability);
-        return;
-    }
-    assertComposedTerminalCapability(capability);
-}
-export function assertStructuredCapability(capability) {
-    if (capability.protocolVersion !== WORKSPACE_CONTRACT_VERSION)
-        throw new TypeError("unsupported structured protocol version");
-    assertId(capability.adapterId, "structured adapter id");
-    assertUniqueText(capability.commands, "structured commands");
-    assertUniqueText(capability.eventTypes, "structured event types");
-    assertUniqueText(capability.attachmentTypes, "structured attachment types");
-    if (capability.resume === "position" && capability.snapshots === "none") {
-        throw new TypeError("position resume requires authoritative snapshots for gap recovery");
-    }
-    if (capability.resume === "snapshot" && capability.snapshots !== "authoritative") {
-        throw new TypeError("snapshot resume requires authoritative snapshots");
-    }
-    for (const [name, value] of Object.entries(capability.flow))
-        assertBoundedPositiveInteger(value, `structured flow ${name}`);
-}
-export function assertComposedTerminalCapability(capability) {
-    if (capability.protocolVersion !== NATIVE_HOST_PROTOCOL_VERSION)
-        throw new TypeError("unsupported native-host protocol version");
-    assertId(capability.hostInstanceId, "native host instance id");
-    assertRevision(capability.topologyRevision, "topology revision");
-}
-export function assertWorkspaceSnapshot(snapshot) {
-    if (snapshot.contractVersion !== WORKSPACE_CONTRACT_VERSION)
-        throw new TypeError("unsupported workspace contract version");
-    assertId(snapshot.workspaceId, "workspace id");
-    assertRevision(snapshot.revision, "workspace revision");
-    assertCollection(snapshot.agents, "workspace agents");
-    const ids = new Set();
-    for (const agent of snapshot.agents) {
-        assertManagedAgentDescriptor(agent);
-        if (ids.has(agent.id))
-            throw new TypeError(`duplicate agent id: ${agent.id}`);
-        ids.add(agent.id);
-    }
-    if (snapshot.selectedAgentId !== null && !ids.has(snapshot.selectedAgentId)) {
-        throw new TypeError("selected agent must exist in the workspace snapshot");
-    }
-}
-export function assertWorkspaceCommand(command) {
-    assertId(command.correlationId, "command correlation id");
-    switch (command.type) {
-        case "create-agent":
-            assertManagedAgentDescriptor(command.agent);
-            return;
-        case "select-agent":
-        case "stop-agent":
-        case "restart-agent":
-        case "remove-agent":
-            assertId(command.agentId, "command agent id");
-            return;
-        case "rename-agent":
-            assertId(command.agentId, "command agent id");
-            assertText(command.displayName, "agent display name", MAX_LABEL_LENGTH);
-            return;
-        case "structured-command":
-            assertId(command.agentId, "command agent id");
-            assertId(command.command, "structured command name");
-            assertJsonValue(command.payload, "structured command payload");
-            return;
-        case "cancel-structured-command":
-            assertId(command.agentId, "command agent id");
-            assertId(command.targetCorrelationId, "target command correlation id");
-    }
-}
-export function assertWorkspaceEvent(event) {
-    assertId(event.agentId, "event agent id");
-    switch (event.type) {
-        case "agent-lifecycle":
-            assertPosition(event.position, "lifecycle event position");
-            return;
-        case "structured-event":
-            assertPosition(event.position, "structured event position");
-            assertId(event.eventType, "structured event type");
-            assertJsonValue(event.payload, "structured event payload");
-            return;
-        case "command-outcome":
-            assertId(event.correlationId, "command correlation id");
-            return;
-        case "terminal-topology":
-            assertTerminalTopologySnapshot(event.topology);
-            return;
-        case "recovery-discontinuity":
-            assertText(event.reason, "recovery discontinuity reason", 4_096);
-    }
-}
-export function assertStructuredAgentSnapshot(snapshot) {
-    if (snapshot.contractVersion !== WORKSPACE_CONTRACT_VERSION)
-        throw new TypeError("unsupported structured snapshot contract version");
-    assertId(snapshot.agentId, "structured snapshot agent id");
-    assertId(snapshot.snapshotId, "structured snapshot id");
-    assertPosition(snapshot.position, "structured snapshot position");
-    if (snapshot.authoritative !== true)
-        throw new TypeError("structured snapshot must be authoritative");
-    assertJsonValue(snapshot.payload, "structured snapshot payload");
-}
-export function assertTerminalTopologySnapshot(topology) {
-    assertId(topology.hostInstanceId, "native host instance id");
-    assertRevision(topology.revision, "topology revision");
-    assertCollection(topology.windows, "terminal windows");
-    assertCollection(topology.sessions, "terminal sessions");
-    const sessionIds = new Set();
-    for (const session of topology.sessions) {
-        assertTerminalSessionLaunch(session);
-        if (sessionIds.has(session.id))
-            throw new TypeError(`duplicate terminal session id: ${session.id}`);
-        sessionIds.add(session.id);
-    }
-    const windowIds = new Set();
-    const paneIds = new Set();
-    for (const window of topology.windows) {
-        assertId(window.id, "terminal window id");
-        if (windowIds.has(window.id))
-            throw new TypeError(`duplicate terminal window id: ${window.id}`);
-        windowIds.add(window.id);
-        assertCollection(window.tabs, "terminal tabs");
-        if (!window.tabs.some(tab => tab.id === window.activeTabId))
-            throw new TypeError("active tab must exist in its window");
-        const tabIds = new Set();
-        for (const tab of window.tabs) {
-            if (tabIds.has(tab.id))
-                throw new TypeError(`duplicate terminal tab id in window: ${tab.id}`);
-            tabIds.add(tab.id);
-            assertTerminalTab(tab, sessionIds, paneIds);
-        }
-    }
-}
-export function assertNativeHostCommand(command) {
-    assertId(command.correlationId, "native-host correlation id");
-    if (command.type === "apply-topology") {
-        assertRevision(command.expectedRevision, "expected topology revision");
-        assertTerminalTopologySnapshot(command.topology);
-        if (command.topology.revision !== command.expectedRevision) {
-            throw new TypeError("applied topology snapshot revision must equal the expected revision");
-        }
-        return;
-    }
-    if (command.type === "focus-pane" || command.type === "close-pane") {
-        assertRevision(command.expectedRevision, "expected topology revision");
-        assertId(command.paneId, "terminal pane id");
-    }
-}
-export function assertRecoveryAuthority(authority) {
-    assertId(authority.referenceId, "recovery reference id");
-    assertId(authority.agentId, "recovery agent id");
-    assertText(authority.processIdentity, "recovery process identity", 1_024);
-    if (authority.kind === "structured") {
-        assertId(authority.adapterId, "recovery adapter id");
-        assertText(authority.ownershipProof, "recovery ownership proof", 4_096);
-        if (authority.boundary.kind === "position") {
-            assertPosition(authority.boundary.position, "resume position");
-            assertText(authority.boundary.resumeToken, "resume token", 4_096);
-        }
-        else {
-            assertId(authority.boundary.snapshotId, "recovery snapshot id");
-        }
-        return;
-    }
-    assertId(authority.hostInstanceId, "recovery host instance id");
-    assertText(authority.hostBuildId, "recovery host build id", 1_024);
-    assertText(authority.pseudoterminalIdentity, "recovery pseudoterminal identity", 1_024);
-    assertText(authority.retainedStateIdentity, "recovery retained-state identity", 1_024);
-    assertRevision(authority.topologyRevision, "recovery topology revision");
-    assertPosition(authority.streamPosition, "recovery stream position");
-}
-export function assertTerminalSessionLaunch(session) {
-    assertId(session.id, "terminal session id");
-    assertText(session.executable, "terminal executable", 32_768);
-    assertText(session.cwd, "terminal working directory", 32_768);
-    if (session.executable.includes("\0") || session.cwd.includes("\0"))
-        throw new TypeError("terminal launch paths contain a null byte");
-    assertCollection(session.arguments, "terminal arguments", MAX_ARGUMENTS);
-    if (session.arguments.some(argument => typeof argument !== "string" || argument.includes("\0"))) {
-        throw new TypeError("terminal arguments contain an invalid value");
-    }
-    const entries = Object.entries(session.environment);
-    assertCollection(entries, "terminal environment", MAX_ENVIRONMENT_ENTRIES);
-    if (entries.some(([name, value]) => !name || name.includes("=") || name.includes("\0") || typeof value !== "string" || value.includes("\0"))) {
-        throw new TypeError("terminal environment contains an invalid name or value");
-    }
-    assertTerminalDimensions(session.dimensions);
-}
-function assertTerminalDimensions(dimensions) {
-    assertIntegerInRange(dimensions.columns, 2, 500, "terminal columns");
-    assertIntegerInRange(dimensions.rows, 1, 300, "terminal rows");
-    assertIntegerInRange(dimensions.widthPixels, 1, 100_000, "terminal pixel width");
-    assertIntegerInRange(dimensions.heightPixels, 1, 100_000, "terminal pixel height");
-}
-function assertTerminalTab(tab, sessionIds, globalPaneIds) {
-    assertId(tab.id, "terminal tab id");
-    assertCollection(tab.nodes, "terminal topology nodes");
-    assertCollection(tab.panes, "terminal panes");
-    const paneIds = new Set();
-    for (const pane of tab.panes) {
-        assertId(pane.id, "terminal pane id");
-        assertId(pane.sessionId, "terminal pane session id");
-        if (paneIds.has(pane.id) || globalPaneIds.has(pane.id))
-            throw new TypeError(`duplicate terminal pane id: ${pane.id}`);
-        if (!sessionIds.has(pane.sessionId))
-            throw new TypeError(`terminal pane references missing session: ${pane.sessionId}`);
-        paneIds.add(pane.id);
-        globalPaneIds.add(pane.id);
-    }
-    if (!paneIds.has(tab.focusedPaneId))
-        throw new TypeError("focused pane must exist in its tab");
-    const nodes = new Map();
-    for (const node of tab.nodes) {
-        assertId(node.id, "terminal topology node id");
-        if (nodes.has(node.id))
-            throw new TypeError(`duplicate terminal topology node id: ${node.id}`);
-        if (node.kind === "leaf") {
-            if (!paneIds.has(node.paneId))
-                throw new TypeError(`terminal leaf references missing pane: ${node.paneId}`);
-        }
-        else {
-            if (!(node.ratio > 0 && node.ratio < 1 && Number.isFinite(node.ratio)))
-                throw new RangeError("terminal split ratio must be between zero and one");
-            if (node.first === node.second || node.id === node.first || node.id === node.second)
-                throw new TypeError("terminal split cannot reference itself or duplicate a child");
-        }
-        nodes.set(node.id, node);
-    }
-    if (!nodes.has(tab.rootNodeId))
-        throw new TypeError("terminal tab root node is missing");
-    const visited = new Set();
-    const visiting = new Set();
-    const reachedPanes = new Set();
-    visitNode(tab.rootNodeId, nodes, visited, visiting, reachedPanes);
-    if (visited.size !== nodes.size)
-        throw new TypeError("terminal tab contains unreachable topology nodes");
-    if (reachedPanes.size !== paneIds.size || [...paneIds].some(paneId => !reachedPanes.has(paneId))) {
-        throw new TypeError("each terminal pane must appear exactly once in the split tree");
-    }
-}
-function visitNode(id, nodes, visited, visiting, reachedPanes) {
-    const node = nodes.get(id);
-    if (!node)
-        throw new TypeError(`terminal split references missing node: ${id}`);
-    if (visiting.has(id))
-        throw new TypeError("terminal topology contains a cycle");
-    if (visited.has(id))
-        throw new TypeError("terminal topology node has multiple parents");
-    visiting.add(id);
-    if (node.kind === "leaf") {
-        if (reachedPanes.has(node.paneId))
-            throw new TypeError("terminal pane appears more than once in the split tree");
-        reachedPanes.add(node.paneId);
-    }
-    else {
-        visitNode(node.first, nodes, visited, visiting, reachedPanes);
-        visitNode(node.second, nodes, visited, visiting, reachedPanes);
-    }
-    visiting.delete(id);
-    visited.add(id);
-}
-function assertUniqueText(values, name) {
-    assertCollection(values, name);
-    const seen = new Set();
-    for (const value of values) {
-        assertId(value, name);
-        if (seen.has(value))
-            throw new TypeError(`${name} contains a duplicate: ${value}`);
-        seen.add(value);
-    }
-}
-function assertJsonValue(value, name) {
-    try {
-        const encoded = JSON.stringify(value);
-        if (encoded === undefined)
-            throw new TypeError();
-    }
-    catch {
-        throw new TypeError(`${name} must be JSON serializable`);
-    }
-}
-function assertCollection(value, name, maximum = MAX_COLLECTION_LENGTH) {
-    if (!Array.isArray(value) || value.length > maximum)
-        throw new RangeError(`${name} exceeds its maximum length`);
-}
-function assertId(value, name) {
-    assertText(value, name, MAX_ID_LENGTH);
-    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value))
-        throw new TypeError(`${name} contains unsupported characters`);
-}
-function assertText(value, name, maximum) {
-    if (typeof value !== "string" || value.length === 0 || value.length > maximum || value.includes("\0")) {
-        throw new TypeError(`${name} is invalid`);
-    }
-}
-function assertIsoDate(value, name) {
-    assertText(value, name, 64);
-    if (!Number.isFinite(Date.parse(value)))
-        throw new TypeError(`${name} is not an ISO timestamp`);
-}
-function assertRevision(value, name) {
-    if (!Number.isSafeInteger(value) || value < 0)
-        throw new RangeError(`${name} must be a non-negative safe integer`);
-}
-function assertPosition(value, name) {
-    assertIntegerInRange(value, 0, MAX_POSITION, name);
-}
-function assertBoundedPositiveInteger(value, name) {
-    assertIntegerInRange(value, 1, MAX_LIMIT, name);
-}
-function assertIntegerInRange(value, minimum, maximum, name) {
-    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
-        throw new RangeError(`${name} must be an integer from ${minimum} to ${maximum}`);
-    }
-}

package/dist/features/owned-ui/customization.d.ts

@@ -1,40 +0,0 @@
-import { type OwnedUiCommand, type OwnedUiCustomization, type OwnedUiSlotId, type OwnedUiTranscriptBlock } from "../../contracts/owned-ui/index.js";
-export interface OwnedUiSlotImplementation {
-    readonly payload: unknown;
-    render?(input: unknown, width: number): readonly string[];
-    createCommand?(context: {
-        readonly sessionId: string;
-        readonly correlationId: string;
-    }): OwnedUiCommand | Promise<OwnedUiCommand>;
-}
-export interface OwnedCommandHandlerContext {
-    readonly sessionId: string;
-    readonly correlationId: string;
-}
-export type OwnedCommandHandler = (context: OwnedCommandHandlerContext) => OwnedUiCommand | Promise<OwnedUiCommand>;
-/** Registers owned UI commands and assigns a monotonic correlation identifier to each dispatch. */
-export declare class OwnedCommandSurface {
-    #private;
-    register(name: string, handler: OwnedCommandHandler): () => void;
-    names(): readonly string[];
-    dispatch(name: string, sessionId: string): Promise<OwnedUiCommand>;
-}
-export interface ResolvedOwnedUiSlot {
-    readonly customization: OwnedUiCustomization;
-    readonly implementation: OwnedUiSlotImplementation;
-}
-/** Resolves one customization per slot by precedence and version while preserving registration identity. */
-export declare class OwnedUiCustomizationRegistry {
-    #private;
-    register(customization: OwnedUiCustomization, implementation: OwnedUiSlotImplementation): () => void;
-    resolve(slot: OwnedUiSlotId): ResolvedOwnedUiSlot | undefined;
-    registrations(slot: OwnedUiSlotId): readonly OwnedUiCustomization[];
-    remove(id: string): boolean;
-    all(): readonly OwnedUiCustomization[];
-    clear(): void;
-    installCommands(surface: OwnedCommandSurface, sessionId: string): readonly string[];
-}
-export interface VanillaUiCustomizationPorts {
-    readonly renderTranscriptBlock: (block: OwnedUiTranscriptBlock, width: number) => readonly string[];
-}
-export declare function createVanillaUiCustomizationRegistry(ports: VanillaUiCustomizationPorts): OwnedUiCustomizationRegistry;

package/dist/features/owned-ui/customization.js

@@ -1,110 +0,0 @@
-import { assertOwnedUiCustomization, } from "../../contracts/owned-ui/index.js";
-/** Registers owned UI commands and assigns a monotonic correlation identifier to each dispatch. */
-export class OwnedCommandSurface {
-    #handlers = new Map();
-    #sequence = 0;
-    register(name, handler) {
-        this.#handlers.set(name, handler);
-        return () => this.#handlers.delete(name);
-    }
-    names() {
-        return [...this.#handlers.keys()].sort();
-    }
-    async dispatch(name, sessionId) {
-        const handler = this.#handlers.get(name);
-        if (!handler)
-            throw new Error(`unknown owned UI command: ${name}`);
-        this.#sequence += 1;
-        return handler({ sessionId, correlationId: `ui-command-${this.#sequence}` });
-    }
-}
-/** Resolves one customization per slot by precedence and version while preserving registration identity. */
-export class OwnedUiCustomizationRegistry {
-    #registrations = new Map();
-    register(customization, implementation) {
-        assertOwnedUiCustomization(customization);
-        if (typeof implementation !== "object" || implementation === null) {
-            throw new TypeError("owned UI slot implementation is invalid");
-        }
-        const slot = this.#slot(customization.slot);
-        slot.set(customization.id, Object.freeze({ customization, implementation }));
-        return () => {
-            if (slot.get(customization.id)?.customization.version === customization.version)
-                slot.delete(customization.id);
-        };
-    }
-    resolve(slot) {
-        return [...(this.#registrations.get(slot)?.values() ?? [])]
-            .sort((left, right) => right.customization.precedence - left.customization.precedence
-            || right.customization.version - left.customization.version
-            || left.customization.id.localeCompare(right.customization.id))[0];
-    }
-    registrations(slot) {
-        return [...(this.#registrations.get(slot)?.values() ?? [])]
-            .map(registration => registration.customization)
-            .sort((left, right) => right.precedence - left.precedence || right.version - left.version || left.id.localeCompare(right.id));
-    }
-    remove(id) {
-        for (const slot of this.#registrations.values()) {
-            if (slot.delete(id))
-                return true;
-        }
-        return false;
-    }
-    all() {
-        return [...this.#registrations.values()]
-            .flatMap(slot => [...slot.values()].map(registration => registration.customization))
-            .sort((left, right) => left.slot.localeCompare(right.slot) || right.precedence - left.precedence || left.id.localeCompare(right.id));
-    }
-    clear() {
-        this.#registrations.clear();
-    }
-    installCommands(surface, sessionId) {
-        const installed = [];
-        for (const registration of this.#registrations.get("command")?.values() ?? []) {
-            if (!registration.implementation.createCommand)
-                continue;
-            installed.push(registration.customization.id);
-            surface.register(registration.customization.id, context => {
-                if (context.sessionId !== sessionId)
-                    throw new Error("owned UI command session does not match the registry binding");
-                return registration.implementation.createCommand(context);
-            });
-        }
-        return installed;
-    }
-    #slot(slot) {
-        let registrations = this.#registrations.get(slot);
-        if (!registrations) {
-            registrations = new Map();
-            this.#registrations.set(slot, registrations);
-        }
-        return registrations;
-    }
-}
-export function createVanillaUiCustomizationRegistry(ports) {
-    const registry = new OwnedUiCustomizationRegistry();
-    const register = (slot, id, label, implementation = { payload: {} }) => registry.register({
-        id,
-        slot,
-        version: 1,
-        precedence: 0,
-        label,
-        payload: {},
-    }, implementation);
-    register("theme", "vanilla-theme", "Vanilla Pi style", {
-        payload: { background: "terminal", foreground: "terminal", accent: "blue" },
-    });
-    register("transcript-block", "vanilla-transcript", "Vanilla transcript", {
-        payload: {},
-        render: (input, width) => ports.renderTranscriptBlock(input, width),
-    });
-    register("tool-card", "vanilla-tool-card", "Vanilla tool cards");
-    register("editor", "vanilla-editor", "Vanilla editor");
-    register("status", "vanilla-status", "Vanilla status");
-    register("selector", "vanilla-selector", "Vanilla selector");
-    register("dialog", "vanilla-dialog", "Vanilla dialog");
-    register("overlay", "vanilla-overlay", "Vanilla overlay");
-    register("layout", "vanilla-fullscreen", "Fullscreen session");
-    return registry;
-}

package/dist/features/owned-ui/diagnostics.d.ts

@@ -1,34 +0,0 @@
-import type { OwnedUiDiagnostics } from "../../contracts/owned-ui/index.js";
-export interface OwnedUiFrameObservation {
-    readonly requestedFrames: number;
-    readonly presentedFrames: number;
-    readonly failedFrames: number;
-    readonly lastFrameBytes: number;
-}
-export interface OwnedUiResourceObservation {
-    readonly cpuUserMicros: number;
-    readonly cpuSystemMicros: number;
-    readonly residentMemoryBytes: number;
-    readonly heapBytes: number;
-}
-export interface OwnedUiDiagnosticsSnapshot {
-    readonly entries: readonly OwnedUiDiagnostics[];
-    readonly frames: OwnedUiFrameObservation;
-    readonly resources: OwnedUiResourceObservation | null;
-    readonly terminalRestorationFailed: boolean;
-}
-/** Retains bounded, redacted UI diagnostics together with frame and resource observations. */
-export declare class OwnedUiDiagnosticsRecorder {
-    #private;
-    readonly maximumEntries: number;
-    constructor(maximumEntries?: number);
-    entries(): readonly OwnedUiDiagnostics[];
-    record(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable?: boolean): OwnedUiDiagnostics;
-    noteFrame(bytes: number, failed?: boolean): OwnedUiFrameObservation;
-    noteResources(observation: OwnedUiResourceObservation): OwnedUiResourceObservation;
-    captureResources(read?: () => NodeJS.ResourceUsage): OwnedUiResourceObservation;
-    noteTerminalRestorationFailure(error: unknown): OwnedUiDiagnostics;
-    frames(): OwnedUiFrameObservation;
-    snapshot(): OwnedUiDiagnosticsSnapshot;
-}
-export declare function redactDiagnosticMessage(message: string): string;

package/dist/features/owned-ui/diagnostics.js

@@ -1,95 +0,0 @@
-/** Retains bounded, redacted UI diagnostics together with frame and resource observations. */
-export class OwnedUiDiagnosticsRecorder {
-    maximumEntries;
-    #entries = [];
-    #sequence = 0;
-    #requestedFrames = 0;
-    #presentedFrames = 0;
-    #failedFrames = 0;
-    #lastFrameBytes = 0;
-    #resources = null;
-    #terminalRestorationFailed = false;
-    constructor(maximumEntries = 100) {
-        this.maximumEntries = maximumEntries;
-        if (!Number.isSafeInteger(maximumEntries) || maximumEntries <= 0)
-            throw new RangeError("diagnostic capacity must be positive");
-    }
-    entries() {
-        return this.#entries.map(entry => ({ ...entry }));
-    }
-    record(severity, code, message, recoverable = true) {
-        const entry = {
-            sequence: this.#sequence++,
-            code: sanitizeDiagnosticCode(code),
-            severity,
-            message: redactDiagnosticMessage(message),
-            recoverable,
-        };
-        this.#entries.push(entry);
-        if (this.#entries.length > this.maximumEntries)
-            this.#entries.shift();
-        return { ...entry };
-    }
-    noteFrame(bytes, failed = false) {
-        if (!Number.isSafeInteger(bytes) || bytes < 0)
-            throw new RangeError("frame byte count is invalid");
-        this.#requestedFrames += 1;
-        if (failed)
-            this.#failedFrames += 1;
-        else
-            this.#presentedFrames += 1;
-        this.#lastFrameBytes = bytes;
-        return this.frames();
-    }
-    noteResources(observation) {
-        for (const value of Object.values(observation)) {
-            if (!Number.isFinite(value) || value < 0)
-                throw new RangeError("resource observations must be non-negative finite values");
-        }
-        this.#resources = Object.freeze({ ...observation });
-        return this.#resources;
-    }
-    captureResources(read = () => process.resourceUsage()) {
-        const usage = read();
-        return this.noteResources({
-            cpuUserMicros: usage.userCPUTime,
-            cpuSystemMicros: usage.systemCPUTime,
-            residentMemoryBytes: process.memoryUsage().rss,
-            heapBytes: process.memoryUsage().heapUsed,
-        });
-    }
-    noteTerminalRestorationFailure(error) {
-        this.#terminalRestorationFailed = true;
-        return this.record("error", "terminal-restoration", error instanceof Error ? error.message : String(error), false);
-    }
-    frames() {
-        return {
-            requestedFrames: this.#requestedFrames,
-            presentedFrames: this.#presentedFrames,
-            failedFrames: this.#failedFrames,
-            lastFrameBytes: this.#lastFrameBytes,
-        };
-    }
-    snapshot() {
-        return {
-            entries: this.entries(),
-            frames: this.frames(),
-            resources: this.#resources === null ? null : { ...this.#resources },
-            terminalRestorationFailed: this.#terminalRestorationFailed,
-        };
-    }
-}
-export function redactDiagnosticMessage(message) {
-    return message
-        .replace(/[A-Za-z0-9_\-]{24,}\.[A-Za-z0-9_\-]{12,}\.[A-Za-z0-9_\-]{12,}/g, "[redacted-token]")
-        .replace(/(api[_-]?key|token|secret|password)=([^\s]+)/gi, "$1=[redacted]")
-        .replace(/[A-Z]:\\Users\\[^\\\s]+/gi, "[home]")
-        .replace(/\/home\/[^/\s]+/g, "[home]")
-        .slice(0, 4_096);
-}
-function sanitizeDiagnosticCode(code) {
-    const normalized = code.toLowerCase().replace(/[^a-z0-9._:-]+/g, "-").replace(/^-+|-+$/g, "");
-    if (!normalized)
-        throw new TypeError("diagnostic code is invalid");
-    return normalized.slice(0, 128);
-}

package/dist/features/workspace/capabilities.d.ts

@@ -1,31 +0,0 @@
-import type { ManagedAgentDescriptor } from "../../contracts/workspace/index.js";
-export type WorkspaceCapabilityAction = {
-    readonly type: "structured-command";
-    readonly command: string;
-} | {
-    readonly type: "cancel-structured-command";
-} | {
-    readonly type: "restore-structured-snapshot";
-} | {
-    readonly type: "send-structured-attachment";
-    readonly attachmentType: string;
-} | {
-    readonly type: "create-terminal-pane";
-} | {
-    readonly type: "apply-terminal-layout";
-} | {
-    readonly type: "focus-terminal-pane";
-} | {
-    readonly type: "close-terminal-pane";
-};
-export type WorkspaceCapabilityActionType = WorkspaceCapabilityAction["type"];
-export type WorkspaceActionGateResult = {
-    readonly kind: "allowed";
-    readonly action: WorkspaceCapabilityAction;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-export declare function gateWorkspaceAction(agent: ManagedAgentDescriptor, action: WorkspaceCapabilityAction): WorkspaceActionGateResult;
-export declare function availableWorkspaceActions(agent: ManagedAgentDescriptor): readonly WorkspaceCapabilityActionType[];