@timurproko/a1 0.2.6-dev.717 → 0.2.6-dev.734

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

@@ -8,6 +8,7 @@ import { PiExtensionUiBinding } from "./extension-ui-binding.js";
 import { PiPromptSuggestions } from "./prompt-suggestions.js";
 import { PiResourceCatalog } from "./resource-catalog.js";
 import { PiEngineRuntime } from "./session-runtime.js";
+import { detachedEngineHostPorts } from "./host-ports.js";
 import { PiEngineSettings } from "./settings-port.js";
 import { PiSessionEvents } from "./session-events.js";
 import { readUsageView } from "./usage-view.js";
@@ -24,10 +25,11 @@ const DEFAULT_SURFACE = {
     focusedRegion: "editor",
     hardwareCursor: false,
 };
-/** Owns the pinned Pi session lifecycle and translates its events into the neutral agent-engine contract. */
+/** Owns the pinned Pi session lifecycle and serves it to the owned shell as the neutral session backend. */
 export class PiEngineAdapter {
     #agentDir;
     #sessionId;
+    #engineHost;
     #workflowHost;
     #engine;
     #workflowInteraction;
@@ -118,9 +120,13 @@ export class PiEngineAdapter {
         emitView: () => { this.#emitView(); },
     });
     #disposed = false;
-    constructor(options = {}) {
+    #ports;
+    constructor(options) {
+        if (typeof options.sessionId !== "string" || options.sessionId.length === 0)
+            throw new TypeError("engine session id is required");
         this.#agentDir = options.agentDir ?? getAgentDir();
-        this.#sessionId = options.sessionId ?? "owned-session-1";
+        this.#sessionId = options.sessionId;
+        this.#engineHost = options.engineHost ?? detachedEngineHostPorts();
         this.#workflowHost = options.workflowHost ?? defaultWorkflowHost();
         this.#workflowInteraction = { prompt: async () => null, notify() { } };
         this.#engine = new PiEngineRuntime({
@@ -133,7 +139,8 @@ export class PiEngineAdapter {
             projectTrustPrompt: options.projectTrustPrompt,
             createRuntime: options.createRuntime,
             checkPackageUpdates: options.checkPackageUpdates,
-            ...(options.announceStartupChangelog === undefined ? {} : { announceStartupChangelog: options.announceStartupChangelog }),
+            signal: this.#engineHost.signal,
+            markStartupPhase: phase => this.#engineHost.markStartupPhase(phase),
             ...(options.repositoryContextReader === undefined ? {} : { repositoryContextReader: options.repositoryContextReader }),
             host: this.#workflowHost,
         }, {
@@ -143,6 +150,9 @@ export class PiEngineAdapter {
                     ...this.#terminal,
                     hardwareCursor: runtime.services.settingsManager?.getShowHardwareCursor?.() ?? this.#terminal.hardwareCursor,
                 };
+                const httpIdleTimeoutMs = runtime.services.settingsManager?.getHttpIdleTimeoutMs?.();
+                if (typeof httpIdleTimeoutMs === "number")
+                    this.#engineHost.httpPolicyLoaded(httpIdleTimeoutMs, this.#sessionId);
             },
             rebindBlocked: () => this.#delivery.overloaded || this.#admissionStopped || this.#disposed,
             sessionReplacing: () => { this.#commands.cancelPending(["new-session", "resume-session"]); },
@@ -203,6 +213,7 @@ export class PiEngineAdapter {
             runtime: () => this.#engine.runtime,
             requireSession: () => this.#requireWorkflowSession(),
             thinkingLevelChanged: level => { this.#thinkingLevel = level; this.#emitView(); },
+            httpPolicyChanged: timeoutMs => { this.#engineHost.httpPolicyChanged(timeoutMs, this.#sessionId); },
             emitView: () => { this.#emitView(); },
         });
         this.#suggestions = new PiPromptSuggestions({
@@ -212,7 +223,16 @@ export class PiEngineAdapter {
             identity: () => ({ sessionId: this.#sessionId, sessionGeneration: this.#engine.generation, runSequence: this.#events.runSequence, responseSequence: this.#events.responseSequence }),
             unavailable: () => this.#disposed || this.#delivery.overloaded || this.#admissionStopped,
         });
-    }
+        this.#ports = this.#createPorts();
+    }
+    get identity() { return this.#ports.identity; }
+    get session() { return this.#ports.session; }
+    get workflows() { return this.#ports.workflows; }
+    get settings() { return this.#ports.settings; }
+    get catalog() { return this.#ports.catalog; }
+    get extensions() { return this.#ports.extensions; }
+    /** The Pi objects behind pinned selectors and renderers, for the session presenters owner only. */
+    presentationSource() { return this.#ports.presentation; }
     setWorkflowInteractionHost(interaction) {
         this.#workflowInteraction = interaction;
     }
@@ -272,9 +292,16 @@ export class PiEngineAdapter {
         this.#editor = { ...this.#editor, submitEnabled: true };
         this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
         this.#emitView();
-        void this.#engine.announcePackageUpdates();
         return this.view();
     }
+    /** Announce pinned Pi's changelog since the profile's last seen version; the host calls this once per process. */
+    announceStartupChangelog() {
+        return this.#engine.announceChangelog();
+    }
+    /** Probe extension packages for updates and announce them; the host calls this once per process. */
+    announcePackageUpdates() {
+        return this.#engine.announcePackageUpdates();
+    }
     onEvent(listener) {
         return this.#delivery.subscribe(listener, this.#delivery.stamp({ type: "session-view", view: this.view() }));
     }
@@ -311,18 +338,12 @@ export class PiEngineAdapter {
     async cycleModelWorkflow(direction) {
         return this.#workflows.cycleModelWorkflow(direction);
     }
-    pinnedModelSelectorContext() {
-        return this.#contexts.pinnedModelSelectorContext();
-    }
     pinnedProjectTrustContext() {
         return this.#contexts.pinnedProjectTrustContext();
     }
     persistProjectTrust(updates) {
         this.#contexts.persistProjectTrust(updates);
     }
-    pinnedSessionSelectorContext() {
-        return this.#contexts.pinnedSessionSelectorContext();
-    }
     pinnedScopedModelsContext() {
         return this.#contexts.pinnedScopedModelsContext();
     }
@@ -362,9 +383,6 @@ export class PiEngineAdapter {
     pinnedForkOptions() {
         return this.#contexts.pinnedForkOptions();
     }
-    pinnedTreeSelectorContext() {
-        return this.#contexts.pinnedTreeSelectorContext();
-    }
     /** Bind the owned UI's clipboard lifecycle without changing the comparison host. True means acknowledged delivery. */
     bindClipboardWriter(writer) {
         return this.#workflows.bindClipboardWriter(writer);
@@ -414,17 +432,14 @@ export class PiEngineAdapter {
     pinnedSettingsSnapshot() {
         return this.#settings.pinnedSettingsSnapshot();
     }
-    applyPinnedSettingValue(callback, value) {
-        return this.#settings.applyPinnedSettingValue(callback, value);
-    }
-    pinnedMessageRenderer(customType) {
+    #pinnedMessageRenderer(customType) {
         return this.#requireWorkflowSession().extensionRunner?.getMessageRenderer?.(customType);
     }
-    pinnedShortcutDescriptions(bindings) {
+    #pinnedShortcutDescriptions(bindings) {
         const shortcuts = this.#requireWorkflowSession().extensionRunner?.getShortcuts?.(bindings);
         return shortcuts === undefined ? [] : [...shortcuts].map(([key, shortcut]) => ({ key, description: shortcut.description ?? shortcut.extensionPath }));
     }
-    pinnedToolRenderers(toolName) {
+    #pinnedToolRenderers(toolName) {
         const runner = this.#requireWorkflowSession().extensionRunner;
         if (runner === undefined)
             return undefined;
@@ -516,6 +531,99 @@ export class PiEngineAdapter {
                 throw error;
         }
     }
+    // Invariant: every sub-port member delegates at call time, so ports built once follow session replacement.
+    #createPorts() {
+        const engine = this.#engine;
+        const contexts = this.#contexts;
+        const workflows = this.#workflows;
+        const settings = this.#settings;
+        const resources = this.#resources;
+        const extensions = this.#extensions;
+        const isDisposed = () => this.#disposed;
+        const sessionId = this.#sessionId;
+        const agentDir = this.#agentDir;
+        return {
+            identity: {
+                sessionId,
+                agentDir,
+                get cwd() { return engine.cwd; },
+                get sessionGeneration() { return engine.generation; },
+                get sessionBindingGeneration() { return engine.bindingGeneration; },
+                get disposed() { return isDisposed(); },
+                currentSessionResumeMetadata: () => engine.currentSessionResumeMetadata(),
+            },
+            session: {
+                start: () => this.start(),
+                view: () => this.view(),
+                snapshot: () => this.snapshot(),
+                onEvent: listener => this.onEvent(listener),
+                execute: command => this.execute(command),
+                flushEvents: () => this.flushEvents(),
+                dispose: () => this.dispose(),
+            },
+            workflows: {
+                executeWorkflow: request => this.executeWorkflow(request),
+                executeBashWorkflow: (command, excludeFromContext) => workflows.executeBashWorkflow(command, excludeFromContext),
+                cycleModelWorkflow: direction => workflows.cycleModelWorkflow(direction),
+                workflowAutocompleteCommands: () => resources.workflowAutocompleteCommands(),
+                clearQueuedWorkflows: () => this.clearQueuedWorkflows(),
+                reloadBlockedResult: () => workflows.reloadBlockedResult(),
+                copyWorkflowText: text => workflows.copyWorkflowText(text),
+                setWorkflowInteractionHost: interaction => { this.setWorkflowInteractionHost(interaction); },
+            },
+            settings: {
+                get productMode() { return settings.productMode; },
+                snapshot: () => {
+                    // Invariant: the selector-only model values travel on the presentation source, not in the neutral snapshot.
+                    const { currentModel: _currentModel, availableDefaultModels: _availableDefaultModels, ...snapshot } = settings.pinnedSettingsSnapshot();
+                    return snapshot;
+                },
+                bindOwner: (owner, handlers) => settings.bindSettingsOwner(owner, handlers),
+                setDefaultThinkingLevel: level => { settings.setDefaultThinkingLevel(level); },
+                configuredTheme: () => settings.configuredTheme(),
+            },
+            catalog: {
+                modelsContext: () => contexts.modelsContext(),
+                setSessionModelScope: scopeIds => { contexts.setSessionModelScope(scopeIds); },
+                persistModelScope: scopeIds => { contexts.persistModelScope(scopeIds); },
+                refreshModels: signal => contexts.refreshModels(signal),
+                pinnedScopedModelsContext: () => contexts.pinnedScopedModelsContext(),
+                updateScopedModels: enabledModelIds => { contexts.updateScopedModels(enabledModelIds); },
+                persistScopedModels: enabledModelIds => { contexts.persistScopedModels(enabledModelIds); },
+                refreshScopedModels: signal => contexts.refreshScopedModels(signal),
+                pinnedProjectTrustContext: () => contexts.pinnedProjectTrustContext(),
+                persistProjectTrust: updates => { contexts.persistProjectTrust(updates); },
+                pinnedLoginOptions: authType => contexts.loginOptions(authType),
+                pinnedLoginMethodOptions: providerReference => contexts.pinnedLoginMethodOptions(providerReference),
+                pinnedAmbientAuthentication: selection => contexts.pinnedAmbientAuthentication(selection),
+                pinnedLogoutOptions: () => contexts.logoutOptions(),
+                pinnedForkOptions: () => contexts.pinnedForkOptions(),
+            },
+            extensions: {
+                nonVisualResources: () => resources.nonVisualResources(),
+                extensionResources: () => resources.extensionResources(),
+                resolveTranscriptImage: assetId => this.resolveTranscriptImage(assetId),
+                visualExtensionSupport: () => extensions.support(),
+                bindExtensionUi: (ui, shutdown) => extensions.bind(ui, shutdown),
+                unbindExtensionUi: () => extensions.unbind(),
+                bindClipboardWriter: writer => workflows.bindClipboardWriter(writer),
+                announceReleaseUpdate: release => { this.announceReleaseUpdate(release); },
+            },
+            presentation: {
+                pinnedModelSelectorContext: () => contexts.pinnedModelSelectorContext(),
+                pinnedSessionSelectorContext: () => contexts.pinnedSessionSelectorContext(),
+                pinnedTreeSelectorContext: () => contexts.pinnedTreeSelectorContext(),
+                pinnedMessageRenderer: customType => this.#pinnedMessageRenderer(customType),
+                pinnedToolRenderers: toolName => this.#pinnedToolRenderers(toolName),
+                pinnedShortcutDescriptions: bindings => this.#pinnedShortcutDescriptions(bindings),
+                pinnedSettingsModels: () => {
+                    const { currentModel, availableDefaultModels } = settings.pinnedSettingsSnapshot();
+                    return { ...(currentModel === undefined ? {} : { currentModel }), availableDefaultModels };
+                },
+                applyPinnedSettingValue: (callback, value) => settings.applyPinnedSettingValue(callback, value),
+            },
+        };
+    }
     #requireWorkflowSession() {
         if (this.#disposed || !this.#engine.runtime || !this.#engine.session)
             throw new Error("engine adapter is not running");
@@ -704,7 +812,7 @@ export class PiEngineAdapter {
         return diagnostic;
     }
 }
-export async function createPiEngineAdapter(options = {}) {
+export async function createPiEngineAdapter(options) {
     const adapter = new PiEngineAdapter(options);
     await adapter.start();
     return adapter;

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

@@ -1,9 +1,6 @@
-import { type OwnedUiCommand, type OwnedUiCommandOutcome, type OwnedUiDiagnostics } from "../../../contracts/owned-ui/index.js";
+import { type OwnedUiCommand, type OwnedUiCommandResult, 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 type AdapterCommandResult = OwnedUiCommandResult;
 export interface PiCommandDispatchPorts {
     sessionId(): string;
     /** True before the runtime and session exist or after disposal: commands are rejected, not queued. */

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

@@ -1,15 +1,6 @@
 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;
-}
+import { type OwnedUiDiagnostics, type OwnedUiVisualExtensionSupport } from "../../../contracts/owned-ui/index.js";
+export type OwnedPiVisualExtensionSupport = OwnedUiVisualExtensionSupport;
 export interface PiExtensionUiBindingPorts {
     session(): AgentSession | undefined;
     diagnostic(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable: boolean): void;

package/dist/integrations/pi/engine/host-ports.d.ts

@@ -0,0 +1,20 @@
+import { type StartupPhase } from "../../../foundation/startup/startup-runtime.js";
+/**
+ * What one engine session may ask of the process-level host that created it. The host owns
+ * everything process-wide; a session only reports what it learned and reads the host's signal.
+ */
+export interface PiEngineHostSessionPorts {
+    /** Aborted when the host is disposed; host-level timers and probes stop with it. */
+    readonly signal: AbortSignal;
+    /** Record a startup trace phase; the host records each phase once per process. */
+    markStartupPhase(phase: StartupPhase): Promise<void>;
+    /** A session's runtime loaded the profile's HTTP idle timeout; the host installs the dispatcher once. */
+    httpPolicyLoaded(timeoutMs: number, sessionId: string): void;
+    /** A session wrote the HTTP idle timeout setting; the host re-installs the dispatcher for the process. */
+    httpPolicyChanged(timeoutMs: number, sessionId: string): void;
+}
+/**
+ * The ports of an adapter built without a host: the signal never fires, phases trace as before, and
+ * no process dispatcher is installed, because only the host owns that.
+ */
+export declare function detachedEngineHostPorts(): PiEngineHostSessionPorts;

package/dist/integrations/pi/engine/host-ports.js

@@ -0,0 +1,13 @@
+import { markStartupPhase } from "../../../foundation/startup/startup-runtime.js";
+/**
+ * The ports of an adapter built without a host: the signal never fires, phases trace as before, and
+ * no process dispatcher is installed, because only the host owns that.
+ */
+export function detachedEngineHostPorts() {
+    return {
+        signal: new AbortController().signal,
+        markStartupPhase: phase => markStartupPhase(process.env, phase),
+        httpPolicyLoaded() { },
+        httpPolicyChanged() { },
+    };
+}

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

@@ -0,0 +1,70 @@
+import { PiEngineAdapter } from "./adapter.js";
+import { type StartupPhase } from "../../../foundation/startup/startup-runtime.js";
+import type { PiEnginePackageUpdateProbe, PiEngineRuntimeFactory, PiRepositoryContextReader } from "./session-runtime.js";
+import type { PiProjectTrustPreflightPrompt } from "./project-trust-preflight.js";
+import type { PiSessionForkPrompt, PiSessionSelection } from "./session-selection.js";
+import type { PiWorkflowHost } from "./workflows.js";
+import type { OwnedUiSessionFactory, OwnedUiSessionRequest, UiAccentColor } from "../../../contracts/owned-ui/index.js";
+/** The theme singletons the host applies. Composition supplies them so the engine owns no presentation module. */
+export interface PiEngineHostThemeApplier {
+    /** Apply the base theme in the engine's grammar: a theme name, or a `light/dark` pair meaning "follow the terminal". */
+    base(setting: string | undefined): void;
+    accentColor(color: UiAccentColor): void;
+    packageBorderProjection(enabled: boolean): void;
+}
+export interface PiEngineHostTheme {
+    /** `dark` pins bare A1's one base; `engine-configured` follows the theme the first session is configured with. */
+    readonly base: "dark" | "engine-configured";
+    readonly accentColor: UiAccentColor;
+    readonly packageBorderProjection: boolean;
+    readonly apply: PiEngineHostThemeApplier;
+}
+export interface PiEngineHostOptions {
+    readonly productMode: "bare" | "comparison";
+    readonly theme: PiEngineHostTheme;
+    /** Themes installed on this machine, listed by the component adapter that owns the theme unit. */
+    readonly availableThemes?: () => readonly string[];
+    /** Comparison profiles preserve Pi's startup changelog; bare A1 owns release-note startup. Defaults to on. */
+    readonly announceStartupChangelog?: boolean;
+    readonly projectTrustPrompt?: PiProjectTrustPreflightPrompt;
+    readonly checkPackageUpdates?: PiEnginePackageUpdateProbe;
+    readonly workflowHost?: PiWorkflowHost;
+    readonly createRuntime?: PiEngineRuntimeFactory;
+    /** Installs the process HTTP dispatcher; defaults to the owned undici seam. */
+    readonly installHttpDispatcher?: (timeoutMs: number) => void;
+    /** Records one startup trace phase; defaults to the process startup trace. */
+    readonly markStartupPhase?: (phase: StartupPhase) => Promise<void>;
+}
+/** A session request as the Pi host takes it: the neutral request plus how the Pi session is opened. */
+export interface PiEngineSessionRequest extends OwnedUiSessionRequest {
+    readonly sessionPath?: string;
+    readonly sessionSelection?: PiSessionSelection;
+    readonly sessionForkPrompt?: PiSessionForkPrompt;
+    readonly repositoryContextReader?: PiRepositoryContextReader;
+}
+/** The dispatcher policy in force for the process and the session that put it there. */
+export interface PiEngineHttpPolicy {
+    readonly timeoutMs: number;
+    readonly sessionId: string;
+    readonly origin: "startup" | "setting";
+}
+/**
+ * The process-level owner of everything in the engine integration that is process-wide: the undici
+ * dispatcher, the theme singletons, the one-time changelog and package-update announcements, and
+ * the startup trace. Sessions come only from `create`, so their ids are unique per process.
+ */
+export interface PiEngineHost extends OwnedUiSessionFactory {
+    /** Aborted on disposal; every host-level timer and probe stops with it. */
+    readonly signal: AbortSignal;
+    readonly disposed: boolean;
+    create(request: PiEngineSessionRequest): Promise<PiEngineAdapter>;
+    /** Ids of the sessions this host created that are not yet disposed. */
+    liveSessionIds(): readonly string[];
+    /** The dispatcher policy in force, or null before any session loaded one. */
+    httpPolicy(): PiEngineHttpPolicy | null;
+    /** Re-apply the owned accent; the live setting change from composition lands here. */
+    setAccentColor(color: UiAccentColor): void;
+    /** Abort the signal and dispose every session still live. */
+    dispose(): Promise<void>;
+}
+export declare function createPiEngineHost(options: PiEngineHostOptions): PiEngineHost;

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

@@ -0,0 +1,147 @@
+import { PiEngineAdapter } from "./adapter.js";
+import { configureOwnedHttpDispatcher } from "./http-dispatcher.js";
+import { markStartupPhase } from "../../../foundation/startup/startup-runtime.js";
+export function createPiEngineHost(options) {
+    return new ProcessPiEngineHost(options);
+}
+const SESSION_ID_PREFIX = "owned-session-";
+class ProcessPiEngineHost {
+    #options;
+    #abort = new AbortController();
+    #sessions = new Map();
+    #tracedPhases = new Set();
+    #sessionPorts;
+    #installHttpDispatcher;
+    #markStartupPhase;
+    #accentColor;
+    #nextSessionNumber = 1;
+    #httpPolicy = null;
+    #themeApplied = false;
+    #announced = false;
+    #disposed = false;
+    constructor(options) {
+        this.#options = options;
+        this.#accentColor = options.theme.accentColor;
+        this.#installHttpDispatcher = options.installHttpDispatcher ?? configureOwnedHttpDispatcher;
+        this.#markStartupPhase = options.markStartupPhase ?? (phase => markStartupPhase(process.env, phase));
+        this.#sessionPorts = {
+            signal: this.#abort.signal,
+            markStartupPhase: phase => this.#tracePhase(phase),
+            httpPolicyLoaded: (timeoutMs, sessionId) => { this.#applyHttpPolicy(timeoutMs, sessionId, "startup"); },
+            httpPolicyChanged: (timeoutMs, sessionId) => { this.#applyHttpPolicy(timeoutMs, sessionId, "setting"); },
+        };
+    }
+    get signal() {
+        return this.#abort.signal;
+    }
+    get disposed() {
+        return this.#disposed;
+    }
+    liveSessionIds() {
+        this.#forgetDisposedSessions();
+        return [...this.#sessions.keys()];
+    }
+    httpPolicy() {
+        return this.#httpPolicy;
+    }
+    setAccentColor(color) {
+        this.#accentColor = color;
+        if (this.#themeApplied)
+            this.#options.theme.apply.accentColor(color);
+    }
+    async create(request) {
+        if (this.#disposed)
+            throw new Error("engine host is disposed");
+        const sessionId = this.#claimSessionId(request.sessionId);
+        const options = this.#options;
+        const adapter = new PiEngineAdapter({
+            cwd: request.cwd,
+            sessionId,
+            engineHost: this.#sessionPorts,
+            settingsProductMode: options.productMode,
+            ...(options.availableThemes === undefined ? {} : { availableThemes: options.availableThemes }),
+            ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
+            ...(options.checkPackageUpdates === undefined ? {} : { checkPackageUpdates: options.checkPackageUpdates }),
+            ...(options.workflowHost === undefined ? {} : { workflowHost: options.workflowHost }),
+            ...(options.createRuntime === undefined ? {} : { createRuntime: options.createRuntime }),
+            ...(request.sessionPath === undefined ? {} : { sessionPath: request.sessionPath }),
+            ...(request.sessionSelection === undefined ? {} : { sessionSelection: request.sessionSelection }),
+            ...(request.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: request.sessionForkPrompt }),
+            ...(request.repositoryContextReader === undefined ? {} : { repositoryContextReader: request.repositoryContextReader }),
+        });
+        this.#sessions.set(sessionId, adapter);
+        try {
+            await adapter.start();
+        }
+        catch (error) {
+            this.#sessions.delete(sessionId);
+            throw error;
+        }
+        this.#applyThemeOnce(adapter);
+        await this.#announceOnce(adapter);
+        return adapter;
+    }
+    async dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#abort.abort();
+        const live = [...this.#sessions.values()].filter(session => !session.disposed);
+        this.#sessions.clear();
+        await Promise.all(live.map(session => session.dispose()));
+    }
+    // Invariant: an id names one live session; a disposed session's id may be reused by a caller, never by generation.
+    #claimSessionId(requested) {
+        this.#forgetDisposedSessions();
+        if (requested !== undefined) {
+            if (requested.length === 0)
+                throw new TypeError("engine session id is required");
+            if (this.#sessions.has(requested))
+                throw new Error(`engine session id is already live: ${requested}`);
+            return requested;
+        }
+        let candidate = `${SESSION_ID_PREFIX}${this.#nextSessionNumber++}`;
+        while (this.#sessions.has(candidate))
+            candidate = `${SESSION_ID_PREFIX}${this.#nextSessionNumber++}`;
+        return candidate;
+    }
+    #forgetDisposedSessions() {
+        for (const [sessionId, session] of this.#sessions)
+            if (session.disposed)
+                this.#sessions.delete(sessionId);
+    }
+    // Rationale: the profile's timeout is installed once, by whichever session loads it first; a written
+    // setting re-installs from any session because the dispatcher is process-wide either way.
+    #applyHttpPolicy(timeoutMs, sessionId, origin) {
+        if (this.#disposed || (origin === "startup" && this.#httpPolicy !== null))
+            return;
+        this.#installHttpDispatcher(timeoutMs);
+        this.#httpPolicy = { timeoutMs, sessionId, origin };
+    }
+    async #tracePhase(phase) {
+        if (this.#tracedPhases.has(phase))
+            return;
+        this.#tracedPhases.add(phase);
+        await this.#markStartupPhase(phase);
+    }
+    // Compatibility: bare A1 ships one base visual target while its UI is being completed: dark, regardless
+    // of terminal detection or a stored Pi theme, with its owned accent projected over it. Comparison keeps
+    // Pi's configured theme and unmodified semantic accent. The base is read from the first session.
+    #applyThemeOnce(adapter) {
+        if (this.#themeApplied)
+            return;
+        this.#themeApplied = true;
+        const theme = this.#options.theme;
+        theme.apply.packageBorderProjection(theme.packageBorderProjection);
+        theme.apply.accentColor(this.#accentColor);
+        theme.apply.base(theme.base === "dark" ? "dark" : adapter.configuredTheme());
+    }
+    async #announceOnce(adapter) {
+        if (this.#announced)
+            return;
+        this.#announced = true;
+        if (this.#options.announceStartupChangelog !== false)
+            await adapter.announceStartupChangelog();
+        void adapter.announcePackageUpdates();
+    }
+}

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

@@ -1,11 +1,15 @@
 export { EngineDeliveryError, PiEngineAdapter, createPiEngineAdapter } from "./adapter.js";
-export type { AdapterCommandResult, OwnedPiExtensionResourceSummary, OwnedPiExtensionSourceSummary, OwnedPiResourceSummary, OwnedPiVisualExtensionSupport, PiEngineAdapterOptions, PiEngineRuntimeFactory, PiEngineRuntimeFactoryInput, } from "./adapter.js";
+export type { AdapterCommandResult, OwnedPiExtensionResourceSummary, OwnedPiExtensionSourceSummary, OwnedPiResourceSummary, OwnedPiVisualExtensionSupport, PiEngineAdapterOptions, PiEngineRuntimeFactory, PiEngineRuntimeFactoryInput, PiSessionPresentationSource, } from "./adapter.js";
+export { createPiEngineHost } from "./host.js";
+export type { PiEngineHost, PiEngineHostOptions, PiEngineHostTheme, PiEngineHostThemeApplier, PiEngineHttpPolicy, PiEngineSessionRequest, } from "./host.js";
+export { detachedEngineHostPorts } from "./host-ports.js";
+export type { PiEngineHostSessionPorts } from "./host-ports.js";
 export { bindPiRuntimeSession, createPiRuntimeIntegration, createPiRuntimeServicesAfterTrust, disposePiRuntimeIntegration, replacePiRuntimeSession, resolveConfiguredModelScope, } from "./runtime-integration.js";
-export type { PiRuntimeIntegrationOptions, PiRuntimePreflightDependencies, PiSessionReplacement } from "./runtime-integration.js";
+export type { PiRuntimeIntegrationOptions, PiRuntimePreflightDependencies, PiSessionReplacement, PiStartupPhaseMarker } 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 { PiSessionCommandIntegration } from "./session-integration.js";
+export type { PiDocumentedSessionCommands, 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";

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

@@ -1,7 +1,9 @@
 export { EngineDeliveryError, PiEngineAdapter, createPiEngineAdapter } from "./adapter.js";
+export { createPiEngineHost } from "./host.js";
+export { detachedEngineHostPorts } from "./host-ports.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 { PiSessionCommandIntegration } 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";

package/dist/integrations/pi/engine/pi-settings-metadata.json

@@ -149,7 +149,7 @@
     },
     "outputPad": {
       "label": "Output padding",
-      "description": "Horizontal padding for user messages, assistant messages, and thinking",
+      "description": "Horizontal padding for messages, tool output, and command output",
       "opensDialog": false,
       "values": [
         "0",

package/dist/integrations/pi/engine/resource-catalog.d.ts

@@ -1,29 +1,10 @@
 import type { AgentSession, AgentSessionRuntime } from "../startup-public.js";
+import type { OwnedUiExtensionResourceSummary, OwnedUiExtensionSourceSummary, OwnedUiResourceSummary } from "../../../contracts/owned-ui/index.js";
 import type { PiWorkflowContexts } from "./workflow-contexts.js";
 import { type PiProductMode, type PiWorkflowAutocompleteCommand } from "./workflows.js";
-export interface OwnedPiResourceSummary {
-    readonly kind: "skill" | "prompt-template" | "agent-context" | "system-prompt" | "theme";
-    readonly id: string;
-    readonly label: string;
-    readonly sourcePath: string | null;
-    readonly diagnostic: string | null;
-}
-export interface OwnedPiExtensionSourceSummary {
-    readonly source: string;
-    readonly scope: "user" | "project" | "temporary";
-    readonly origin: "package" | "top-level";
-    readonly baseDir: string | null;
-}
-export interface OwnedPiExtensionResourceSummary {
-    readonly kind: "extension";
-    readonly id: string;
-    readonly sourcePath: string | null;
-    readonly resolvedPath: string | null;
-    readonly sourceInfo: OwnedPiExtensionSourceSummary | null;
-    readonly loaded: boolean;
-    readonly hidden: boolean;
-    readonly diagnostic: string | null;
-}
+export type OwnedPiResourceSummary = OwnedUiResourceSummary;
+export type OwnedPiExtensionSourceSummary = OwnedUiExtensionSourceSummary;
+export type OwnedPiExtensionResourceSummary = OwnedUiExtensionResourceSummary;
 export interface PiResourceCatalogPorts {
     session(): AgentSession | undefined;
     runtime(): AgentSessionRuntime | undefined;