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

package/dist/features/workspace/capabilities.js

@@ -1,75 +0,0 @@
-const STRUCTURED_ACTIONS = [
-    "structured-command",
-    "cancel-structured-command",
-    "restore-structured-snapshot",
-    "send-structured-attachment",
-];
-const COMPOSED_ACTIONS = [
-    "create-terminal-pane",
-    "apply-terminal-layout",
-    "focus-terminal-pane",
-    "close-terminal-pane",
-];
-export function gateWorkspaceAction(agent, action) {
-    const capability = agent.capability;
-    if (capability.kind === "structured") {
-        if (!isStructuredAction(action.type)) {
-            return reject("capability-mismatch", `agent ${agent.id} is structured and cannot use composed pane action ${action.type}`);
-        }
-        switch (action.type) {
-            case "structured-command":
-                return capability.commands.includes(action.command)
-                    ? allow(action)
-                    : reject("unsupported-command", `structured agent ${agent.id} does not declare command ${action.command}`);
-            case "cancel-structured-command":
-                return capability.cancellation === "correlated"
-                    ? allow(action)
-                    : reject("unsupported-cancellation", `structured agent ${agent.id} did not negotiate correlated cancellation`);
-            case "restore-structured-snapshot":
-                return capability.snapshots === "authoritative"
-                    ? allow(action)
-                    : reject("unsupported-snapshot", `structured agent ${agent.id} does not provide authoritative snapshots`);
-            case "send-structured-attachment":
-                return capability.attachmentTypes.includes(action.attachmentType)
-                    ? allow(action)
-                    : reject("unsupported-attachment", `structured agent ${agent.id} does not declare attachment type ${action.attachmentType}`);
-        }
-    }
-    if (isStructuredAction(action.type)) {
-        return reject("capability-mismatch", `agent ${agent.id} is terminal-backed and cannot use structured action ${action.type}`);
-    }
-    if (!isComposedAction(action.type))
-        return reject("invalid-action", `workspace action is invalid: ${action.type}`);
-    if (capability.proofStatus !== "accepted") {
-        return reject("composed-unavailable", `composed pane action ${action.type} is unavailable until native-host proof is accepted (current: ${capability.proofStatus})`);
-    }
-    return allow(action);
-}
-export function availableWorkspaceActions(agent) {
-    const capability = agent.capability;
-    if (capability.kind === "structured") {
-        const actions = [];
-        if (capability.commands.length > 0)
-            actions.push("structured-command");
-        if (capability.cancellation === "correlated")
-            actions.push("cancel-structured-command");
-        if (capability.snapshots === "authoritative")
-            actions.push("restore-structured-snapshot");
-        if (capability.attachmentTypes.length > 0)
-            actions.push("send-structured-attachment");
-        return Object.freeze(actions);
-    }
-    return capability.proofStatus === "accepted" ? Object.freeze([...COMPOSED_ACTIONS]) : Object.freeze([]);
-}
-function isStructuredAction(type) {
-    return STRUCTURED_ACTIONS.includes(type);
-}
-function isComposedAction(type) {
-    return COMPOSED_ACTIONS.includes(type);
-}
-function allow(action) {
-    return { kind: "allowed", action };
-}
-function reject(code, diagnostic) {
-    return { kind: "rejected", code, diagnostic };
-}

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

@@ -1,6 +0,0 @@
-export * from "./capabilities.js";
-export * from "./presentation.js";
-export * from "./reconciliation.js";
-export * from "./reducer.js";
-export * from "./router.js";
-export * from "./store.js";

package/dist/features/workspace/index.js

@@ -1,6 +0,0 @@
-export * from "./capabilities.js";
-export * from "./presentation.js";
-export * from "./reconciliation.js";
-export * from "./reducer.js";
-export * from "./router.js";
-export * from "./store.js";

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

@@ -1,30 +0,0 @@
-import { type WorkspaceCapabilityActionType } from "./capabilities.js";
-import type { WorkspaceAgentState, WorkspaceView } from "./reducer.js";
-export interface WorkspacePresentationOptions {
-    readonly maxRows?: number;
-    readonly maxLabelWidth?: number;
-}
-export interface WorkspaceAgentPresentationRow {
-    readonly role: "option";
-    readonly agentId: string;
-    readonly label: string;
-    readonly selected: boolean;
-    readonly lifecycle: WorkspaceAgentState["lifecycle"];
-    readonly unreadActivity: number;
-    readonly attention: boolean;
-    readonly failure: string | null;
-    readonly actions: readonly WorkspaceCapabilityActionType[];
-    readonly text: string;
-    readonly accessibleDescription: string;
-}
-export interface WorkspacePresentationModel {
-    readonly role: "listbox";
-    readonly label: string;
-    readonly selectedAgentId: string | null;
-    readonly rows: readonly WorkspaceAgentPresentationRow[];
-    readonly overflowCount: number;
-    readonly emptyMessage: string | null;
-    readonly text: string;
-}
-export declare function presentWorkspace(view: WorkspaceView, options?: WorkspacePresentationOptions): WorkspacePresentationModel;
-export declare function workspaceSelectionForKey(view: WorkspaceView, key: "ArrowDown" | "ArrowUp" | "Home" | "End"): string | null;

package/dist/features/workspace/presentation.js

@@ -1,70 +0,0 @@
-import { availableWorkspaceActions } from "./capabilities.js";
-import { PRODUCT_TEXT } from "../../product-identity.js";
-const WORKSPACE_LABEL = `${PRODUCT_TEXT.displayName} agents`;
-export function presentWorkspace(view, options = {}) {
-    const maxRows = boundedInteger(options.maxRows ?? 8, 1, 100, "maximum workspace rows");
-    const maxLabelWidth = boundedInteger(options.maxLabelWidth ?? 32, 8, 64, "maximum workspace label width");
-    const rows = view.agents.slice(0, maxRows).map(agent => presentAgent(agent, view.selectedAgentId === agent.id, maxLabelWidth));
-    const overflowCount = Math.max(0, view.agents.length - rows.length);
-    const text = rows.length === 0
-        ? `${WORKSPACE_LABEL}\nNo managed agents.`
-        : [WORKSPACE_LABEL, ...rows.map(row => row.text), ...(overflowCount > 0 ? [`… ${overflowCount} more`] : [])].join("\n");
-    return Object.freeze({
-        role: "listbox",
-        label: WORKSPACE_LABEL,
-        selectedAgentId: view.selectedAgentId,
-        rows: Object.freeze(rows),
-        overflowCount,
-        emptyMessage: rows.length === 0 ? "No managed agents." : null,
-        text,
-    });
-}
-export function workspaceSelectionForKey(view, key) {
-    if (view.agents.length === 0)
-        return null;
-    const currentIndex = Math.max(0, view.agents.findIndex(agent => agent.id === view.selectedAgentId));
-    switch (key) {
-        case "ArrowDown":
-            return view.agents[Math.min(view.agents.length - 1, currentIndex + 1)]?.id ?? null;
-        case "ArrowUp":
-            return view.agents[Math.max(0, currentIndex - 1)]?.id ?? null;
-        case "Home":
-            return view.agents[0]?.id ?? null;
-        case "End":
-            return view.agents[view.agents.length - 1]?.id ?? null;
-    }
-}
-function presentAgent(agent, selected, maxLabelWidth) {
-    const label = truncate(agent.displayName, maxLabelWidth);
-    const badges = [
-        agent.lifecycle,
-        agent.unreadActivity > 0 ? `${agent.unreadActivity} unread` : null,
-        agent.attention ? "attention" : null,
-    ].filter((value) => value !== null).join(", ");
-    const failure = agent.failure ? `${agent.failure.code}: ${agent.failure.message}` : null;
-    const actions = availableWorkspaceActions(agent);
-    return Object.freeze({
-        role: "option",
-        agentId: agent.id,
-        label,
-        selected,
-        lifecycle: agent.lifecycle,
-        unreadActivity: agent.unreadActivity,
-        attention: agent.attention,
-        failure,
-        actions,
-        text: `${selected ? "›" : " "} ${label} — ${badges}`,
-        accessibleDescription: [agent.lifecycle, agent.unreadActivity > 0 ? `${agent.unreadActivity} unread` : null, agent.attention ? "needs attention" : null, failure]
-            .filter((value) => value !== null)
-            .join("; "),
-    });
-}
-function truncate(value, width) {
-    return value.length <= width ? value : `${value.slice(0, width - 1)}…`;
-}
-function boundedInteger(value, minimum, maximum, name) {
-    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
-        throw new RangeError(`${name} must be an integer from ${minimum} to ${maximum}`);
-    }
-    return value;
-}

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

@@ -1,15 +0,0 @@
-import { type StructuredResumeProof } from "../../foundation/structured-agent-runtime/index.js";
-import { WorkspaceReducer } from "./reducer.js";
-import { WorkspaceStore } from "./store.js";
-export interface WorkspaceReconciliationEntry {
-    readonly agentId: string;
-    readonly outcome: "unchanged" | "ready" | "ended" | "discontinuous";
-    readonly code: string | null;
-    readonly diagnostic: string;
-}
-export interface WorkspaceReconciliationReport {
-    readonly reconciledAt: string;
-    readonly revision: number;
-    readonly entries: readonly WorkspaceReconciliationEntry[];
-}
-export declare function reconcileWorkspaceRestart(reducer: WorkspaceReducer, store: WorkspaceStore, proofs: ReadonlyMap<string, StructuredResumeProof>, reconciledAt?: string): WorkspaceReconciliationReport;

package/dist/features/workspace/reconciliation.js

@@ -1,82 +0,0 @@
-import { StructuredReconnectionManager, } from "../../foundation/structured-agent-runtime/index.js";
-import { WorkspaceReducer } from "./reducer.js";
-import { WorkspaceStore } from "./store.js";
-export function reconcileWorkspaceRestart(reducer, store, proofs, reconciledAt = new Date().toISOString()) {
-    const entries = [];
-    for (const agent of reducer.view().agents) {
-        if (agent.lifecycle === "stopped" || agent.lifecycle === "failed" || agent.lifecycle === "discontinuous") {
-            entries.push(entry(agent.id, "unchanged", null, "agent is already terminal or discontinuous"));
-            continue;
-        }
-        if (!agent.recoveryReferenceId) {
-            reducer.markDiscontinuous(agent.id, "missing-recovery-authority", "agent has no durable recovery authority");
-            entries.push(entry(agent.id, "discontinuous", "missing-recovery-authority", "agent has no durable recovery authority"));
-            continue;
-        }
-        const reference = store.loadRecoveryReference(agent.recoveryReferenceId);
-        if (!reference) {
-            reducer.markDiscontinuous(agent.id, "missing-recovery-reference", "recovery reference is absent from the control store");
-            entries.push(entry(agent.id, "discontinuous", "missing-recovery-reference", "recovery reference is absent from the control store"));
-            continue;
-        }
-        const authority = reference.authority;
-        if (authority.agentId !== agent.id || authority.kind !== agent.capability.kind) {
-            reducer.markDiscontinuous(agent.id, "authority-mismatch", "recovery authority does not match the durable agent identity or runtime");
-            persistRecoveryOutcome(store, authority, reference.status, "rejected", reconciledAt, "authority mismatch during workspace restart");
-            entries.push(entry(agent.id, "discontinuous", "authority-mismatch", "recovery authority does not match the durable agent identity or runtime"));
-            continue;
-        }
-        if (authority.kind === "composed-terminal") {
-            reducer.markDiscontinuous(agent.id, "native-host-unavailable", "native-host recovery is unavailable until its accepted proof capability is enabled");
-            persistRecoveryOutcome(store, authority, reference.status, "discontinuous", reconciledAt, "native-host recovery unavailable");
-            entries.push(entry(agent.id, "discontinuous", "native-host-unavailable", "native-host recovery is unavailable until its accepted proof capability is enabled"));
-            continue;
-        }
-        const proof = proofs.get(agent.id);
-        if (!proof) {
-            reducer.markDiscontinuous(agent.id, "missing-resume-proof", "adapter did not provide a resume proof during reconciliation");
-            persistRecoveryOutcome(store, authority, reference.status, "discontinuous", reconciledAt, "missing resume proof");
-            entries.push(entry(agent.id, "discontinuous", "missing-resume-proof", "adapter did not provide a resume proof during reconciliation"));
-            continue;
-        }
-        if (agent.capability.kind !== "structured") {
-            reducer.markDiscontinuous(agent.id, "capability-mismatch", "structured proof cannot recover a non-structured agent");
-            persistRecoveryOutcome(store, authority, reference.status, "rejected", reconciledAt, "structured proof capability mismatch");
-            entries.push(entry(agent.id, "discontinuous", "capability-mismatch", "structured proof cannot recover a non-structured agent"));
-            continue;
-        }
-        const result = new StructuredReconnectionManager(agent.capability).resume(authority, proof, null);
-        if (result.kind === "accepted") {
-            reducer.markRecovered(agent.id);
-            persistRecoveryOutcome(store, authority, reference.status, "accepted", reconciledAt, "verified ownership and resume boundary");
-            entries.push(entry(agent.id, "ready", null, result.diagnostic));
-        }
-        else if (result.kind === "terminated") {
-            reducer.stopAgent(agent.id);
-            persistRecoveryOutcome(store, authority, reference.status, "discontinuous", reconciledAt, result.diagnostic);
-            entries.push(entry(agent.id, "ended", "non-reconnectable", result.diagnostic));
-        }
-        else {
-            reducer.markDiscontinuous(agent.id, result.code, result.diagnostic);
-            persistRecoveryOutcome(store, authority, reference.status, "rejected", reconciledAt, result.diagnostic);
-            entries.push(entry(agent.id, "discontinuous", result.code, result.diagnostic));
-        }
-    }
-    store.save(reducer);
-    return Object.freeze({
-        reconciledAt,
-        revision: reducer.view().revision,
-        entries: Object.freeze(entries),
-    });
-}
-function persistRecoveryOutcome(store, authority, previousStatus, status, reconciledAt, reason) {
-    store.persistRecoveryReference(authority, status, {
-        previousStatus,
-        reason,
-        reconciledAt,
-        rollbackToStatus: previousStatus,
-    }, reconciledAt);
-}
-function entry(agentId, outcome, code, diagnostic) {
-    return Object.freeze({ agentId, outcome, code, diagnostic });
-}

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

@@ -1,43 +0,0 @@
-import { type ManagedAgentDescriptor } from "../../contracts/workspace/index.js";
-export interface WorkspaceAgentFailure {
-    readonly code: string;
-    readonly message: string;
-}
-export interface WorkspaceAgentState extends ManagedAgentDescriptor {
-    readonly unreadActivity: number;
-    readonly attention: boolean;
-    readonly failure: WorkspaceAgentFailure | null;
-}
-export interface WorkspaceView {
-    readonly workspaceId: string;
-    readonly revision: number;
-    readonly selectedAgentId: string | null;
-    readonly agents: readonly WorkspaceAgentState[];
-}
-export type WorkspaceReducerResult<T = undefined> = {
-    readonly kind: "applied";
-    readonly view: WorkspaceView;
-    readonly value: T;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-/** Applies validated workspace mutations and advances the revision only when observable state changes. */
-export declare class WorkspaceReducer {
-    #private;
-    readonly workspaceId: string;
-    constructor(workspaceId: string, agents?: readonly WorkspaceAgentState[], selectedAgentId?: string | null, revision?: number);
-    createAgent(descriptor: ManagedAgentDescriptor): WorkspaceReducerResult<WorkspaceAgentState>;
-    selectAgent(agentId: string): WorkspaceReducerResult<WorkspaceAgentState>;
-    renameAgent(agentId: string, displayName: string): WorkspaceReducerResult<string>;
-    stopAgent(agentId: string): WorkspaceReducerResult<WorkspaceAgentState>;
-    restartAgent(agentId: string): WorkspaceReducerResult<WorkspaceAgentState>;
-    removeAgent(agentId: string): WorkspaceReducerResult<WorkspaceAgentState>;
-    recordActivity(agentId: string, amount?: number): WorkspaceReducerResult<number>;
-    requestAttention(agentId: string): WorkspaceReducerResult<WorkspaceAgentState>;
-    markRecovered(agentId: string): WorkspaceReducerResult<WorkspaceAgentState>;
-    markDiscontinuous(agentId: string, code: string, message: string): WorkspaceReducerResult<WorkspaceAgentState>;
-    markFailed(agentId: string, code: string, message: string): WorkspaceReducerResult<WorkspaceAgentState>;
-    view(): WorkspaceView;
-}

package/dist/features/workspace/reducer.js

@@ -1,214 +0,0 @@
-import { assertManagedAgentDescriptor, } from "../../contracts/workspace/index.js";
-const REMOVABLE_STATES = new Set(["stopped", "failed", "discontinuous"]);
-/** Applies validated workspace mutations and advances the revision only when observable state changes. */
-export class WorkspaceReducer {
-    workspaceId;
-    #agents = new Map();
-    #selectedAgentId;
-    #revision;
-    constructor(workspaceId, agents = [], selectedAgentId = null, revision = 0) {
-        this.workspaceId = workspaceId;
-        if (!workspaceId || workspaceId.includes("\0"))
-            throw new TypeError("workspace id is invalid");
-        if (!Number.isSafeInteger(revision) || revision < 0)
-            throw new RangeError("workspace revision must be a non-negative safe integer");
-        for (const agent of agents) {
-            assertWorkspaceAgent(agent);
-            if (this.#agents.has(agent.id))
-                throw new TypeError(`duplicate workspace agent id: ${agent.id}`);
-            this.#agents.set(agent.id, { ...agent });
-        }
-        if (selectedAgentId !== null && !this.#agents.has(selectedAgentId))
-            throw new TypeError("selected workspace agent must exist");
-        this.#selectedAgentId = selectedAgentId ?? agents[0]?.id ?? null;
-        this.#revision = revision;
-    }
-    createAgent(descriptor) {
-        try {
-            assertManagedAgentDescriptor(descriptor);
-        }
-        catch (error) {
-            return rejected("invalid-agent", error);
-        }
-        if (this.#agents.has(descriptor.id))
-            return rejected("duplicate-agent", new Error(`workspace agent id already exists: ${descriptor.id}`));
-        const agent = {
-            ...descriptor,
-            displayName: this.#uniqueDisplayName(descriptor.displayName),
-            unreadActivity: 0,
-            attention: false,
-            failure: null,
-        };
-        this.#agents.set(agent.id, agent);
-        this.#selectedAgentId ??= agent.id;
-        this.#revision += 1;
-        return applied(this.view(), Object.freeze({ ...agent }));
-    }
-    selectAgent(agentId) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        const changed = this.#selectedAgentId !== agentId || agent.unreadActivity !== 0 || agent.attention;
-        this.#selectedAgentId = agentId;
-        agent.unreadActivity = 0;
-        agent.attention = false;
-        if (changed)
-            this.#revision += 1;
-        return applied(this.view(), Object.freeze({ ...agent }));
-    }
-    renameAgent(agentId, displayName) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        try {
-            assertDisplayName(displayName);
-        }
-        catch (error) {
-            return rejected("invalid-display-name", error);
-        }
-        agent.displayName = this.#uniqueDisplayName(displayName, agentId);
-        this.#revision += 1;
-        return applied(this.view(), agent.displayName);
-    }
-    stopAgent(agentId) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        if (agent.lifecycle !== "stopped") {
-            agent.lifecycle = "stopped";
-            agent.unreadActivity = 0;
-            agent.attention = false;
-            this.#revision += 1;
-        }
-        return applied(this.view(), Object.freeze({ ...agent }));
-    }
-    restartAgent(agentId) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        agent.lifecycle = "creating";
-        agent.unreadActivity = 0;
-        agent.attention = false;
-        agent.failure = null;
-        this.#revision += 1;
-        return applied(this.view(), Object.freeze({ ...agent }));
-    }
-    removeAgent(agentId) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        if (!REMOVABLE_STATES.has(agent.lifecycle)) {
-            return rejected("agent-active", new Error(`workspace agent must be stopped, failed, or discontinuous before removal: ${agentId}`));
-        }
-        const removed = Object.freeze({ ...agent });
-        this.#agents.delete(agentId);
-        if (this.#selectedAgentId === agentId)
-            this.#selectedAgentId = this.#agents.keys().next().value ?? null;
-        this.#revision += 1;
-        return applied(this.view(), removed);
-    }
-    recordActivity(agentId, amount = 1) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        if (!Number.isSafeInteger(amount) || amount <= 0)
-            return rejected("invalid-activity", new Error("workspace unread activity amount must be positive"));
-        if (this.#selectedAgentId !== agentId) {
-            agent.unreadActivity += amount;
-            this.#revision += 1;
-        }
-        return applied(this.view(), agent.unreadActivity);
-    }
-    requestAttention(agentId) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        if (!agent.attention) {
-            agent.attention = true;
-            if (this.#selectedAgentId !== agentId && agent.unreadActivity === 0)
-                agent.unreadActivity = 1;
-            this.#revision += 1;
-        }
-        return applied(this.view(), Object.freeze({ ...agent }));
-    }
-    markRecovered(agentId) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        agent.lifecycle = "ready";
-        agent.unreadActivity = 0;
-        agent.attention = false;
-        agent.failure = null;
-        this.#revision += 1;
-        return applied(this.view(), Object.freeze({ ...agent }));
-    }
-    markDiscontinuous(agentId, code, message) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        if (!code || code.length > 128 || code.includes("\0") || !message || message.length > 4_096 || message.includes("\0")) {
-            return rejected("invalid-failure", new Error("workspace discontinuity code and message must be bounded non-empty values"));
-        }
-        agent.lifecycle = "discontinuous";
-        agent.failure = Object.freeze({ code, message });
-        agent.attention = true;
-        this.#revision += 1;
-        return applied(this.view(), Object.freeze({ ...agent }));
-    }
-    markFailed(agentId, code, message) {
-        const agent = this.#agents.get(agentId);
-        if (!agent)
-            return unknownAgent(agentId);
-        if (!code || code.length > 128 || code.includes("\0") || !message || message.length > 4_096 || message.includes("\0")) {
-            return rejected("invalid-failure", new Error("workspace failure code and message must be bounded non-empty values"));
-        }
-        agent.lifecycle = "failed";
-        agent.failure = Object.freeze({ code, message });
-        agent.attention = true;
-        this.#revision += 1;
-        return applied(this.view(), Object.freeze({ ...agent }));
-    }
-    view() {
-        return Object.freeze({
-            workspaceId: this.workspaceId,
-            revision: this.#revision,
-            selectedAgentId: this.#selectedAgentId,
-            agents: Object.freeze([...this.#agents.values()].map(agent => Object.freeze({ ...agent }))),
-        });
-    }
-    #uniqueDisplayName(requested, excludeAgentId = null) {
-        assertDisplayName(requested);
-        const used = new Set([...this.#agents.values()].filter(agent => agent.id !== excludeAgentId).map(agent => agent.displayName));
-        if (!used.has(requested))
-            return requested;
-        for (let suffix = 2; suffix < 1_000_000; suffix += 1) {
-            const candidate = `${requested} (${suffix})`;
-            if (!used.has(candidate))
-                return candidate;
-        }
-        throw new RangeError("workspace display name suffix budget is exhausted");
-    }
-}
-function applied(view, value) {
-    return { kind: "applied", view, value };
-}
-function rejected(code, error) {
-    return { kind: "rejected", code, diagnostic: error instanceof Error ? error.message : String(error) };
-}
-function unknownAgent(agentId) {
-    return rejected("unknown-agent", new Error(`workspace agent does not exist: ${agentId}`));
-}
-function assertWorkspaceAgent(agent) {
-    assertManagedAgentDescriptor(agent);
-    if (!Number.isSafeInteger(agent.unreadActivity) || agent.unreadActivity < 0)
-        throw new RangeError("workspace unread activity is invalid");
-    if (typeof agent.attention !== "boolean")
-        throw new TypeError("workspace attention is invalid");
-    if (agent.failure !== null && (!agent.failure.code || !agent.failure.message))
-        throw new TypeError("workspace failure is invalid");
-}
-function assertDisplayName(value) {
-    if (typeof value !== "string" || value.length === 0 || value.length > 256 || value.includes("\0")) {
-        throw new TypeError("workspace display name is invalid");
-    }
-}

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

@@ -1,32 +0,0 @@
-import { type StructuredCommandRecord } from "../../foundation/structured-agent-runtime/index.js";
-import type { ManagedAgentDescriptor } from "../../contracts/workspace/index.js";
-import { WorkspaceReducer, type WorkspaceAgentState, type WorkspaceView } from "./reducer.js";
-export interface RoutedStructuredCommand {
-    readonly agentId: string;
-    readonly correlationId: string;
-    readonly command: string;
-    readonly record: StructuredCommandRecord;
-}
-export type WorkspaceRouterResult<T = undefined> = {
-    readonly kind: "applied";
-    readonly view: WorkspaceView;
-    readonly value: T;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-/** Serializes workspace actions and capability-gates structured commands at the selected-agent boundary. */
-export declare class WorkspaceRouter {
-    #private;
-    readonly reducer: WorkspaceReducer;
-    constructor(reducer: WorkspaceReducer);
-    createAgent(agent: ManagedAgentDescriptor): Promise<WorkspaceRouterResult<WorkspaceAgentState>>;
-    selectAgent(agentId: string): Promise<WorkspaceRouterResult<WorkspaceAgentState>>;
-    stopAgent(agentId: string): Promise<WorkspaceRouterResult<WorkspaceAgentState>>;
-    removeAgent(agentId: string): Promise<WorkspaceRouterResult<WorkspaceAgentState>>;
-    recordActivity(agentId: string, amount?: number): Promise<WorkspaceRouterResult<number>>;
-    sendStructuredCommand(agentId: string, command: string, payload: unknown): Promise<WorkspaceRouterResult<RoutedStructuredCommand>>;
-    cancelStructuredCommand(agentId: string, targetCorrelationId: string): Promise<WorkspaceRouterResult<StructuredCommandRecord>>;
-    view(): WorkspaceView;
-}