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

package/dist/integrations/pi/engine/command-dispatch.d.ts

@@ -0,0 +1,41 @@
+import { type OwnedUiCommand, type OwnedUiCommandOutcome, type OwnedUiDiagnostics } from "../../../contracts/owned-ui/index.js";
+import type { PiEmittedEvent } from "./event-delivery.js";
+export interface AdapterCommandResult {
+    readonly outcome: OwnedUiCommandOutcome;
+    readonly diagnostic: string | null;
+}
+export interface PiCommandDispatchPorts {
+    sessionId(): string;
+    /** True before the runtime and session exist or after disposal: commands are rejected, not queued. */
+    notRunning(): boolean;
+    /** True while delivery is overloaded or admission is stopped. */
+    admissionStopped(): boolean;
+    /** Workflows currently admitted; they share the admission budget with commands. */
+    pendingWorkflowCount(): number;
+    sessionGeneration(): number;
+    beginRunning(): void;
+    endRunning(): void;
+    /** Carry out one admitted command against the engine; a throw becomes a failed outcome. */
+    perform(command: OwnedUiCommand): Promise<void>;
+    emit(value: PiEmittedEvent): void;
+    emitView(): void;
+    diagnostic(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable: boolean): void;
+}
+/**
+ * Admission and settlement of owned UI commands: the accepted/completed/failed/rejected outcome
+ * events, the bounded pending set with its out-of-band cancellation slot per command, the active
+ * ids the view reports, and the remembered results that make a retried correlation id idempotent.
+ * What a command does to the engine is the adapter's `perform` port.
+ */
+export declare class PiCommandDispatch {
+    #private;
+    constructor(ports: PiCommandDispatchPorts);
+    get activeCommandIds(): readonly string[];
+    get pendingCount(): number;
+    isPending(correlationId: string): boolean;
+    /** Resolve every admitted command as failed, except the listed types. */
+    cancelPending(except?: readonly OwnedUiCommand["type"][]): void;
+    /** Forget active ids and remembered results; a new session binding cannot inherit them. */
+    reset(): void;
+    execute(command: OwnedUiCommand): Promise<AdapterCommandResult>;
+}

package/dist/integrations/pi/engine/command-dispatch.js

@@ -0,0 +1,125 @@
+import { assertOwnedUiCommand } from "../../../contracts/owned-ui/index.js";
+/** How many commands and workflows may be admitted together before new work is rejected. */
+const MAX_PENDING_WORK = 32;
+/** Completed results remembered so a retried correlation id gets its original outcome. */
+const MAX_COMPLETED_COMMANDS = 256;
+/**
+ * Admission and settlement of owned UI commands: the accepted/completed/failed/rejected outcome
+ * events, the bounded pending set with its out-of-band cancellation slot per command, the active
+ * ids the view reports, and the remembered results that make a retried correlation id idempotent.
+ * What a command does to the engine is the adapter's `perform` port.
+ */
+export class PiCommandDispatch {
+    #ports;
+    #activeCommandIds = [];
+    #completedCommands = new Map();
+    #pendingCommands = new Map();
+    constructor(ports) {
+        this.#ports = ports;
+    }
+    get activeCommandIds() {
+        return this.#activeCommandIds;
+    }
+    get pendingCount() {
+        return this.#pendingCommands.size;
+    }
+    isPending(correlationId) {
+        return this.#pendingCommands.has(correlationId);
+    }
+    /** Resolve every admitted command as failed, except the listed types. */
+    cancelPending(except = []) {
+        for (const pending of this.#pendingCommands.values())
+            if (!except.includes(pending.type))
+                pending.cancel();
+    }
+    /** Forget active ids and remembered results; a new session binding cannot inherit them. */
+    reset() {
+        this.#activeCommandIds = [];
+        this.#completedCommands.clear();
+    }
+    async execute(command) {
+        assertOwnedUiCommand(command);
+        if (command.sessionId !== this.#ports.sessionId()) {
+            return this.#finishCommand(command, "rejected", "command targets a different owned session");
+        }
+        if (this.#ports.notRunning()) {
+            return this.#finishCommand(command, "rejected", "engine adapter is not running");
+        }
+        // Invariant: the bounded out-of-band cancellation path has one slot per admitted command.
+        if (this.#ports.admissionStopped() || this.#pendingCommands.size + this.#ports.pendingWorkflowCount() >= MAX_PENDING_WORK)
+            return { outcome: "rejected", diagnostic: null };
+        const existing = this.#completedCommands.get(command.correlationId);
+        if (existing)
+            return existing;
+        if (this.#activeCommandIds.includes(command.correlationId)) {
+            return this.#finishCommand(command, "rejected", "duplicate engine command correlation id");
+        }
+        this.#activeCommandIds.push(command.correlationId);
+        const generation = this.#ports.sessionGeneration();
+        let cancelled = false;
+        const cancellation = new Promise(resolve => {
+            this.#pendingCommands.set(command.correlationId, { type: command.type, cancel: () => {
+                    if (cancelled)
+                        return;
+                    cancelled = true;
+                    resolve(this.#recordCommand(command, "failed", null));
+                } });
+        });
+        this.#ports.emit({ type: "command-outcome", correlationId: command.correlationId, outcome: "accepted", diagnostic: null });
+        const operation = async () => {
+            try {
+                if (cancelled)
+                    return { outcome: "failed", diagnostic: null };
+                this.#ports.beginRunning();
+                try {
+                    await this.#ports.perform(command);
+                }
+                finally {
+                    this.#ports.endRunning();
+                }
+                if (cancelled)
+                    return { outcome: "failed", diagnostic: null };
+                if (generation === this.#ports.sessionGeneration())
+                    this.#ports.emitView();
+                if (cancelled)
+                    return { outcome: "failed", diagnostic: null };
+                return this.#recordCommand(command, "completed", null);
+            }
+            catch (error) {
+                if (cancelled)
+                    return { outcome: "failed", diagnostic: null };
+                const diagnostic = error instanceof Error ? error.message : String(error);
+                this.#ports.diagnostic("error", "engine-command", diagnostic, true);
+                if (generation === this.#ports.sessionGeneration())
+                    this.#ports.emitView();
+                return this.#recordCommand(command, "failed", diagnostic);
+            }
+        };
+        try {
+            return await Promise.race([operation(), cancellation]);
+        }
+        finally {
+            this.#pendingCommands.delete(command.correlationId);
+        }
+    }
+    #recordCommand(command, outcome, diagnostic) {
+        const result = this.#finishCommand(command, outcome, diagnostic);
+        this.#completedCommands.set(command.correlationId, result);
+        if (this.#completedCommands.size > MAX_COMPLETED_COMMANDS) {
+            const oldest = this.#completedCommands.keys().next().value;
+            if (oldest)
+                this.#completedCommands.delete(oldest);
+        }
+        return result;
+    }
+    #finishCommand(command, outcome, diagnostic) {
+        this.#activeCommandIds = this.#activeCommandIds.filter(id => id !== command.correlationId);
+        this.#ports.emit({
+            type: "command-outcome",
+            correlationId: command.correlationId,
+            outcome,
+            diagnostic,
+        });
+        return { outcome, diagnostic };
+    }
+}

package/dist/integrations/pi/engine/event-delivery.d.ts

@@ -0,0 +1,100 @@
+import type { OwnedUiEvent, OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+/** An event the adapter emits before delivery stamps it with the session id and sequence. */
+export type PiEmittedEvent = Omit<Extract<OwnedUiEvent, {
+    type: "session-lifecycle";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "session-view";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "transcript-block";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "assistant-message-completed";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "agent-run-started";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "agent-run-settled";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "editor-state";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "status";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "command-outcome";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "terminal-surface";
+}>, "sessionId" | "sequence"> | Omit<Extract<OwnedUiEvent, {
+    type: "diagnostic";
+}>, "sessionId" | "sequence">;
+/** A command outcome held back during an overload so its command can still settle after recovery. */
+export interface ReservedCommandOutcome {
+    readonly outcome: Extract<OwnedUiEvent, {
+        type: "command-outcome";
+    }>["outcome"];
+    readonly diagnostic: Extract<OwnedUiEvent, {
+        type: "command-outcome";
+    }>["diagnostic"];
+}
+export interface PiEventDeliveryPorts {
+    sessionId(): string;
+    sessionGeneration(): number;
+    /** The current block for a lazily materialized transcript event. */
+    transcriptBlock(id: string): OwnedUiTranscriptBlock | undefined;
+    /** Retain the image assets an event references until the returned release runs. */
+    retainEvent(event: OwnedUiEvent): () => void;
+    /** Whether a command outcome still has an admitted command waiting for it. */
+    isPendingCommand(correlationId: string): boolean;
+    /** Cancel admitted work when the queue saturates; resolves once the engine session aborted. */
+    cancelForOverload(): Promise<void>;
+    /** Rebuild session state once the saturated queue drained; `cancelled` says whether the abort completed. */
+    reconcileOverload(cancelled: boolean): Promise<void>;
+    /** A listener threw; the adapter records the warning. */
+    listenerFailed(message: string): void;
+}
+/**
+ * Bounded delivery of owned UI events: stamps sequence numbers, keeps subscribers, queues events
+ * through the replaceable pending buffer, yields to the event loop between batches, and when the
+ * buffer saturates declares an overload that the adapter reconciles once the queue drains. The
+ * adapter decides what an event means; this class decides only when it reaches a listener.
+ */
+export declare class PiEventDelivery {
+    #private;
+    constructor(ports: PiEventDeliveryPorts);
+    /** The sequence number of the most recently stamped event. */
+    get sequence(): number;
+    /** True from queue saturation until the adapter's reconciliation ends. */
+    get overloaded(): boolean;
+    /** True once a listener threw or the queue saturated, until the adapter clears it after a flush. */
+    get failed(): boolean;
+    clearFailure(): void;
+    /** Developer-only pressure evidence; never mirrored into visible diagnostic/status arrays. */
+    diagnostics(): {
+        overloads: number;
+        recovering: boolean;
+        reservedOutcomes: number;
+        invalidatedEvents: number;
+        pending: number;
+        bytes: number;
+        protected: number;
+        superseded: number;
+        peakNodes: number;
+        peakBytes: number;
+    };
+    /** Give an event its session id and the next sequence number without queueing it. */
+    stamp(value: PiEmittedEvent): OwnedUiEvent;
+    /** Register a listener that first receives `initial` and afterwards every later-stamped event. */
+    subscribe(listener: (event: OwnedUiEvent) => void, initial: OwnedUiEvent): () => void;
+    /** Stamp and queue an event for ordered delivery. */
+    emit(value: PiEmittedEvent): OwnedUiEvent;
+    /** Queue an already stamped event; during an overload only pending command outcomes are kept, as reservations. */
+    enqueue(event: OwnedUiEvent): void;
+    /** Freeze lazy snapshots before their source is replaced; false means the queue saturated. */
+    seal(): boolean;
+    /** Drop queued events from earlier session generations. */
+    discardObsolete(generation: number): void;
+    /** Enter the bounded overload transition; a no-op while one is already in progress. */
+    beginOverload(): void;
+    /** Deliver out of band, bypassing the queue; used for reconciliation after an overload. */
+    deliverNow(event: OwnedUiEvent): void;
+    /** The command outcomes reserved during an overload, in arrival order; clears the reservation. */
+    takeReservedOutcomes(): [string, ReservedCommandOutcome][];
+    /** Resolves once every queued event has been delivered or invalidated. */
+    settle(): Promise<void>;
+}

package/dist/integrations/pi/engine/event-delivery.js

@@ -0,0 +1,184 @@
+import { PendingEngineDelivery } from "./pending-delivery.js";
+/**
+ * Engine events delivered before the queue hands the event loop a turn. Small enough
+ * that a streaming burst never holds input, large enough that an ordinary turn is one
+ * batch.
+ */
+// Performance: deliver at most one engine event per event-loop turn. Transcript updates can
+// be expensive in long sessions; a larger synchronous batch starves terminal
+// input and makes an in-progress mouse selection appear frozen.
+const EVENT_DELIVERY_BATCH = 1;
+const OVERLOAD_CANCELLATION_TIMEOUT_MS = 2000;
+/**
+ * Bounded delivery of owned UI events: stamps sequence numbers, keeps subscribers, queues events
+ * through the replaceable pending buffer, yields to the event loop between batches, and when the
+ * buffer saturates declares an overload that the adapter reconciles once the queue drains. The
+ * adapter decides what an event means; this class decides only when it reaches a listener.
+ */
+export class PiEventDelivery {
+    #listeners = new Map();
+    #queue;
+    #reservedOutcomes = new Map();
+    #ports;
+    #sequence = 0;
+    #processing;
+    #overload;
+    #overloads = 0;
+    #deliveryFailed = false;
+    #invalidatedEvents = 0;
+    constructor(ports) {
+        this.#ports = ports;
+        this.#queue = new PendingEngineDelivery(event => ports.retainEvent(event));
+    }
+    /** The sequence number of the most recently stamped event. */
+    get sequence() {
+        return this.#sequence;
+    }
+    /** True from queue saturation until the adapter's reconciliation ends. */
+    get overloaded() {
+        return this.#overload !== undefined;
+    }
+    /** True once a listener threw or the queue saturated, until the adapter clears it after a flush. */
+    get failed() {
+        return this.#deliveryFailed;
+    }
+    clearFailure() {
+        this.#deliveryFailed = false;
+    }
+    /** Developer-only pressure evidence; never mirrored into visible diagnostic/status arrays. */
+    diagnostics() {
+        return { ...this.#queue.diagnostics(), overloads: this.#overloads, recovering: this.overloaded,
+            reservedOutcomes: this.#reservedOutcomes.size, invalidatedEvents: this.#invalidatedEvents };
+    }
+    /** Give an event its session id and the next sequence number without queueing it. */
+    stamp(value) {
+        this.#sequence += 1;
+        return { ...value, sessionId: this.#ports.sessionId(), sequence: this.#sequence };
+    }
+    /** Register a listener that first receives `initial` and afterwards every later-stamped event. */
+    subscribe(listener, initial) {
+        this.#listeners.set(listener, initial.sequence);
+        listener(initial);
+        return () => this.#listeners.delete(listener);
+    }
+    /** Stamp and queue an event for ordered delivery. */
+    emit(value) {
+        const event = this.stamp(value);
+        this.enqueue(event);
+        return event;
+    }
+    /** Queue an already stamped event; during an overload only pending command outcomes are kept, as reservations. */
+    enqueue(event) {
+        if (this.#overload !== undefined) {
+            if (event.type === "command-outcome" && event.outcome !== "accepted" && this.#ports.isPendingCommand(event.correlationId)) {
+                this.#reservedOutcomes.set(event.correlationId, { outcome: event.outcome, diagnostic: event.diagnostic });
+            }
+            return;
+        }
+        if (!this.#queue.push(event, this.#ports.sessionGeneration(), event.type === "transcript-block"
+            ? this.#blockReconciliation(event.block.id, event.sequence) : undefined)) {
+            this.beginOverload();
+            if (event.type === "command-outcome" && event.outcome !== "accepted" && this.#ports.isPendingCommand(event.correlationId)
+                && !this.#reservedOutcomes.has(event.correlationId)) {
+                this.#reservedOutcomes.set(event.correlationId, { outcome: event.outcome, diagnostic: event.diagnostic });
+            }
+        }
+        this.#processing ??= Promise.resolve().then(() => this.#processQueue());
+    }
+    // Performance: capture only identity, not the complete block/event retained by an earlier revision.
+    #blockReconciliation(id, sequence) {
+        return () => ({ type: "transcript-block", sessionId: this.#ports.sessionId(), sequence, block: this.#ports.transcriptBlock(id) });
+    }
+    /** Freeze lazy snapshots before their source is replaced; false means the queue saturated. */
+    seal() {
+        return this.#queue.seal();
+    }
+    /** Drop queued events from earlier session generations. */
+    discardObsolete(generation) {
+        this.#invalidatedEvents += this.#queue.discardObsolete(generation);
+    }
+    /** Enter the bounded overload transition; a no-op while one is already in progress. */
+    beginOverload() {
+        if (this.#overload !== undefined)
+            return;
+        this.#overloads = Math.min(Number.MAX_SAFE_INTEGER, this.#overloads + 1);
+        this.#deliveryFailed = true;
+        // Concurrency: reserve before cancellation; outcomes produced reentrantly must not enter the saturated queue.
+        this.#overload = Promise.resolve(false);
+        const cancellation = this.#ports.cancelForOverload();
+        this.#overload = new Promise(resolve => {
+            const timer = setTimeout(() => resolve(false), OVERLOAD_CANCELLATION_TIMEOUT_MS);
+            cancellation.then(() => {
+                clearTimeout(timer);
+                resolve(true);
+            }, () => { clearTimeout(timer); resolve(false); });
+        });
+    }
+    /** Deliver out of band, bypassing the queue; used for reconciliation after an overload. */
+    deliverNow(event) {
+        for (const [listener, subscribedAt] of this.#listeners) {
+            if (event.sequence <= subscribedAt)
+                continue;
+            try {
+                listener(event);
+            }
+            catch (error) {
+                this.#deliveryFailed = true;
+                this.#ports.listenerFailed(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    /** The command outcomes reserved during an overload, in arrival order; clears the reservation. */
+    takeReservedOutcomes() {
+        const reserved = [...this.#reservedOutcomes];
+        this.#reservedOutcomes.clear();
+        return reserved;
+    }
+    /** Resolves once every queued event has been delivered or invalidated. */
+    async settle() {
+        while (this.#processing)
+            await this.#processing;
+    }
+    async #processQueue() {
+        try {
+            let deliveredSinceYield = 0;
+            while (this.#queue.size > 0) {
+                const pending = this.#queue.shift();
+                if (pending === undefined)
+                    continue;
+                if (pending.generation !== this.#ports.sessionGeneration() && pending.event.type !== "command-outcome") {
+                    this.#invalidatedEvents = Math.min(Number.MAX_SAFE_INTEGER, this.#invalidatedEvents + 1);
+                    pending.release?.();
+                    continue;
+                }
+                try {
+                    this.deliverNow(pending.event);
+                }
+                finally {
+                    pending.release?.();
+                }
+                deliveredSinceYield += 1;
+                // Concurrency: a microtask chain runs to exhaustion before the loop turns, so a streaming
+                // burst would hold typed input, pointer reports, and timed indicators until it
+                // drained. Yielding on a macrotask hands those their turn between batches.
+                if (deliveredSinceYield >= EVENT_DELIVERY_BATCH && this.#queue.size > 0) {
+                    deliveredSinceYield = 0;
+                    await new Promise(resolve => { setImmediate(resolve); });
+                }
+            }
+            if (this.#overload !== undefined) {
+                const cancelled = await this.#overload;
+                await this.#ports.reconcileOverload(cancelled);
+                // Invariant: an outcome reserved while reconciliation replayed the earlier ones is dropped with the overload.
+                this.#reservedOutcomes.clear();
+                this.#overload = undefined;
+            }
+        }
+        finally {
+            this.#processing = undefined;
+            if (this.#queue.size > 0) {
+                this.#processing = Promise.resolve().then(() => this.#processQueue());
+            }
+        }
+    }
+}

package/dist/integrations/pi/engine/extension-ui-binding.d.ts

@@ -0,0 +1,35 @@
+import type { AgentSession } from "../startup-public.js";
+import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, type OwnedUiDiagnostics } from "../../../contracts/owned-ui/index.js";
+export interface OwnedPiVisualExtensionSupport {
+    readonly available: boolean;
+    readonly contractComplete: true;
+    readonly contractVersion: typeof OWNED_UI_EXTENSION_CONTRACT_VERSION;
+    readonly binding: "bound" | "unbound";
+    readonly uiCallbacks: typeof OWNED_UI_EXTENSION_UI_CALLBACKS;
+    readonly uiProperties: typeof OWNED_UI_EXTENSION_UI_PROPERTIES;
+    readonly renderCallbacks: typeof OWNED_UI_EXTENSION_RENDER_CALLBACKS;
+    readonly diagnostic: string;
+}
+export interface PiExtensionUiBindingPorts {
+    session(): AgentSession | undefined;
+    diagnostic(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable: boolean): void;
+    emitView(): void;
+}
+/**
+ * The owned extension UI bridge's attachment to pinned Pi sessions: the bridge the shell hands
+ * over, whether the current session is bound to it, and the rebind that every new session needs.
+ * Extension errors surface as adapter diagnostics through the ports.
+ */
+export declare class PiExtensionUiBinding {
+    #private;
+    constructor(ports: PiExtensionUiBindingPorts);
+    /** True while a bridge is attached, bound or not. */
+    get attached(): boolean;
+    support(): OwnedPiVisualExtensionSupport;
+    /** Attach the owned extension UI bridge and bind it to the current session. */
+    bind(ui: unknown, shutdown?: () => void | Promise<void>): Promise<void>;
+    /** Detach the bridge; the next session binding will not rebind it. */
+    unbind(): Promise<void>;
+    /** Bind the attached bridge to the current session, reporting failures as diagnostics. */
+    rebind(): Promise<void>;
+}

package/dist/integrations/pi/engine/extension-ui-binding.js

@@ -0,0 +1,81 @@
+import { PRODUCT_IDENTITY } from "../../../product-identity.js";
+import { isRecord } from "./message-values.js";
+import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, assertOwnedUiExtensionUiPort, } from "../../../contracts/owned-ui/index.js";
+/**
+ * The owned extension UI bridge's attachment to pinned Pi sessions: the bridge the shell hands
+ * over, whether the current session is bound to it, and the rebind that every new session needs.
+ * Extension errors surface as adapter diagnostics through the ports.
+ */
+export class PiExtensionUiBinding {
+    #ports;
+    #extensionUi;
+    #extensionShutdown;
+    #extensionBound = false;
+    constructor(ports) {
+        this.#ports = ports;
+    }
+    /** True while a bridge is attached, bound or not. */
+    get attached() {
+        return this.#extensionUi !== undefined;
+    }
+    support() {
+        return {
+            available: this.#extensionBound,
+            contractComplete: true,
+            contractVersion: OWNED_UI_EXTENSION_CONTRACT_VERSION,
+            binding: this.#extensionBound ? "bound" : "unbound",
+            uiCallbacks: OWNED_UI_EXTENSION_UI_CALLBACKS,
+            uiProperties: OWNED_UI_EXTENSION_UI_PROPERTIES,
+            renderCallbacks: OWNED_UI_EXTENSION_RENDER_CALLBACKS,
+            diagnostic: this.#extensionBound
+                ? `Pinned public extension UI lifecycle is bound through the ${PRODUCT_IDENTITY.displayName}-owned bridge.`
+                : `The complete ${PRODUCT_IDENTITY.displayName}-owned extension UI contract is available; the active session has not been bound to the owned UI bridge.`,
+        };
+    }
+    /** Attach the owned extension UI bridge and bind it to the current session. */
+    async bind(ui, shutdown) {
+        assertPiExtensionUiContext(ui);
+        this.#extensionUi = ui;
+        this.#extensionShutdown = shutdown;
+        await this.rebind();
+    }
+    /** Detach the bridge; the next session binding will not rebind it. */
+    async unbind() {
+        this.#extensionUi = undefined;
+        this.#extensionShutdown = undefined;
+        this.#extensionBound = false;
+    }
+    /** Bind the attached bridge to the current session, reporting failures as diagnostics. */
+    async rebind() {
+        const session = this.#ports.session();
+        const ui = this.#extensionUi;
+        if (session === undefined || ui === undefined || session.bindExtensions === undefined) {
+            this.#extensionBound = false;
+            return;
+        }
+        try {
+            await session.bindExtensions({
+                uiContext: ui,
+                mode: "tui",
+                shutdownHandler: () => this.#extensionShutdown?.(),
+                onError: error => {
+                    const message = isRecord(error) && typeof error.error === "string"
+                        ? error.error
+                        : error instanceof Error ? error.message : String(error);
+                    this.#ports.diagnostic("warning", "extension-ui", message, true);
+                    this.#ports.emitView();
+                },
+            });
+            this.#extensionBound = true;
+            this.#ports.emitView();
+        }
+        catch (error) {
+            this.#extensionBound = false;
+            this.#ports.diagnostic("error", "extension-ui-bind", error instanceof Error ? error.message : String(error), true);
+            this.#ports.emitView();
+        }
+    }
+}
+function assertPiExtensionUiContext(value) {
+    assertOwnedUiExtensionUiPort(value);
+}

package/dist/integrations/pi/engine/index.d.ts

@@ -1,14 +1,18 @@
-export * from "./adapter.js";
-export * from "./conformance.js";
-export * from "./runtime-integration.js";
-export * from "./session-selection.js";
-export * from "./session-integration.js";
-export * from "./model-auth-integration.js";
-export * from "./settings-integration.js";
-export * from "./settings-effects.js";
-export * from "./project-trust-preflight.js";
-export * from "./http-dispatcher.js";
-export * from "./package-integration.js";
-export * from "./resource-extension-integration.js";
-export * from "./workflow-controllers.js";
-export * from "./workflows.js";
+export { EngineDeliveryError, PiEngineAdapter, createPiEngineAdapter } from "./adapter.js";
+export type { AdapterCommandResult, OwnedPiExtensionResourceSummary, OwnedPiExtensionSourceSummary, OwnedPiResourceSummary, OwnedPiVisualExtensionSupport, PiEngineAdapterOptions, PiEngineRuntimeFactory, PiEngineRuntimeFactoryInput, } from "./adapter.js";
+export { bindPiRuntimeSession, createPiRuntimeIntegration, createPiRuntimeServicesAfterTrust, disposePiRuntimeIntegration, replacePiRuntimeSession, resolveConfiguredModelScope, } from "./runtime-integration.js";
+export type { PiRuntimeIntegrationOptions, PiRuntimePreflightDependencies, PiSessionReplacement } from "./runtime-integration.js";
+export { PiSessionSelectionError, openSelectedPiSession, resolveSessionArgumentPath } from "./session-selection.js";
+export type { PiSessionForkPrompt, PiSessionSelection } from "./session-selection.js";
+export { PiSessionCommandIntegration, convertPiSessionEvent, subscribeToPiSessionEvents } from "./session-integration.js";
+export type { PiDocumentedSessionCommands, PiOrderedEventIntegration, PiSessionCommand, PiSessionCommandResult } from "./session-integration.js";
+export { AUTOMATIC_THEME, EXPOSED_SETTING_KEYS, PI_SETTING_EFFECTS, PiSettingsBridge, PiSettingsCoordinator, parseAutomaticTheme, settingsEffectInventoryDrift, settingsInventoryDrift, settingsVisualInventoryViolations, } from "./settings-bridge.js";
+export { assertPiSettingsMetadata, loadPiSettingsMetadata, PI_SETTINGS_METADATA_FILE } from "./settings-metadata.js";
+export type { PiSettingBounds, PiSettingPresentation, PiSettingsMetadata } from "./settings-metadata.js";
+export type { PiSettingEffectDefinition, PiSettingEffectHandler, PiSettingKey, PiSettingOwnerHandlers, PiSettingStorageOperation, PiSettingVisualClass, PiSettingVisualEvidence, PiSettingsCoordinatorOptions, PiSettingsModelChoice, PiSettingsProviders, } from "./settings-bridge.js";
+export { resolvePiProjectTrustPreflight } from "./project-trust-preflight.js";
+export type { PiProjectTrustPreflightPrompt, PiProjectTrustPreflightRequest, PiProjectTrustPreflightResult, ResolvePiProjectTrustPreflightOptions, } from "./project-trust-preflight.js";
+export { configureOwnedHttpDispatcher, configuredOwnedHttpIdleTimeoutMs } from "./http-dispatcher.js";
+export { createPiPackagesPort } from "./package-integration.js";
+export { PINNED_PI_HIDDEN_COMMAND_NAMES, PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES } from "./workflows.js";
+export type { PiAuthenticationProviderOption, PiAuthenticationProviderStatus, PiBashWorkflowResult, PiHiddenWorkflowCommandName, PiPinnedSettingsCallback, PiPinnedSettingsSnapshot, PiProjectTrustContext, PiProjectTrustUpdate, PiScopedModelDescriptor, PiScopedModelsContext, PiScopedModelsRefreshResult, PiSessionInfoPresentation, PiSessionResumeMetadata, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowAutocompleteCommand, PiWorkflowCommandName, PiWorkflowHost, PiWorkflowInteractionHost, PiWorkflowInteractionRequest, PiWorkflowLoginNotification, PiWorkflowLoginStart, PiWorkflowMessage, PiWorkflowMessageKind, PiWorkflowOption, PiWorkflowOutcome, PiWorkflowPresentation, PiWorkflowRequest, PiWorkflowResult, PiWorkflowRoute, } from "./workflows.js";

package/dist/integrations/pi/engine/index.js

@@ -1,14 +1,10 @@
-export * from "./adapter.js";
-export * from "./conformance.js";
-export * from "./runtime-integration.js";
-export * from "./session-selection.js";
-export * from "./session-integration.js";
-export * from "./model-auth-integration.js";
-export * from "./settings-integration.js";
-export * from "./settings-effects.js";
-export * from "./project-trust-preflight.js";
-export * from "./http-dispatcher.js";
-export * from "./package-integration.js";
-export * from "./resource-extension-integration.js";
-export * from "./workflow-controllers.js";
-export * from "./workflows.js";
+export { EngineDeliveryError, PiEngineAdapter, createPiEngineAdapter } from "./adapter.js";
+export { bindPiRuntimeSession, createPiRuntimeIntegration, createPiRuntimeServicesAfterTrust, disposePiRuntimeIntegration, replacePiRuntimeSession, resolveConfiguredModelScope, } from "./runtime-integration.js";
+export { PiSessionSelectionError, openSelectedPiSession, resolveSessionArgumentPath } from "./session-selection.js";
+export { PiSessionCommandIntegration, convertPiSessionEvent, subscribeToPiSessionEvents } from "./session-integration.js";
+export { AUTOMATIC_THEME, EXPOSED_SETTING_KEYS, PI_SETTING_EFFECTS, PiSettingsBridge, PiSettingsCoordinator, parseAutomaticTheme, settingsEffectInventoryDrift, settingsInventoryDrift, settingsVisualInventoryViolations, } from "./settings-bridge.js";
+export { assertPiSettingsMetadata, loadPiSettingsMetadata, PI_SETTINGS_METADATA_FILE } from "./settings-metadata.js";
+export { resolvePiProjectTrustPreflight } from "./project-trust-preflight.js";
+export { configureOwnedHttpDispatcher, configuredOwnedHttpIdleTimeoutMs } from "./http-dispatcher.js";
+export { createPiPackagesPort } from "./package-integration.js";
+export { PINNED_PI_HIDDEN_COMMAND_NAMES, PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES } from "./workflows.js";