@timurproko/a1 0.1.1-dev.3 → 0.1.1-dev.4

package/bin/a1-ui.js

@@ -4,11 +4,11 @@ const { runSelectedInteractiveRuntime } = await import("../dist/src/features/lau
 
 runSelectedInteractiveRuntime(process.env.A1_LAUNCH_PROFILE ?? "a1", {
   ownedUi: async () => {
-    const [{ runOwnedUi }, { composeStructuredWorkspaceApplication }] = await Promise.all([
+    const [{ runOwnedUi }, { composeOwnedUiApplication }] = await Promise.all([
       import("../dist/src/features/owned-ui/index.js"),
       import("../dist/src/composition/index.js"),
     ]);
-    const application = await composeStructuredWorkspaceApplication({ cwd: process.cwd() });
+    const application = await composeOwnedUiApplication({ cwd: process.cwd() });
     return await runOwnedUi({ application });
   },
   transparent: async profileId => {

package/dist/src/composition/index.d.ts

@@ -1,9 +1,6 @@
 import { type AgentEnginePort } from "../foundation/agent-engine-contracts/index.js";
 import { type PiEngineAdapter } from "../foundation/pi-engine-adapter/index.js";
 import { type OwnedUiApplicationPort, type PresentationComponentPort, type PresentationRuntimePort, type PresentationTerminalPort } from "../foundation/presentation-contracts/index.js";
-import { StructuredWorkspaceTabs, type StructuredWorkspaceLimits } from "../features/workspace/index.js";
-import { StructuredWorkspaceApplication } from "./structured-workspace-application.js";
-export * from "./structured-workspace-application.js";
 export interface ProcessCompositionOptions {
     readonly cwd?: string;
     readonly sessionId?: string;
@@ -17,21 +14,6 @@ export interface OwnedUiCompositionOptions {
     readonly createPiAdapter?: () => Promise<PiEngineAdapter>;
 }
 export declare function composeOwnedUiApplication(options?: OwnedUiCompositionOptions): Promise<OwnedUiApplicationPort>;
-export interface StructuredWorkspaceCompositionOptions {
-    readonly cwd?: string;
-    readonly workspaceId?: string;
-    readonly limits?: Partial<StructuredWorkspaceLimits>;
-    readonly createEngine?: (agentId: string) => Promise<AgentEnginePort>;
-    readonly createPiAdapter?: (agentId: string) => Promise<PiEngineAdapter>;
-}
-export declare function composeStructuredWorkspace(options?: StructuredWorkspaceCompositionOptions): StructuredWorkspaceTabs;
-export interface StructuredWorkspaceApplicationCompositionOptions extends StructuredWorkspaceCompositionOptions {
-    readonly terminal?: PresentationTerminalPort;
-    readonly mode?: "regular" | "fullscreen";
-    readonly initialAgentId?: string;
-    readonly initialAgentName?: string;
-}
-export declare function composeStructuredWorkspaceApplication(options?: StructuredWorkspaceApplicationCompositionOptions): Promise<StructuredWorkspaceApplication>;
 export interface ProcessComposition {
     readonly engine: AgentEnginePort;
     createPresentation(root: PresentationComponentPort, terminal: PresentationTerminalPort): PresentationRuntimePort;

package/dist/src/composition/index.js

@@ -3,9 +3,6 @@ import { createPiEngineAdapter } from "../foundation/pi-engine-adapter/index.js"
 import { createPiPresentationRuntime, createPiTerminalBridge } from "../foundation/pi-tui-runtime-adapter/index.js";
 import { assertPresentationComponent, assertPresentationRuntime, } from "../foundation/presentation-contracts/index.js";
 import { OwnedUiSessionShell } from "../foundation/pi-owned-ui-integration/index.js";
-import { StructuredWorkspaceTabs, } from "../features/workspace/index.js";
-import { StructuredWorkspaceApplication } from "./structured-workspace-application.js";
-export * from "./structured-workspace-application.js";
 const CAPABILITIES = {
     contractVersion: AGENT_ENGINE_CONTRACT_VERSION,
     commands: ["prompt", "steer", "follow-up", "abort", "retry", "compact", "bash", "replace-session"],
@@ -28,39 +25,6 @@ export async function composeOwnedUiApplication(options = {}) {
         dispose: () => shell.dispose(),
     };
 }
-export function composeStructuredWorkspace(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const createEngine = options.createEngine ?? (async (agentId) => {
-        const sessionId = `${agentId}.session`;
-        const adapter = options.createPiAdapter
-            ? await options.createPiAdapter(agentId)
-            : await createPiEngineAdapter({ cwd, sessionId });
-        return new PiAgentEngineBridge(adapter, cwd);
-    });
-    return new StructuredWorkspaceTabs({
-        cwd,
-        createEngine,
-        ...(options.workspaceId === undefined ? {} : { workspaceId: options.workspaceId }),
-        ...(options.limits === undefined ? {} : { limits: options.limits }),
-    });
-}
-export async function composeStructuredWorkspaceApplication(options = {}) {
-    const workspace = composeStructuredWorkspace(options);
-    const created = await workspace.createAgent({
-        id: options.initialAgentId ?? "agent-1",
-        displayName: options.initialAgentName ?? "Agent 1",
-    });
-    if (created.kind === "rejected") {
-        await workspace.dispose();
-        throw new Error(`could not create the initial structured workspace agent: ${created.diagnostic}`);
-    }
-    return new StructuredWorkspaceApplication({
-        workspace,
-        cwd: options.cwd ?? process.cwd(),
-        ...(options.terminal === undefined ? {} : { terminal: options.terminal }),
-        ...(options.mode === undefined ? {} : { mode: options.mode }),
-    });
-}
 export async function composeProcess(options = {}) {
     let engine = options.engine;
     if (!engine) {

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

@@ -4,4 +4,3 @@ export * from "./reconciliation.js";
 export * from "./reducer.js";
 export * from "./router.js";
 export * from "./store.js";
-export * from "./structured-tabs.js";

package/dist/src/features/workspace/index.js

@@ -4,4 +4,3 @@ export * from "./reconciliation.js";
 export * from "./reducer.js";
 export * from "./router.js";
 export * from "./store.js";
-export * from "./structured-tabs.js";

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

@@ -22,15 +22,10 @@ export declare class WorkspaceRouter {
     constructor(reducer: WorkspaceReducer);
     createAgent(agent: ManagedAgentDescriptor): Promise<WorkspaceRouterResult<WorkspaceAgentState>>;
     selectAgent(agentId: string): Promise<WorkspaceRouterResult<WorkspaceAgentState>>;
-    restartAgent(agentId: string): Promise<WorkspaceRouterResult<WorkspaceAgentState>>;
-    markRecovered(agentId: string): Promise<WorkspaceRouterResult<WorkspaceAgentState>>;
-    markFailed(agentId: string, code: string, message: string): Promise<WorkspaceRouterResult<WorkspaceAgentState>>;
-    requestAttention(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>>;
-    settleStructuredCommand(agentId: string, correlationId: string, outcome: "completed" | "failed"): Promise<WorkspaceRouterResult<StructuredCommandRecord>>;
     view(): WorkspaceView;
 }

package/dist/src/features/workspace/router.js

@@ -23,18 +23,6 @@ export class WorkspaceRouter {
     selectAgent(agentId) {
         return this.#enqueue(() => this.reducer.selectAgent(agentId));
     }
-    restartAgent(agentId) {
-        return this.#enqueue(() => this.reducer.restartAgent(agentId));
-    }
-    markRecovered(agentId) {
-        return this.#enqueue(() => this.reducer.markRecovered(agentId));
-    }
-    markFailed(agentId, code, message) {
-        return this.#enqueue(() => this.reducer.markFailed(agentId, code, message));
-    }
-    requestAttention(agentId) {
-        return this.#enqueue(() => this.reducer.requestAttention(agentId));
-    }
     stopAgent(agentId) {
         return this.#enqueue(() => this.reducer.stopAgent(agentId));
     }
@@ -104,20 +92,6 @@ export class WorkspaceRouter {
             return applied(this.reducer.view(), result.record);
         });
     }
-    settleStructuredCommand(agentId, correlationId, outcome) {
-        return this.#enqueue(() => {
-            const agent = this.reducer.view().agents.find(candidate => candidate.id === agentId);
-            if (!agent)
-                return reject("unknown-agent", `workspace agent does not exist: ${agentId}`);
-            const tracker = this.#trackerFor(agent);
-            if (!tracker)
-                return reject("capability-mismatch", `agent ${agent.id} is not structured`);
-            const result = tracker.complete(correlationId, outcome);
-            if (result.kind === "rejected")
-                return result;
-            return applied(this.reducer.view(), result.record);
-        });
-    }
     view() {
         return this.reducer.view();
     }

package/dist/src/foundation/release/bootstrap.js

@@ -42,9 +42,7 @@ export async function runBootstrap(options) {
             return await launchUi(retained, environment);
         }
     }
-    const candidate = await materializeRelease(options.packageRoot, paths.dataDir, {
-        onProgress: progress => output.write(`${PRODUCT_TEXT.diagnostic(`installing ${progress.fileCount} files.`)}\n`),
-    });
+    const candidate = await materializeRelease(options.packageRoot, paths.dataDir);
     await stateStore.recordCandidate(candidate);
     state = await stateStore.read();
     if (!state.references.active) {

package/dist/src/foundation/release/update.js

@@ -106,9 +106,7 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
             }
         },
         async activateInstalled(packageRoot, targetVersion, phase) {
-            const candidate = await materializeRelease(packageRoot, paths.dataDir, {
-                onProgress: progress => output.stdout(`${PRODUCT_TEXT.diagnostic(`installing ${progress.fileCount} files.`)}\n`),
-            });
+            const candidate = await materializeRelease(packageRoot, paths.dataDir);
             if (candidate.packageVersion !== targetVersion)
                 throw new Error(`installed ${PRODUCT_TEXT.displayName} version ${candidate.packageVersion} does not match target ${targetVersion}`);
             await stateStore.recordCandidate(candidate);
@@ -198,14 +196,20 @@ export async function runSelfUpdate(options) {
             transaction = await transactionStore.advance("ownership-released");
         }
         if (phaseBefore(transaction.phase, "package-installed")) {
-            output.stdout(`${PRODUCT_TEXT.diagnostic(`is installing ${PRODUCT_TEXT.packageName}@${targetVersion}.`)}\n`);
-            const installation = await runNpm(runner, ["install", "--global", `${PRODUCT_PACKAGE}@${targetVersion}`], false, output, "start the global npm installation", false);
+            const installation = await runNpm(runner, ["install", "--global", "--loglevel=error", "--no-fund", "--no-audit", `${PRODUCT_PACKAGE}@${targetVersion}`], true, output, "start the global npm installation", false);
             if (installation.result === null)
                 throw new UpdateFailure(installation.exitCode, "npm process failed");
-            if (installation.result.code !== 0)
+            if (installation.result.code !== 0) {
+                if (installation.result.stdout.trim().length > 0)
+                    output.stderr(`${installation.result.stdout.trimEnd()}\n`);
                 throw new UpdateFailure(unsuccessfulCode(installation.result.code), `npm exited with status ${formatExitCode(installation.result.code)}`);
+            }
             transaction = await transactionStore.advance("package-installed");
         }
+        // Ownership can be reacquired after an interrupted installation (for
+        // example, if bare A1 is launched before the update is resumed). Recheck
+        // immediately before activation so recovery cannot start a second cohort.
+        await lifecycle.shutdownVerifiedOwners(targetVersion);
         await lifecycle.activateInstalled(packageRoot, targetVersion, async (phase) => { transaction = await transactionStore.advance(phase); });
         await transactionStore.advance("supervisor-verified");
         await transactionStore.finish("completed");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.1-dev.3",
+  "version": "0.1.1-dev.4",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",

package/dist/src/composition/structured-workspace-application.d.ts

@@ -1,38 +0,0 @@
-import { OwnedUiSessionShellRoot } from "../foundation/pi-owned-ui-integration/index.js";
-import { PiTuiRuntimeAdapter, type PiTuiComponentPort } from "../foundation/pi-tui-runtime-adapter/index.js";
-import type { OwnedUiApplicationPort, PresentationTerminalPort } from "../foundation/presentation-contracts/index.js";
-import { type StructuredWorkspaceTabs } from "../features/workspace/index.js";
-export interface StructuredWorkspaceApplicationOptions {
-    readonly workspace: StructuredWorkspaceTabs;
-    readonly cwd: string;
-    readonly terminal?: PresentationTerminalPort;
-    readonly mode?: "regular" | "fullscreen";
-}
-export declare class StructuredWorkspaceApplication implements OwnedUiApplicationPort {
-    #private;
-    readonly workspace: StructuredWorkspaceTabs;
-    readonly root: OwnedUiSessionShellRoot;
-    readonly runtime: PiTuiRuntimeAdapter;
-    readonly component: StructuredWorkspaceRootComponent;
-    constructor(options: StructuredWorkspaceApplicationOptions);
-    get disposed(): boolean;
-    start(): void;
-    flush(): Promise<void>;
-    waitUntilStopped(): Promise<void>;
-    submit(raw: string): Promise<void>;
-    switchRelative(direction: -1 | 1): Promise<void>;
-    dispose(): Promise<void>;
-}
-export declare class StructuredWorkspaceRootComponent implements PiTuiComponentPort {
-    readonly workspace: StructuredWorkspaceTabs;
-    readonly sessionRoot: OwnedUiSessionShellRoot;
-    readonly onSwitch: (direction: -1 | 1) => void;
-    readonly onEditorChange: (text: string) => void;
-    readonly notice: () => string | null;
-    constructor(workspace: StructuredWorkspaceTabs, sessionRoot: OwnedUiSessionShellRoot, onSwitch: (direction: -1 | 1) => void, onEditorChange: (text: string) => void, notice: () => string | null);
-    render(width: number): readonly string[];
-    handleInput(data: string): void;
-    invalidate(): void;
-    setFocused(focused: boolean): void;
-    dispose(): void;
-}

package/dist/src/composition/structured-workspace-application.js

@@ -1,261 +0,0 @@
-import { OWNED_UI_CONTRACT_VERSION, } from "../foundation/owned-ui-contracts/index.js";
-import { OwnedUiSessionShellRoot } from "../foundation/pi-owned-ui-integration/index.js";
-import { createPiTerminalBridge, PiTuiRuntimeAdapter, } from "../foundation/pi-tui-runtime-adapter/index.js";
-import {} from "../features/workspace/index.js";
-export class StructuredWorkspaceApplication {
-    workspace;
-    root;
-    runtime;
-    component;
-    #unsubscribe;
-    #resolveStopped;
-    #stopped;
-    #notice = null;
-    #disposed = false;
-    #started = false;
-    #agentSequence;
-    constructor(options) {
-        this.workspace = options.workspace;
-        const initial = selectedPanel(options.workspace.view());
-        if (!initial)
-            throw new TypeError("structured workspace application requires an initial agent tab");
-        this.#agentSequence = options.workspace.view().panels.length;
-        this.#stopped = new Promise(resolve => { this.#resolveStopped = resolve; });
-        this.root = new OwnedUiSessionShellRoot(toOwnedView(options.workspace.view(), initial, null, 80, 24), options.cwd, {
-            getColumns: () => this.runtime?.viewport().columns ?? options.terminal?.columns ?? 80,
-            getRows: () => this.runtime?.viewport().rows ?? options.terminal?.rows ?? 24,
-            requestRender: () => this.runtime?.requestRender(),
-            onSubmit: text => { void this.submit(text); },
-            onInterrupt: () => { this.#notice = "Use /agent stop to stop the selected agent."; this.runtime?.requestRender(); },
-            onClear: () => { this.root.editor.setText(""); this.runtime?.requestRender(); },
-            onExit: () => { void this.dispose(); },
-            onModelSelect: () => { this.#notice = "Model selection remains scoped to each structured agent session."; this.runtime?.requestRender(); },
-            onThinkingCycle: () => { this.#notice = "Thinking settings remain scoped to each structured agent session."; this.runtime?.requestRender(); },
-        });
-        this.component = new StructuredWorkspaceRootComponent(this.workspace, this.root, direction => { void this.switchRelative(direction); }, text => this.#saveEditor(text), () => this.#notice);
-        this.runtime = new PiTuiRuntimeAdapter({
-            root: this.component,
-            mode: options.mode ?? "regular",
-            ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
-            hardwareCursor: true,
-            mouse: false,
-        });
-        this.#unsubscribe = this.workspace.subscribe(view => this.#sync(view));
-    }
-    get disposed() { return this.#disposed; }
-    start() {
-        if (this.#started || this.#disposed)
-            return;
-        this.#started = true;
-        this.runtime.start();
-        this.#sync(this.workspace.view());
-    }
-    async flush() {
-        await this.workspace.flush();
-        this.#sync(this.workspace.view());
-    }
-    waitUntilStopped() { return this.#stopped; }
-    async submit(raw) {
-        const input = raw.trim();
-        if (!input)
-            return;
-        if (input === "/agent" || input.startsWith("/agent ")) {
-            await this.#agentCommand(input.slice("/agent".length).trim());
-            return;
-        }
-        const selected = selectedPanel(this.workspace.view());
-        if (!selected)
-            return;
-        this.workspace.setEditorText(selected.agentId, input);
-        const result = await this.workspace.sendPrompt(selected.agentId, input);
-        this.#notice = result.kind === "rejected" ? result.diagnostic : null;
-        this.#sync(this.workspace.view());
-    }
-    async switchRelative(direction) {
-        const view = this.workspace.view();
-        if (view.panels.length < 2)
-            return;
-        this.#saveEditor(this.root.editor.getText());
-        const current = Math.max(0, view.panels.findIndex(panel => panel.selected));
-        const next = (current + direction + view.panels.length) % view.panels.length;
-        const target = view.panels[next];
-        if (target)
-            await this.workspace.selectAgent(target.agentId);
-    }
-    async dispose() {
-        if (this.#disposed)
-            return;
-        this.#disposed = true;
-        this.#unsubscribe();
-        const failures = [];
-        await this.runtime.stop().catch(error => failures.push(error));
-        await this.workspace.dispose().catch(error => failures.push(error));
-        this.#resolveStopped?.();
-        if (failures.length > 0)
-            throw new AggregateError(failures, "structured workspace application disposal failed");
-    }
-    async #agentCommand(argument) {
-        const [command = "list", ...rest] = argument.split(/\s+/).filter(Boolean);
-        const view = this.workspace.view();
-        const selected = selectedPanel(view);
-        if (command === "new") {
-            this.#agentSequence += 1;
-            const id = `agent-${this.#agentSequence}`;
-            const displayName = rest.join(" ") || `Agent ${this.#agentSequence}`;
-            const created = await this.workspace.createAgent({ id, displayName });
-            if (created.kind === "applied")
-                await this.workspace.selectAgent(id);
-            this.#notice = created.kind === "rejected" ? created.diagnostic : `Created ${created.value.agentId}.`;
-        }
-        else if (command === "next" || command === "previous" || command === "prev") {
-            await this.switchRelative(command === "next" ? 1 : -1);
-            this.#notice = null;
-        }
-        else if (command === "select") {
-            const target = rest[0];
-            const selectedResult = target ? await this.workspace.selectAgent(target) : null;
-            this.#notice = selectedResult === null ? "Usage: /agent select <id>" : selectedResult.kind === "rejected" ? selectedResult.diagnostic : null;
-        }
-        else if (command === "stop") {
-            const result = selected ? await this.workspace.stopAgent(selected.agentId) : null;
-            this.#notice = result === null ? "No agent selected." : result.kind === "rejected" ? result.diagnostic : `Stopped ${selected.agentId}.`;
-        }
-        else if (command === "restart") {
-            const result = selected ? await this.workspace.restartAgent(selected.agentId) : null;
-            this.#notice = result === null ? "No agent selected." : result.kind === "rejected" ? result.diagnostic : `Restarted ${selected.agentId}.`;
-        }
-        else if (command === "remove") {
-            if (!selected)
-                this.#notice = "No agent selected.";
-            else {
-                if (selected.lifecycle !== "stopped" && selected.lifecycle !== "failed")
-                    await this.workspace.stopAgent(selected.agentId);
-                const result = await this.workspace.removeAgent(selected.agentId);
-                this.#notice = result.kind === "rejected" ? result.diagnostic : `Removed ${selected.agentId}.`;
-            }
-        }
-        else if (command === "list") {
-            this.#notice = view.tabs.length === 0 ? "No managed agents." : view.tabs.map(tab => `${tab.selected ? "*" : " "}${tab.agentId}:${tab.label}`).join("  ");
-        }
-        else {
-            this.#notice = "Usage: /agent [list|new [name]|next|prev|select <id>|stop|restart|remove]";
-        }
-        this.#sync(this.workspace.view());
-    }
-    #saveEditor(text) {
-        const selected = selectedPanel(this.workspace.view());
-        if (selected)
-            this.workspace.setEditorText(selected.agentId, text);
-    }
-    #sync(view) {
-        const selected = selectedPanel(view);
-        if (!selected)
-            return;
-        const viewport = this.runtime?.viewport() ?? { columns: 80, rows: 24 };
-        this.root.update(toOwnedView(view, selected, this.#notice, viewport.columns, viewport.rows));
-        if (this.root.editor.getText() !== selected.editorText)
-            this.root.editor.setText(selected.editorText);
-        this.component.invalidate();
-        this.runtime?.requestRender();
-    }
-}
-export class StructuredWorkspaceRootComponent {
-    workspace;
-    sessionRoot;
-    onSwitch;
-    onEditorChange;
-    notice;
-    constructor(workspace, sessionRoot, onSwitch, onEditorChange, notice) {
-        this.workspace = workspace;
-        this.sessionRoot = sessionRoot;
-        this.onSwitch = onSwitch;
-        this.onEditorChange = onEditorChange;
-        this.notice = notice;
-    }
-    render(width) {
-        const view = this.workspace.view();
-        const tabLine = truncate(view.tabs.map(tab => `${tab.selected ? "[" : " "}${tab.label}${tab.selected ? "]" : " "}`).join("  "), width);
-        const notice = this.notice();
-        return [tabLine, ...(notice ? [truncate(notice, width)] : []), ...this.sessionRoot.render(width)];
-    }
-    handleInput(data) {
-        if (data === "\x1b[6;5~" || data === "\x1b[1;3C") {
-            this.onEditorChange(this.sessionRoot.editor.getText());
-            this.onSwitch(1);
-            return;
-        }
-        if (data === "\x1b[5;5~" || data === "\x1b[1;3D") {
-            this.onEditorChange(this.sessionRoot.editor.getText());
-            this.onSwitch(-1);
-            return;
-        }
-        this.sessionRoot.editor.handleInput?.(data);
-    }
-    invalidate() { this.sessionRoot.invalidate(); }
-    setFocused(focused) { this.sessionRoot.editor.setFocused?.(focused); }
-    dispose() { this.sessionRoot.dispose?.(); }
-}
-function selectedPanel(view) {
-    return view.selectedPanel ?? view.panels[0] ?? null;
-}
-function toOwnedView(workspace, panel, notice, columns, rows) {
-    const agent = workspace.workspace.agents.find(candidate => candidate.id === panel.agentId);
-    return {
-        contractVersion: OWNED_UI_CONTRACT_VERSION,
-        sessionId: panel.sessionId,
-        revision: workspace.workspace.revision + panel.lastSequence,
-        lifecycle: ownedLifecycle(panel.lifecycle),
-        transcript: panel.transcript.flatMap(messageBlocks),
-        editor: {
-            text: panel.editorText,
-            queuedSubmissions: [],
-            selection: null,
-            cursorOffset: panel.editorText.length,
-            historyRevision: panel.lastSequence,
-            submitEnabled: panel.lifecycle !== "stopping" && panel.lifecycle !== "stopped" && panel.lifecycle !== "failed",
-        },
-        status: {
-            title: agent?.displayName ?? panel.agentId,
-            workingMessage: panel.lifecycle === "busy" ? "Working" : null,
-            diagnostics: panel.failure ? [panel.failure] : notice ? [notice] : [],
-            badges: [
-                `${workspace.panels.length} agents`,
-                ...(agent?.unreadActivity ? [`${agent.unreadActivity} unread`] : []),
-                ...(agent?.attention ? ["attention"] : []),
-            ],
-            footer: { branch: null, sessionName: agent?.displayName ?? null, availableProviderCount: 0, extensionStatuses: [] },
-        },
-        terminal: { columns, rows, focusedRegion: "editor", hardwareCursor: true },
-        activeModel: null,
-        thinkingLevel: "medium",
-        activeCommandIds: panel.activeCommandIds,
-        dialog: null,
-        overlay: null,
-        customizations: [],
-        diagnostics: panel.failure ? [{ sequence: panel.lastSequence, code: "structured-agent", severity: "error", message: panel.failure, recoverable: true }] : [],
-    };
-}
-function messageBlocks(message) {
-    return message.content.map((content, index) => {
-        const base = { id: `${message.id}.${index}`, status: message.status === "streaming" ? "live" : "finalized", revision: index + 1, title: null };
-        if (content.kind === "thinking")
-            return { ...base, kind: "thinking", text: content.text, payload: {} };
-        if (content.kind === "tool-call")
-            return { ...base, kind: "tool-call", title: content.toolName, text: JSON.stringify(content.input), payload: content };
-        if (content.kind === "tool-result")
-            return { ...base, kind: "tool-result", text: JSON.stringify(content.output), payload: content };
-        if (content.kind === "image")
-            return { ...base, kind: "custom", title: content.mediaType, text: "[image]", payload: content };
-        if (content.kind === "unknown")
-            return { ...base, kind: "custom", title: content.sourceType, text: JSON.stringify(content.payload), payload: content };
-        return { ...base, kind: message.role === "user" ? "user" : message.role === "system" ? "system" : message.role === "tool" ? "tool-result" : "assistant", text: content.text, payload: {} };
-    });
-}
-function ownedLifecycle(lifecycle) {
-    return lifecycle;
-}
-function truncate(value, width) {
-    if (width <= 0)
-        return "";
-    return value.length <= width ? value : width === 1 ? "…" : `${value.slice(0, width - 1)}…`;
-}

package/dist/src/features/workspace/structured-tabs.d.ts

@@ -1,83 +0,0 @@
-import { type AgentCommandOutcome, type AgentEnginePort, type AgentMessage, type AgentSessionLifecycle } from "../../foundation/agent-engine-contracts/index.js";
-import { type WorkspacePresentationModel } from "./presentation.js";
-import { type WorkspaceView } from "./reducer.js";
-import { WorkspaceRouter } from "./router.js";
-export interface StructuredWorkspaceLimits {
-    readonly maxAgents: number;
-    readonly maxMessagesPerAgent: number;
-    readonly maxMessageBytes: number;
-    readonly maxEditorBytes: number;
-}
-export interface StructuredWorkspaceTabsOptions {
-    readonly workspaceId?: string;
-    readonly cwd: string;
-    readonly createEngine: (agentId: string) => Promise<AgentEnginePort>;
-    readonly limits?: Partial<StructuredWorkspaceLimits>;
-    readonly now?: () => string;
-}
-export interface StructuredAgentTabView {
-    readonly role: "tabpanel";
-    readonly agentId: string;
-    readonly sessionId: string;
-    readonly selected: boolean;
-    readonly lifecycle: AgentSessionLifecycle;
-    readonly transcript: readonly AgentMessage[];
-    readonly toolMessages: readonly AgentMessage[];
-    readonly editorText: string;
-    readonly activeCommandIds: readonly string[];
-    readonly lastSequence: number;
-    readonly failure: string | null;
-    readonly accessibleDescription: string;
-}
-export interface StructuredWorkspaceTabSelector {
-    readonly role: "tab";
-    readonly agentId: string;
-    readonly label: string;
-    readonly selected: boolean;
-    readonly accessibleDescription: string;
-}
-export interface StructuredWorkspaceTabsView {
-    readonly role: "tablist";
-    readonly workspace: WorkspaceView;
-    readonly presentation: WorkspacePresentationModel;
-    readonly tabs: readonly StructuredWorkspaceTabSelector[];
-    readonly panels: readonly StructuredAgentTabView[];
-    readonly selectedPanel: StructuredAgentTabView | null;
-}
-export type StructuredWorkspaceTabsResult<T> = {
-    readonly kind: "applied";
-    readonly view: StructuredWorkspaceTabsView;
-    readonly value: T;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-export declare class StructuredWorkspaceTabs {
-    #private;
-    readonly router: WorkspaceRouter;
-    constructor(options: StructuredWorkspaceTabsOptions);
-    subscribe(listener: (view: StructuredWorkspaceTabsView) => void): () => void;
-    createAgent(input: {
-        readonly id: string;
-        readonly displayName: string;
-        readonly sessionId?: string;
-    }): Promise<StructuredWorkspaceTabsResult<StructuredAgentTabView>>;
-    selectAgent(agentId: string): Promise<StructuredWorkspaceTabsResult<StructuredAgentTabView>>;
-    setEditorText(agentId: string, text: string): StructuredWorkspaceTabsResult<StructuredAgentTabView>;
-    submitSelected(): Promise<StructuredWorkspaceTabsResult<{
-        readonly correlationId: string;
-        readonly outcome: AgentCommandOutcome;
-    }>>;
-    sendPrompt(agentId: string, text: string): Promise<StructuredWorkspaceTabsResult<{
-        readonly correlationId: string;
-        readonly outcome: AgentCommandOutcome;
-    }>>;
-    stopAgent(agentId: string): Promise<StructuredWorkspaceTabsResult<StructuredAgentTabView>>;
-    restartAgent(agentId: string): Promise<StructuredWorkspaceTabsResult<StructuredAgentTabView>>;
-    refreshAgent(agentId: string): Promise<StructuredWorkspaceTabsResult<StructuredAgentTabView>>;
-    removeAgent(agentId: string): Promise<StructuredWorkspaceTabsResult<string>>;
-    flush(): Promise<void>;
-    view(): StructuredWorkspaceTabsView;
-    dispose(): Promise<void>;
-}

package/dist/src/features/workspace/structured-tabs.js

@@ -1,453 +0,0 @@
-import { AGENT_ENGINE_CONTRACT_VERSION, assertAgentCapabilityContract, assertAgentEvent, assertAgentSnapshot, } from "../../foundation/agent-engine-contracts/index.js";
-import { WORKSPACE_CONTRACT_VERSION, } from "../../foundation/workspace-contracts/index.js";
-import { presentWorkspace } from "./presentation.js";
-import { WorkspaceReducer } from "./reducer.js";
-import { WorkspaceRouter } from "./router.js";
-const DEFAULT_LIMITS = Object.freeze({
-    maxAgents: 8,
-    maxMessagesPerAgent: 512,
-    maxMessageBytes: 256 * 1024,
-    maxEditorBytes: 64 * 1024,
-});
-export class StructuredWorkspaceTabs {
-    router;
-    #cwd;
-    #createEngine;
-    #limits;
-    #now;
-    #tabs = new Map();
-    #listeners = new Set();
-    #disposed = false;
-    constructor(options) {
-        if (!options.cwd || options.cwd.includes("\0"))
-            throw new TypeError("structured workspace cwd is invalid");
-        if (typeof options.createEngine !== "function")
-            throw new TypeError("structured workspace engine factory is required");
-        this.#cwd = options.cwd;
-        this.#createEngine = options.createEngine;
-        this.#limits = validateLimits({ ...DEFAULT_LIMITS, ...options.limits });
-        this.#now = options.now ?? (() => new Date().toISOString());
-        this.router = new WorkspaceRouter(new WorkspaceReducer(options.workspaceId ?? "workspace-default"));
-    }
-    subscribe(listener) {
-        this.#listeners.add(listener);
-        listener(this.view());
-        return () => this.#listeners.delete(listener);
-    }
-    async createAgent(input) {
-        if (this.#disposed)
-            return rejected("workspace-disposed", "structured workspace is disposed");
-        if (this.#tabs.size >= this.#limits.maxAgents)
-            return rejected("agent-limit", `structured workspace is limited to ${this.#limits.maxAgents} agents`);
-        if (this.#tabs.has(input.id))
-            return rejected("duplicate-agent", `structured workspace agent already exists: ${input.id}`);
-        const sessionId = input.sessionId ?? `${input.id}.session`;
-        let runtime;
-        try {
-            runtime = await this.#createRuntime(input.id, sessionId);
-        }
-        catch (error) {
-            return rejected("engine-start-failed", diagnostic(error));
-        }
-        const descriptor = {
-            id: input.id,
-            displayName: input.displayName,
-            adapterId: `engine.${input.id}`,
-            runtime: "structured",
-            lifecycle: workspaceLifecycle(runtime.snapshot.lifecycle),
-            capability: workspaceCapability(runtime.engine, input.id, this.#limits),
-            createdAt: this.#now(),
-            recoveryReferenceId: null,
-        };
-        const created = await this.router.createAgent(descriptor);
-        if (created.kind === "rejected") {
-            await disposeRuntime(runtime.session, runtime.engine);
-            return created;
-        }
-        const tab = {
-            agentId: input.id,
-            sessionId,
-            engine: runtime.engine,
-            session: runtime.session,
-            unsubscribe: () => { },
-            eventTail: Promise.resolve(),
-            lifecycle: runtime.snapshot.lifecycle,
-            transcript: this.#boundedSnapshot(runtime.snapshot),
-            editorText: "",
-            activeCommandIds: new Set(runtime.snapshot.activeCommandIds),
-            lastSequence: runtime.snapshot.sequence,
-            failure: null,
-        };
-        tab.unsubscribe = tab.session.subscribe(event => this.#queueEvent(tab, event));
-        this.#tabs.set(input.id, tab);
-        await this.#reflectLifecycle(tab, runtime.snapshot.lifecycle, null);
-        this.#notify();
-        return applied(this.view(), this.#tabView(tab));
-    }
-    async selectAgent(agentId) {
-        const selected = await this.router.selectAgent(agentId);
-        if (selected.kind === "rejected")
-            return selected;
-        const tab = this.#tabs.get(agentId);
-        if (!tab)
-            return rejected("missing-runtime", `structured runtime is missing for ${agentId}`);
-        this.#notify();
-        return applied(this.view(), this.#tabView(tab));
-    }
-    setEditorText(agentId, text) {
-        const tab = this.#tabs.get(agentId);
-        if (!tab)
-            return rejected("unknown-agent", `structured workspace agent does not exist: ${agentId}`);
-        if (typeof text !== "string" || byteLength(text) > this.#limits.maxEditorBytes) {
-            return rejected("editor-limit", `structured editor exceeds ${this.#limits.maxEditorBytes} bytes`);
-        }
-        tab.editorText = text;
-        this.#notify();
-        return applied(this.view(), this.#tabView(tab));
-    }
-    async submitSelected() {
-        const selectedAgentId = this.router.view().selectedAgentId;
-        if (!selectedAgentId)
-            return rejected("no-selected-agent", "no structured workspace agent is selected");
-        const tab = this.#tabs.get(selectedAgentId);
-        if (!tab)
-            return rejected("missing-runtime", `structured runtime is missing for ${selectedAgentId}`);
-        return await this.sendPrompt(selectedAgentId, tab.editorText);
-    }
-    async sendPrompt(agentId, text) {
-        if (typeof text !== "string" || text.length === 0)
-            return rejected("empty-prompt", "structured prompt must not be empty");
-        if (byteLength(text) > this.#limits.maxEditorBytes)
-            return rejected("editor-limit", `structured prompt exceeds ${this.#limits.maxEditorBytes} bytes`);
-        const routed = await this.router.sendStructuredCommand(agentId, "prompt", { text });
-        if (routed.kind === "rejected")
-            return routed;
-        const tab = this.#tabs.get(agentId);
-        if (!tab)
-            return rejected("missing-runtime", `structured runtime is missing for ${agentId}`);
-        const correlationId = routed.value.correlationId;
-        tab.activeCommandIds.add(correlationId);
-        if (tab.editorText === text)
-            tab.editorText = "";
-        let outcome;
-        try {
-            outcome = await tab.session.execute({
-                contractVersion: AGENT_ENGINE_CONTRACT_VERSION,
-                type: "prompt",
-                commandId: correlationId,
-                sessionId: tab.sessionId,
-                text,
-            });
-        }
-        catch (error) {
-            outcome = "failed";
-            await this.#failTab(tab, "command-failed", diagnostic(error));
-        }
-        if (outcome !== "accepted") {
-            tab.activeCommandIds.delete(correlationId);
-            await this.router.settleStructuredCommand(agentId, correlationId, outcome === "completed" ? "completed" : "failed");
-        }
-        this.#notify();
-        return applied(this.view(), { correlationId, outcome });
-    }
-    async stopAgent(agentId) {
-        const tab = this.#tabs.get(agentId);
-        if (!tab)
-            return rejected("unknown-agent", `structured workspace agent does not exist: ${agentId}`);
-        tab.unsubscribe();
-        try {
-            await disposeRuntime(tab.session, tab.engine);
-        }
-        catch (error) {
-            await this.#failTab(tab, "stop-failed", diagnostic(error));
-            return rejected("stop-failed", diagnostic(error));
-        }
-        tab.lifecycle = "stopped";
-        tab.activeCommandIds.clear();
-        const stopped = await this.router.stopAgent(agentId);
-        if (stopped.kind === "rejected")
-            return stopped;
-        this.#notify();
-        return applied(this.view(), this.#tabView(tab));
-    }
-    async restartAgent(agentId) {
-        const tab = this.#tabs.get(agentId);
-        if (!tab)
-            return rejected("unknown-agent", `structured workspace agent does not exist: ${agentId}`);
-        await this.router.restartAgent(agentId);
-        tab.unsubscribe();
-        await disposeRuntime(tab.session, tab.engine).catch(() => undefined);
-        try {
-            const runtime = await this.#createRuntime(agentId, tab.sessionId);
-            tab.engine = runtime.engine;
-            tab.session = runtime.session;
-            tab.lifecycle = runtime.snapshot.lifecycle;
-            tab.transcript = this.#boundedSnapshot(runtime.snapshot);
-            tab.activeCommandIds = new Set(runtime.snapshot.activeCommandIds);
-            tab.lastSequence = runtime.snapshot.sequence;
-            tab.failure = null;
-            tab.eventTail = Promise.resolve();
-            tab.unsubscribe = tab.session.subscribe(event => this.#queueEvent(tab, event));
-            await this.#reflectLifecycle(tab, runtime.snapshot.lifecycle, null);
-            this.#notify();
-            return applied(this.view(), this.#tabView(tab));
-        }
-        catch (error) {
-            await this.#failTab(tab, "restart-failed", diagnostic(error));
-            return rejected("restart-failed", diagnostic(error));
-        }
-    }
-    async refreshAgent(agentId) {
-        const tab = this.#tabs.get(agentId);
-        if (!tab)
-            return rejected("unknown-agent", `structured workspace agent does not exist: ${agentId}`);
-        try {
-            const snapshot = await tab.session.snapshot();
-            assertAgentSnapshot(snapshot);
-            if (snapshot.sessionId !== tab.sessionId)
-                throw new TypeError("structured snapshot session identity changed");
-            tab.lifecycle = snapshot.lifecycle;
-            tab.transcript = this.#boundedSnapshot(snapshot);
-            tab.activeCommandIds = new Set(snapshot.activeCommandIds);
-            tab.lastSequence = snapshot.sequence;
-            tab.failure = null;
-            await this.#reflectLifecycle(tab, snapshot.lifecycle, null);
-            this.#notify();
-            return applied(this.view(), this.#tabView(tab));
-        }
-        catch (error) {
-            await this.#failTab(tab, "snapshot-failed", diagnostic(error));
-            return rejected("snapshot-failed", diagnostic(error));
-        }
-    }
-    async removeAgent(agentId) {
-        const tab = this.#tabs.get(agentId);
-        if (!tab)
-            return rejected("unknown-agent", `structured workspace agent does not exist: ${agentId}`);
-        const removed = await this.router.removeAgent(agentId);
-        if (removed.kind === "rejected")
-            return removed;
-        tab.unsubscribe();
-        await disposeRuntime(tab.session, tab.engine).catch(() => undefined);
-        this.#tabs.delete(agentId);
-        this.#notify();
-        return applied(this.view(), agentId);
-    }
-    async flush() {
-        await Promise.all([...this.#tabs.values()].map(tab => tab.eventTail));
-    }
-    view() {
-        const workspace = this.router.view();
-        const panels = workspace.agents.flatMap(agent => {
-            const tab = this.#tabs.get(agent.id);
-            return tab ? [this.#tabView(tab)] : [];
-        });
-        const presentation = presentWorkspace(workspace);
-        const rows = new Map(presentation.rows.map(row => [row.agentId, row]));
-        const tabs = panels.map(panel => {
-            const row = rows.get(panel.agentId);
-            return Object.freeze({
-                role: "tab",
-                agentId: panel.agentId,
-                label: row?.label ?? panel.agentId,
-                selected: panel.selected,
-                accessibleDescription: row?.accessibleDescription ?? panel.accessibleDescription,
-            });
-        });
-        return Object.freeze({
-            role: "tablist",
-            workspace,
-            presentation,
-            tabs: Object.freeze(tabs),
-            panels: Object.freeze(panels),
-            selectedPanel: panels.find(panel => panel.selected) ?? null,
-        });
-    }
-    async dispose() {
-        if (this.#disposed)
-            return;
-        this.#disposed = true;
-        const failures = [];
-        for (const tab of [...this.#tabs.values()].reverse()) {
-            tab.unsubscribe();
-            await tab.eventTail.catch(error => failures.push(error));
-            await disposeRuntime(tab.session, tab.engine).catch(error => failures.push(error));
-        }
-        this.#tabs.clear();
-        this.#listeners.clear();
-        if (failures.length > 0)
-            throw new AggregateError(failures, "structured workspace disposal failed");
-    }
-    async #createRuntime(agentId, sessionId) {
-        const engine = await this.#createEngine(agentId);
-        try {
-            assertAgentCapabilityContract(engine.capabilities);
-            const session = await engine.createSession({ sessionId, cwd: this.#cwd });
-            assertAgentCapabilityContract(session.capabilities);
-            const snapshot = await session.snapshot();
-            assertAgentSnapshot(snapshot);
-            if (session.sessionId !== sessionId || snapshot.sessionId !== sessionId)
-                throw new TypeError("structured session identity does not match its workspace tab");
-            return { engine, session, snapshot };
-        }
-        catch (error) {
-            await engine.dispose().catch(() => undefined);
-            throw error;
-        }
-    }
-    #queueEvent(tab, event) {
-        tab.eventTail = tab.eventTail
-            .then(() => this.#applyEvent(tab, event))
-            .catch(error => this.#failTab(tab, "event-failed", diagnostic(error)))
-            .then(() => this.#notify());
-    }
-    async #applyEvent(tab, event) {
-        assertAgentEvent(event, tab.session.capabilities);
-        if (event.sessionId !== tab.sessionId)
-            throw new TypeError("structured event crossed workspace tab identity");
-        if (event.sequence <= tab.lastSequence)
-            return;
-        if (event.sequence !== tab.lastSequence + 1 || event.type === "snapshot-invalidated") {
-            await this.refreshAgent(tab.agentId);
-            return;
-        }
-        tab.lastSequence = event.sequence;
-        if (event.type === "content") {
-            this.#appendMessage(tab, event.content);
-            await this.router.recordActivity(tab.agentId);
-            return;
-        }
-        if (event.type === "lifecycle") {
-            tab.lifecycle = event.lifecycle;
-            await this.#reflectLifecycle(tab, event.lifecycle, event.reason);
-            return;
-        }
-        if (event.type === "command-outcome") {
-            tab.activeCommandIds.delete(event.commandId);
-            await this.router.settleStructuredCommand(tab.agentId, event.commandId, event.outcome === "completed" ? "completed" : "failed");
-            if (event.outcome === "failed")
-                await this.router.requestAttention(tab.agentId);
-            return;
-        }
-        if (event.type === "diagnostic") {
-            if (event.recoverable)
-                await this.router.requestAttention(tab.agentId);
-            else
-                await this.#failTab(tab, event.code, event.message);
-        }
-    }
-    #appendMessage(tab, message) {
-        if (byteLength(JSON.stringify(message)) > this.#limits.maxMessageBytes)
-            throw new RangeError("structured message exceeds its workspace tab byte limit");
-        tab.transcript.push(message);
-        while (tab.transcript.length > this.#limits.maxMessagesPerAgent)
-            tab.transcript.shift();
-    }
-    #boundedSnapshot(snapshot) {
-        if (byteLength(JSON.stringify(snapshot)) > snapshot.capabilities.snapshots.maxBytes)
-            throw new RangeError("structured snapshot exceeds its negotiated byte limit");
-        const messages = snapshot.content.slice(-this.#limits.maxMessagesPerAgent);
-        for (const message of messages) {
-            if (byteLength(JSON.stringify(message)) > this.#limits.maxMessageBytes)
-                throw new RangeError("structured snapshot message exceeds its workspace tab byte limit");
-        }
-        return [...messages];
-    }
-    async #reflectLifecycle(tab, lifecycle, reason) {
-        if (lifecycle === "ready" || lifecycle === "busy")
-            await this.router.markRecovered(tab.agentId);
-        else if (lifecycle === "starting")
-            await this.router.restartAgent(tab.agentId);
-        else if (lifecycle === "stopped")
-            await this.router.stopAgent(tab.agentId);
-        else if (lifecycle === "failed")
-            await this.#failTab(tab, "engine-failed", reason ?? "structured engine failed");
-    }
-    async #failTab(tab, code, message) {
-        tab.lifecycle = "failed";
-        tab.failure = `${code}: ${message}`;
-        tab.activeCommandIds.clear();
-        await this.router.markFailed(tab.agentId, code, message);
-    }
-    #notify() {
-        const view = this.view();
-        for (const listener of this.#listeners)
-            listener(view);
-    }
-    #tabView(tab) {
-        const selected = this.router.view().selectedAgentId === tab.agentId;
-        const toolMessages = tab.transcript.filter(message => message.role === "tool" || message.content.some(content => content.kind === "tool-call" || content.kind === "tool-result"));
-        return Object.freeze({
-            role: "tabpanel",
-            agentId: tab.agentId,
-            sessionId: tab.sessionId,
-            selected,
-            lifecycle: tab.lifecycle,
-            transcript: Object.freeze([...tab.transcript]),
-            toolMessages: Object.freeze(toolMessages),
-            editorText: tab.editorText,
-            activeCommandIds: Object.freeze([...tab.activeCommandIds]),
-            lastSequence: tab.lastSequence,
-            failure: tab.failure,
-            accessibleDescription: `${selected ? "selected" : "background"} structured agent ${tab.agentId}; ${tab.lifecycle}; ${tab.transcript.length} messages`,
-        });
-    }
-}
-function workspaceCapability(engine, agentId, limits) {
-    return {
-        kind: "structured",
-        protocolVersion: WORKSPACE_CONTRACT_VERSION,
-        adapterId: `engine.${agentId}`,
-        commands: Object.freeze([...engine.capabilities.commands]),
-        eventTypes: Object.freeze([...engine.capabilities.events]),
-        snapshots: engine.capabilities.snapshots.supported ? "authoritative" : "none",
-        resume: engine.capabilities.snapshots.supported ? "snapshot" : "none",
-        cancellation: engine.capabilities.commands.includes("abort") ? "correlated" : "none",
-        attachmentTypes: Object.freeze([]),
-        flow: Object.freeze({
-            maxEventBytes: limits.maxMessageBytes,
-            maxSnapshotBytes: engine.capabilities.snapshots.maxBytes,
-            maxAttachmentBytes: limits.maxMessageBytes,
-            maxQueuedEvents: limits.maxMessagesPerAgent,
-            maxConcurrentCommands: 4,
-            maxReconnectEvents: limits.maxMessagesPerAgent,
-        }),
-    };
-}
-function workspaceLifecycle(lifecycle) {
-    if (lifecycle === "starting")
-        return "creating";
-    if (lifecycle === "stopping")
-        return "stopping";
-    if (lifecycle === "stopped")
-        return "stopped";
-    if (lifecycle === "failed")
-        return "failed";
-    return "ready";
-}
-function validateLimits(limits) {
-    for (const [name, value] of Object.entries(limits)) {
-        if (!Number.isSafeInteger(value) || value <= 0)
-            throw new RangeError(`structured workspace ${name} must be a positive safe integer`);
-    }
-    return Object.freeze(limits);
-}
-async function disposeRuntime(session, engine) {
-    const failures = [];
-    await session.dispose().catch(error => failures.push(error));
-    await engine.dispose().catch(error => failures.push(error));
-    if (failures.length > 0)
-        throw new AggregateError(failures, "structured agent runtime disposal failed");
-}
-function applied(view, value) {
-    return { kind: "applied", view, value };
-}
-function rejected(code, message) {
-    return { kind: "rejected", code, diagnostic: message };
-}
-function diagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function byteLength(value) {
-    return new TextEncoder().encode(value).byteLength;
-}