@timurproko/a1 0.1.8-dev.112 → 0.1.8-dev.121

package/bin/cli.js

@@ -3,7 +3,7 @@
 const packageRoot = new URL("..", import.meta.url);
 const { fileURLToPath } = await import("node:url");
 const { readFile } = await import("node:fs/promises");
-const { cliCapabilities, dispatchCli } = await import("../dist/src/cli/index.js");
+const { cliCapabilities, dispatchCli } = await import("../dist/cli/index.js");
 
 // Which commands this build exposes follows from the build's own version, so a
 // released a1 cannot be argued into offering the development profiles.
@@ -12,24 +12,24 @@ const capabilities = cliCapabilities(JSON.parse(await readFile(new URL("package.
 process.exitCode = await dispatchCli(process.argv.slice(2), {
   launch: async intent => {
     const [{ prepareInteractiveLaunch }, { runBootstrap }] = await Promise.all([
-      import("../dist/src/features/launch/index.js"),
-      import("../dist/src/foundation/release/index.js"),
+      import("../dist/features/launch/index.js"),
+      import("../dist/foundation/release/index.js"),
     ]);
     const prepared = await prepareInteractiveLaunch(intent);
     return await runBootstrap({ packageRoot: fileURLToPath(packageRoot), launchIntent: intent, environment: prepared.environment });
   },
   version: async () => {
-    const { runVersionStats } = await import("../dist/src/cli/index.js");
+    const { runVersionStats } = await import("../dist/cli/index.js");
     return await runVersionStats({ packageRoot: fileURLToPath(packageRoot) });
   },
   update: async (channel, target) => {
-    const { runSelfUpdate } = await import("../dist/src/foundation/release/index.js");
+    const { runSelfUpdate } = await import("../dist/foundation/release/index.js");
     return await runSelfUpdate({ packageRoot: fileURLToPath(packageRoot), channel, ...(target === undefined ? {} : { target }) });
   },
   packages: async request => {
     const [{ runPackageCommand }, { createPiPackagesPort }] = await Promise.all([
-      import("../dist/src/cli/index.js"),
-      import("../dist/src/foundation/pi-engine-adapter/index.js"),
+      import("../dist/cli/index.js"),
+      import("../dist/integrations/pi/engine/index.js"),
     ]);
     return await runPackageCommand(request, { createPort: createPiPackagesPort });
   },

package/bin/guardian.js

@@ -2,7 +2,7 @@
 
 const { fileURLToPath } = await import("node:url");
 const { resolve } = await import("node:path");
-const { runLaunchGuardian } = await import("../dist/src/foundation/launch-guardian/index.js");
+const { runLaunchGuardian } = await import("../dist/foundation/launch-guardian/index.js");
 
 const releaseRoot = process.env.A1_RELEASE_ROOT ?? fileURLToPath(new URL("..", import.meta.url));
 const profileId = process.env.A1_LAUNCH_PROFILE ?? "a1";

package/bin/supervisor.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runSupervisor } from "../dist/src/foundation/supervision/index.js";
+import { runSupervisor } from "../dist/foundation/supervision/index.js";
 
 runSupervisor().catch(error => {
   console.error(error instanceof Error ? error.stack ?? error.message : String(error));

package/bin/ui.js

@@ -10,13 +10,13 @@ const { fileURLToPath } = await import("node:url");
 // when that stopped being true.
 assertSinglePiTuiModuleAtLaunch(fileURLToPath(new URL("..", import.meta.url)), message => process.stderr.write(message));
 
-const { runSelectedInteractiveRuntime } = await import("../dist/src/features/launch/index.js");
+const { runSelectedInteractiveRuntime } = await import("../dist/features/launch/index.js");
 
 runSelectedInteractiveRuntime(process.env.A1_LAUNCH_PROFILE ?? "a1", {
   ownedUi: async (profileId, ownedSurfaces) => {
     const [{ runOwnedUi }, { composeOwnedUi }] = await Promise.all([
-      import("../dist/src/features/owned-ui/index.js"),
-      import("../dist/src/composition/index.js"),
+      import("../dist/features/owned-ui/index.js"),
+      import("../dist/composition/index.js"),
     ]);
     const { application, settings } = await composeOwnedUi({ cwd: process.cwd(), profileId, ownedSurfaces });
     return await runOwnedUi({ application, ...(settings === null ? {} : { settings }) });

package/dist/{src/cli → cli}/packages.d.ts

@@ -1,5 +1,5 @@
 import { initializeProductProfile } from "../features/launch/index.js";
-import type { AgentPackageOutcome, AgentPackagesPort, AgentPackagesPortInput } from "../foundation/agent-engine-contracts/index.js";
+import type { AgentPackageOutcome, AgentPackagesPort, AgentPackagesPortInput } from "../contracts/agent-engine/index.js";
 /**
  * Package commands manage A1's own profile and nothing else, so no request carries
  * a profile: `update` with no source means every installed package, and refreshing

package/dist/composition/agent-engine-bridge.d.ts

@@ -0,0 +1,3 @@
+import { type AgentEnginePort } from "../contracts/agent-engine/index.js";
+import type { PiEngineAdapter } from "../integrations/pi/engine/index.js";
+export declare function createPiAgentEngineBridge(adapter: PiEngineAdapter, cwd: string): AgentEnginePort;

package/dist/composition/agent-engine-bridge.js

@@ -0,0 +1,108 @@
+import { AGENT_ENGINE_CONTRACT_VERSION, assertAgentCommand, } from "../contracts/agent-engine/index.js";
+const CAPABILITIES = {
+    contractVersion: AGENT_ENGINE_CONTRACT_VERSION,
+    commands: ["prompt", "steer", "follow-up", "abort", "retry", "compact", "bash", "replace-session"],
+    events: ["lifecycle", "content", "command-outcome", "snapshot-invalidated", "diagnostic"],
+    snapshots: { supported: true, maxBytes: 1024 * 1024 },
+};
+export function createPiAgentEngineBridge(adapter, cwd) {
+    return new PiAgentEngineBridge(adapter, cwd);
+}
+class PiAgentEngineBridge {
+    adapter;
+    cwd;
+    capabilities = CAPABILITIES;
+    #session;
+    constructor(adapter, cwd) {
+        this.adapter = adapter;
+        this.cwd = cwd;
+    }
+    async createSession(input) {
+        if (this.#session)
+            return this.#session;
+        if (input.cwd !== this.cwd)
+            throw new TypeError("composed Pi engine cannot change working directory");
+        await this.adapter.start();
+        this.#session = new PiAgentSessionBridge(this.adapter, input.sessionId);
+        return this.#session;
+    }
+    async dispose() { await this.adapter.dispose(); }
+}
+class PiAgentSessionBridge {
+    adapter;
+    sessionId;
+    capabilities = CAPABILITIES;
+    lifecycle = "starting";
+    #listeners = new Set();
+    #unsubscribe;
+    constructor(adapter, sessionId) {
+        this.adapter = adapter;
+        this.sessionId = sessionId;
+        this.#unsubscribe = adapter.onEvent(event => {
+            const converted = convertEvent(event);
+            if (!converted)
+                return;
+            if (converted.type === "lifecycle")
+                this.lifecycle = converted.lifecycle;
+            for (const listener of this.#listeners)
+                listener(converted);
+        });
+        this.lifecycle = toLifecycle(adapter.snapshot().view.lifecycle);
+    }
+    async execute(command) {
+        assertAgentCommand(command, this.capabilities);
+        if (command.sessionId !== this.sessionId)
+            return "rejected";
+        if (command.type === "bash") {
+            const result = await this.adapter.executeBashWorkflow(command.command, false);
+            return !result.cancelled && result.exitCode === 0 ? "completed" : result.cancelled ? "cancelled" : "failed";
+        }
+        const result = await this.adapter.execute(toOwnedCommand(command));
+        return result.outcome === "timed-out" ? "failed" : result.outcome;
+    }
+    subscribe(listener) { this.#listeners.add(listener); return () => this.#listeners.delete(listener); }
+    async snapshot() {
+        const snapshot = this.adapter.snapshot();
+        return {
+            contractVersion: AGENT_ENGINE_CONTRACT_VERSION,
+            snapshotId: snapshot.snapshotId,
+            sessionId: this.sessionId,
+            revision: snapshot.view.revision,
+            sequence: snapshot.sequence,
+            lifecycle: toLifecycle(snapshot.view.lifecycle),
+            content: snapshot.view.transcript.map(toMessage),
+            activeCommandIds: snapshot.view.activeCommandIds,
+            capabilities: this.capabilities,
+        };
+    }
+    async dispose() { this.#unsubscribe(); this.#listeners.clear(); await this.adapter.dispose(); this.lifecycle = "stopped"; }
+}
+function toOwnedCommand(command) {
+    const base = { correlationId: command.commandId, sessionId: command.sessionId };
+    if (command.type === "replace-session")
+        return command.source.kind === "new" ? { ...base, type: "new-session" } : { ...base, type: "resume-session", sessionPath: command.source.sessionPath };
+    if (command.type === "prompt" || command.type === "steer" || command.type === "follow-up")
+        return { ...base, type: command.type, text: command.text };
+    return { ...base, type: command.type };
+}
+function convertEvent(event) {
+    const base = { contractVersion: AGENT_ENGINE_CONTRACT_VERSION, sessionId: event.sessionId, sequence: event.sequence };
+    if (event.type === "session-lifecycle")
+        return { ...base, type: "lifecycle", lifecycle: toLifecycle(event.lifecycle), reason: event.reason };
+    if (event.type === "transcript-block")
+        return { ...base, type: "content", content: toMessage(event.block) };
+    if (event.type === "command-outcome")
+        return { ...base, type: "command-outcome", commandId: event.correlationId, outcome: event.outcome === "timed-out" ? "failed" : event.outcome, diagnostic: event.diagnostic };
+    if (event.type === "diagnostic")
+        return { ...base, type: "diagnostic", code: event.diagnostic.code, message: event.diagnostic.message, recoverable: event.diagnostic.recoverable };
+    if (event.type === "session-view")
+        return { ...base, type: "snapshot-invalidated", expectedRevision: event.view.revision };
+    return null;
+}
+function toLifecycle(lifecycle) {
+    return lifecycle === "suspended" ? "ready" : lifecycle;
+}
+function toMessage(block) {
+    const role = block.kind === "user" ? "user" : block.kind === "system" ? "system" : block.kind === "tool-call" || block.kind === "tool-result" ? "tool" : "assistant";
+    return { id: block.id, role, status: block.status === "live" ? "streaming" : "final", content: [{ kind: "text", text: block.text }] };
+}

package/dist/composition/index.d.ts

@@ -0,0 +1,3 @@
+export { composeOwnedUi, composeOwnedUiApplication, type OwnedUiComposition, type OwnedUiCompositionOptions, } from "./owned-ui.js";
+export { composeProcess, type ProcessComposition, type ProcessCompositionOptions, } from "./process.js";
+export { createOwnedRouteHost } from "./settings-route-host.js";

package/dist/composition/index.js

@@ -0,0 +1,3 @@
+export { composeOwnedUi, composeOwnedUiApplication, } from "./owned-ui.js";
+export { composeProcess, } from "./process.js";
+export { createOwnedRouteHost } from "./settings-route-host.js";

package/dist/composition/owned-ui.d.ts

@@ -0,0 +1,25 @@
+import { type PiEngineAdapter } from "../integrations/pi/engine/index.js";
+import { OwnedUiSettingsSession } from "../ui/settings/index.js";
+import type { OwnedUiApplicationPort, PresentationTerminalPort } from "../contracts/presentation/index.js";
+export interface OwnedUiCompositionOptions {
+    readonly cwd?: string;
+    readonly terminal?: PresentationTerminalPort;
+    readonly createPiAdapter?: () => Promise<PiEngineAdapter>;
+    /**
+     * A1 profile whose settings this session reads and writes. Omitted keeps the
+     * session settings-free, which is what the pinned comparison paths use.
+     */
+    readonly profileId?: string;
+    /**
+     * Whether A1's product-specific surfaces are reachable. Comparison profiles
+     * use the same composition with those surfaces withheld.
+     */
+    readonly ownedSurfaces?: "on" | "off";
+}
+export interface OwnedUiComposition {
+    readonly application: OwnedUiApplicationPort;
+    /** Present when a profile was supplied, so the caller can resolve settings before start. */
+    readonly settings: OwnedUiSettingsSession | null;
+}
+export declare function composeOwnedUiApplication(options?: OwnedUiCompositionOptions): Promise<OwnedUiApplicationPort>;
+export declare function composeOwnedUi(options?: OwnedUiCompositionOptions): Promise<OwnedUiComposition>;

package/dist/composition/owned-ui.js

@@ -0,0 +1,40 @@
+import { resolveProductPaths } from "../foundation/lifecycle/index.js";
+import { applyConfiguredPiTheme, getAvailablePiThemes } from "../integrations/pi/components/index.js";
+import { createPiEngineAdapter } from "../integrations/pi/engine/index.js";
+import { OwnedUiSessionShell } from "../integrations/pi/owned-ui/index.js";
+import { OwnedUiSettingsSession, OwnedUiSettingsStore } from "../ui/settings/index.js";
+import { createPiTerminalBridge } from "../integrations/pi/tui-runtime/index.js";
+import { createOwnedRouteHost } from "./settings-route-host.js";
+export async function composeOwnedUiApplication(options = {}) {
+    return (await composeOwnedUi(options)).application;
+}
+export async function composeOwnedUi(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const adapter = options.createPiAdapter
+        ? await options.createPiAdapter()
+        : await createPiEngineAdapter({ cwd, availableThemes: () => getAvailablePiThemes().map(theme => theme.name) });
+    const settings = options.profileId === undefined
+        ? null
+        : new OwnedUiSettingsSession({
+            store: new OwnedUiSettingsStore({ configDir: resolveProductPaths().configDir, profileId: options.profileId }),
+            agentProvider: () => adapter.settingsPort(),
+        });
+    // Before anything is drawn, so every surface uses the configured theme rather
+    // than the one guessed from the terminal's background.
+    applyConfiguredPiTheme(adapter.configuredTheme());
+    const routeHost = settings === null || options.ownedSurfaces === "off" ? null : createOwnedRouteHost(settings);
+    const shell = new OwnedUiSessionShell({
+        backend: adapter,
+        cwd,
+        ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
+        ...(routeHost === null ? {} : { routeHost }),
+    });
+    const application = {
+        get disposed() { return adapter.disposed; },
+        start: () => shell.start(),
+        flush: () => adapter.flushEvents(),
+        waitUntilStopped: () => shell.waitUntilStopped(),
+        dispose: () => shell.dispose(),
+    };
+    return { application, settings };
+}

package/dist/composition/process.d.ts

@@ -0,0 +1,16 @@
+import { type AgentEnginePort } from "../contracts/agent-engine/index.js";
+import { type PiEngineAdapter } from "../integrations/pi/engine/index.js";
+import { type PresentationComponentPort, type PresentationRuntimePort, type PresentationTerminalPort } from "../contracts/presentation/index.js";
+export interface ProcessCompositionOptions {
+    readonly cwd?: string;
+    readonly sessionId?: string;
+    readonly engine?: AgentEnginePort;
+    readonly presentationFactory?: (root: PresentationComponentPort, terminal: PresentationTerminalPort) => PresentationRuntimePort;
+    readonly createPiAdapter?: () => Promise<PiEngineAdapter>;
+}
+export interface ProcessComposition {
+    readonly engine: AgentEnginePort;
+    createPresentation(root: PresentationComponentPort, terminal: PresentationTerminalPort): PresentationRuntimePort;
+    dispose(): Promise<void>;
+}
+export declare function composeProcess(options?: ProcessCompositionOptions): Promise<ProcessComposition>;

package/dist/composition/process.js

@@ -0,0 +1,45 @@
+import { assertAgentCapabilityContract, } from "../contracts/agent-engine/index.js";
+import { createPiEngineAdapter } from "../integrations/pi/engine/index.js";
+import { createPiPresentationRuntime } from "../integrations/pi/tui-runtime/index.js";
+import { assertPresentationComponent, assertPresentationRuntime, } from "../contracts/presentation/index.js";
+import { createPiAgentEngineBridge } from "./agent-engine-bridge.js";
+export async function composeProcess(options = {}) {
+    let engine = options.engine;
+    if (!engine) {
+        const adapter = options.createPiAdapter
+            ? await options.createPiAdapter()
+            : await createPiEngineAdapter({
+                ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+                ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId }),
+            });
+        engine = createPiAgentEngineBridge(adapter, options.cwd ?? process.cwd());
+    }
+    assertAgentCapabilityContract(engine.capabilities);
+    if (typeof engine.createSession !== "function" || typeof engine.dispose !== "function")
+        throw new TypeError("composed engine does not satisfy the neutral engine port");
+    const presentations = new Set();
+    let disposed = false;
+    return {
+        engine,
+        createPresentation(root, terminal) {
+            if (disposed)
+                throw new Error("process composition is disposed");
+            assertPresentationComponent(root);
+            const runtime = options.presentationFactory?.(root, terminal) ?? createPiPresentationRuntime(root, terminal);
+            assertPresentationRuntime(runtime);
+            presentations.add(runtime);
+            return runtime;
+        },
+        async dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            const failures = [];
+            for (const runtime of [...presentations].reverse())
+                await runtime.stop().catch(error => failures.push(error));
+            await engine.dispose().catch(error => failures.push(error));
+            if (failures.length)
+                throw new AggregateError(failures, "process composition disposal failed");
+        },
+    };
+}

package/dist/composition/settings-route-host.d.ts

@@ -0,0 +1,8 @@
+import type { UiRouteHost } from "../integrations/pi/owned-ui/index.js";
+import type { OwnedUiSettingsSession } from "../ui/settings/index.js";
+/**
+ * Registers the A1-owned screens and adapts the app host to the shell's route
+ * seam. The shell mounts whatever surface it is handed and forwards keys; it
+ * never learns what an app is.
+ */
+export declare function createOwnedRouteHost(settings: OwnedUiSettingsSession): UiRouteHost;

package/dist/composition/settings-route-host.js

@@ -0,0 +1,73 @@
+import { SETTINGS_APP_ID, SETTINGS_ROUTE, SettingsApp } from "../features/owned-ui/index.js";
+import { piTheme } from "../integrations/pi/components/index.js";
+import { UiAppHost, UiAppRegistry } from "../ui/apps/index.js";
+import { faint } from "../ui/components/index.js";
+/**
+ * Registers the A1-owned screens and adapts the app host to the shell's route
+ * seam. The shell mounts whatever surface it is handed and forwards keys; it
+ * never learns what an app is.
+ */
+export function createOwnedRouteHost(settings) {
+    const registry = new UiAppRegistry();
+    registry.register({ id: SETTINGS_APP_ID, route: SETTINGS_ROUTE, create: () => new SettingsApp(settings) });
+    return {
+        claims: route => registry.forRoute(route) !== null,
+        open: route => {
+            const registration = registry.forRoute(route);
+            if (registration === null)
+                return null;
+            let size = { width: 80, height: 24 };
+            let frame = [];
+            let closed = false;
+            let onRender = () => undefined;
+            let onExit = () => undefined;
+            const host = new UiAppHost({
+                registry,
+                closeOnInterrupt: true,
+                theme: pinnedTheme(),
+                surface: {
+                    size: () => size,
+                    requestRender: () => onRender(),
+                    exit: () => onExit(),
+                    present: lines => {
+                        if (lines === null)
+                            closed = true;
+                        else
+                            frame = lines;
+                    },
+                },
+            });
+            host.open(registration.id);
+            const surface = {
+                id: registration.id,
+                render: (width, height) => {
+                    size = { width, height };
+                    host.render();
+                    return frame.length === height ? frame : [...frame.slice(0, height), ...Array(Math.max(0, height - frame.length)).fill("")];
+                },
+                handleInput: data => host.handleInput(data).consumed,
+                handleMouse: event => host.handleMouse(event).consumed,
+                isClosed: () => closed || !host.isPresenting,
+                close: () => host.close(),
+                onRenderRequested: listener => { onRender = listener; },
+                onExitRequested: listener => { onExit = listener; },
+            };
+            return surface;
+        },
+    };
+}
+/** Maps A1 UI tokens onto the pinned Pi theme so owned screens match the shell. */
+function pinnedTheme() {
+    return {
+        fg: (token, text) => piTheme().fg(token, text),
+        bold: (text) => piTheme().bold(text),
+        // Unpainted, so a list reads against the terminal the reader actually has
+        // rather than against the background the configured theme was built for.
+        plain: (text) => text,
+        // Quiet, and quieter again: the terminal's own faint attribute over the
+        // dimmest colour the theme has.
+        disabled: (text) => faint(piTheme().fg("dim", text)),
+        highlight: (text) => `${text}`,
+        panel: (text) => `${text}`,
+    };
+}

package/dist/{src/features → features}/owned-ui/customization.d.ts

@@ -1,4 +1,4 @@
-import { type OwnedUiCommand, type OwnedUiCustomization, type OwnedUiSlotId, type OwnedUiTranscriptBlock } from "../../foundation/owned-ui-contracts/index.js";
+import { type OwnedUiCommand, type OwnedUiCustomization, type OwnedUiSlotId, type OwnedUiTranscriptBlock } from "../../contracts/owned-ui/index.js";
 export interface OwnedUiSlotImplementation {
     readonly payload: unknown;
     render?(input: unknown, width: number): readonly string[];

package/dist/{src/features → features}/owned-ui/customization.js

@@ -1,4 +1,4 @@
-import { assertOwnedUiCustomization, } from "../../foundation/owned-ui-contracts/index.js";
+import { assertOwnedUiCustomization, } from "../../contracts/owned-ui/index.js";
 export class OwnedCommandSurface {
     #handlers = new Map();
     #sequence = 0;

package/dist/{src/features → features}/owned-ui/diagnostics.d.ts

@@ -1,4 +1,4 @@
-import type { OwnedUiDiagnostics } from "../../foundation/owned-ui-contracts/index.js";
+import type { OwnedUiDiagnostics } from "../../contracts/owned-ui/index.js";
 export interface OwnedUiFrameObservation {
     readonly requestedFrames: number;
     readonly presentedFrames: number;

package/dist/{src/features → features}/owned-ui/run.d.ts

@@ -1,5 +1,5 @@
-import type { OwnedUiApplicationPort } from "../../foundation/presentation-contracts/index.js";
-import type { OwnedUiSettingsSession } from "../../foundation/owned-ui-settings/index.js";
+import type { OwnedUiApplicationPort } from "../../contracts/presentation/index.js";
+import type { OwnedUiSettingsSession } from "../../ui/settings/index.js";
 export interface OwnedUiRunOptions {
     readonly application: OwnedUiApplicationPort;
     /**

package/dist/{src/features → features}/owned-ui/settings-app.d.ts

@@ -1,6 +1,6 @@
-import type { AppHostServices, UiApp } from "../../foundation/ui-apps/index.js";
-import { ShortcutRegistry, type PaneInputResult, type PaneMouseEvent, type PaneRect } from "../../foundation/ui-components/index.js";
-import type { OwnedUiSettingsSession } from "../../foundation/owned-ui-settings/index.js";
+import type { AppHostServices, UiApp } from "../../ui/apps/index.js";
+import { ShortcutRegistry, type PaneInputResult, type PaneMouseEvent, type PaneRect } from "../../ui/components/index.js";
+import type { OwnedUiSettingsSession } from "../../ui/settings/index.js";
 export declare const SETTINGS_APP_ID = "settings";
 export declare const SETTINGS_ROUTE = "settings";
 type Action = "move-up" | "move-down" | "block-up" | "block-down" | "first" | "last" | "page-up" | "page-down" | "previous-value" | "next-value" | "activate" | "open-filter" | "close" | "part-previous" | "part-next" | "part-change";

package/dist/{src/features → features}/owned-ui/settings-app.js

@@ -1,4 +1,4 @@
-import { GLOBAL_SCOPE, LineInput, PLAIN_THEME, ShortcutRegistry, PROMPT_GLYPH, blockJumpTarget, dialogValueColumn, numericValues, RAIL_COLUMNS, renderDialogPanel, renderEmptyState, renderGroupHeader, renderInputRow, renderStatusLine, renderListRow, renderNote, dialogRowAt, menuRowAt, regionAt, renderValueMenu, withScrollbarRail, stepperEnds, steppedValue, valueColumnFor, valueMenuFrame, promptRule, caretCell, blockRowSpan, displayWidth, faint, handleLineInputKey, humanizeLabel, humanizeTitle, indexOfKey, isThumbRow, layoutList, moveSelection, rowKey, scrollForSelection, scrollbarGeometry, selectableIndexes, } from "../../foundation/ui-components/index.js";
+import { GLOBAL_SCOPE, LineInput, PLAIN_THEME, ShortcutRegistry, PROMPT_GLYPH, blockJumpTarget, dialogValueColumn, numericValues, RAIL_COLUMNS, renderDialogPanel, renderEmptyState, renderGroupHeader, renderInputRow, renderStatusLine, renderListRow, renderNote, dialogRowAt, menuRowAt, regionAt, renderValueMenu, withScrollbarRail, stepperEnds, steppedValue, valueColumnFor, valueMenuFrame, promptRule, caretCell, blockRowSpan, displayWidth, faint, handleLineInputKey, humanizeLabel, humanizeTitle, indexOfKey, isThumbRow, layoutList, moveSelection, rowKey, scrollForSelection, scrollbarGeometry, selectableIndexes, } from "../../ui/components/index.js";
 export const SETTINGS_APP_ID = "settings";
 export const SETTINGS_ROUTE = "settings";
 const SCOPE = SETTINGS_APP_ID;

package/dist/{src/features → features}/workspace/capabilities.d.ts

@@ -1,4 +1,4 @@
-import type { ManagedAgentDescriptor } from "../../foundation/workspace-contracts/index.js";
+import type { ManagedAgentDescriptor } from "../../contracts/workspace/index.js";
 export type WorkspaceCapabilityAction = {
     readonly type: "structured-command";
     readonly command: string;

package/dist/{src/features → features}/workspace/reducer.d.ts

@@ -1,4 +1,4 @@
-import { type ManagedAgentDescriptor } from "../../foundation/workspace-contracts/index.js";
+import { type ManagedAgentDescriptor } from "../../contracts/workspace/index.js";
 export interface WorkspaceAgentFailure {
     readonly code: string;
     readonly message: string;

package/dist/{src/features → features}/workspace/reducer.js

@@ -1,4 +1,4 @@
-import { assertManagedAgentDescriptor, } from "../../foundation/workspace-contracts/index.js";
+import { assertManagedAgentDescriptor, } from "../../contracts/workspace/index.js";
 const REMOVABLE_STATES = new Set(["stopped", "failed", "discontinuous"]);
 export class WorkspaceReducer {
     workspaceId;

package/dist/{src/features → features}/workspace/router.d.ts

@@ -1,5 +1,5 @@
 import { type StructuredCommandRecord } from "../../foundation/structured-agent-runtime/index.js";
-import type { ManagedAgentDescriptor } from "../../foundation/workspace-contracts/index.js";
+import type { ManagedAgentDescriptor } from "../../contracts/workspace/index.js";
 import { WorkspaceReducer, type WorkspaceAgentState, type WorkspaceView } from "./reducer.js";
 export interface RoutedStructuredCommand {
     readonly agentId: string;

package/dist/{src/features → features}/workspace/store.d.ts

@@ -1,4 +1,4 @@
-import type { AgentRecoveryAuthority, RecoveryReferenceId } from "../../foundation/workspace-contracts/index.js";
+import type { AgentRecoveryAuthority, RecoveryReferenceId } from "../../contracts/workspace/index.js";
 import { WorkspaceReducer, type WorkspaceView } from "./reducer.js";
 export declare class WorkspaceStore {
     #private;

package/dist/{src/foundation → foundation}/launch-guardian/main.js

@@ -4,7 +4,7 @@ import { resolve } from "node:path";
 import { assertLaunchProfileId } from "../lifecycle/index.js";
 import { closeVerifiedContainment, LinuxNativeProcessInspector, NativeGuardianContainment, resolveProcessGuardianPath, verifyProcessGuardianArtifact, WindowsNativeProcessInspector, } from "../process-containment/index.js";
 import { SupervisorClient } from "../protocol/index.js";
-import { resolveProductPaths } from "../supervision/index.js";
+import { resolveCohortEndpoint, resolveProductPaths } from "../supervision/index.js";
 export async function runLaunchGuardian(options) {
     assertLaunchProfileId(options.profileId);
     const environment = { ...(options.environment ?? process.env) };
@@ -17,7 +17,13 @@ export async function runLaunchGuardian(options) {
     if (!guardianIdentity)
         throw diagnosticError("launch guardian cannot verify its own native process identity", "PROCESS_IDENTITY_UNAVAILABLE");
     const client = options.control ?? new SupervisorClient(environment[PRODUCT_IDENTITY.environment.releaseId]);
-    await client.connect(paths.endpoint);
+    // An instance belongs to the cohort that launched it and talks to that cohort's endpoint
+    // for its whole life, whatever release becomes the active one meanwhile.
+    const releaseId = environment[PRODUCT_IDENTITY.environment.releaseId];
+    const endpoint = releaseId
+        ? resolveCohortEndpoint(paths, releaseId, environment).endpoint
+        : paths.endpoint;
+    await client.connect(endpoint);
     const containment = options.containment ?? new NativeGuardianContainment(instanceId, helperPath, resolve(paths.runtimeDir, "launch-instances", `${instanceId}.ready.json`));
     const stop = stopRequests(client, instanceId);
     let rootIdentity = null;

package/dist/foundation/lifecycle/paths.d.ts

@@ -0,0 +1,28 @@
+export interface ProductPaths {
+    readonly configDir: string;
+    readonly dataDir: string;
+    readonly runtimeDir: string;
+    readonly databasePath: string;
+    /** The endpoint written by releases that predate cohort-scoped identity. */
+    readonly endpoint: string;
+    /** The metadata written by releases that predate cohort-scoped identity. */
+    readonly endpointMetadataPath: string;
+    readonly endpointsDir: string;
+    readonly supervisorLogPath: string;
+}
+/** Where one cohort listens, and where it records that it is listening. */
+export interface CohortEndpointPaths {
+    readonly endpoint: string;
+    readonly endpointMetadataPath: string;
+}
+/**
+ * Endpoint identity for one release cohort. Two cohorts can be live at once — an update
+ * leaves a working session on the release it started on — so the name a supervisor listens
+ * on has to name the release as well as the runtime directory, or the two contend for one
+ * endpoint and replacing one means ending the other.
+ *
+ * An explicit endpoint override keeps its single endpoint: it is how an isolated run pins
+ * the address it is going to talk to.
+ */
+export declare function resolveCohortEndpoint(paths: ProductPaths, releaseId: string, environment?: NodeJS.ProcessEnv, hostPlatform?: NodeJS.Platform): CohortEndpointPaths;
+export declare function resolveProductPaths(environment?: NodeJS.ProcessEnv, hostPlatform?: NodeJS.Platform, fallbackHome?: string): ProductPaths;

package/dist/{src/foundation → foundation}/lifecycle/paths.js

@@ -2,6 +2,26 @@ import { createHash } from "node:crypto";
 import { homedir, platform } from "node:os";
 import { posix, win32 } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
+/**
+ * Endpoint identity for one release cohort. Two cohorts can be live at once — an update
+ * leaves a working session on the release it started on — so the name a supervisor listens
+ * on has to name the release as well as the runtime directory, or the two contend for one
+ * endpoint and replacing one means ending the other.
+ *
+ * An explicit endpoint override keeps its single endpoint: it is how an isolated run pins
+ * the address it is going to talk to.
+ */
+export function resolveCohortEndpoint(paths, releaseId, environment = process.env, hostPlatform = platform()) {
+    if (environment[PRODUCT_IDENTITY.environment.endpoint]) {
+        return { endpoint: paths.endpoint, endpointMetadataPath: paths.endpointMetadataPath };
+    }
+    const path = hostPlatform === "win32" ? win32 : posix;
+    const token = createHash("sha256").update(releaseId).digest("hex").slice(0, 16);
+    const endpoint = hostPlatform === "win32"
+        ? `${paths.endpoint}-${token}`
+        : path.join(paths.runtimeDir, `${token}-${PRODUCT_IDENTITY.endpoint.unixSocketFilename}`);
+    return { endpoint, endpointMetadataPath: path.join(paths.endpointsDir, `${token}.json`) };
+}
 export function resolveProductPaths(environment = process.env, hostPlatform = platform(), fallbackHome = homedir()) {
     const windows = hostPlatform === "win32";
     const path = windows ? win32 : posix;
@@ -37,6 +57,7 @@ export function resolveProductPaths(environment = process.env, hostPlatform = pl
         databasePath: path.resolve(databaseOverride ?? path.join(dataDir, PRODUCT_IDENTITY.endpoint.databaseFilename)),
         endpoint,
         endpointMetadataPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.metadataFilename),
+        endpointsDir: path.join(runtimeDir, "endpoints"),
         supervisorLogPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.supervisorLogFilename),
     };
 }

package/dist/{src/foundation → foundation}/native-host-protocol/messages.d.ts

@@ -1,4 +1,4 @@
-import { type CorrelationId, type NativeHostCommand, type NativeHostEvent, type NativeHostHello, type PaneId, type TerminalSessionLaunch } from "../workspace-contracts/index.js";
+import { type CorrelationId, type NativeHostCommand, type NativeHostEvent, type NativeHostHello, type PaneId, type TerminalSessionLaunch } from "../../contracts/workspace/index.js";
 export declare const NATIVE_HOST_PROTOCOL_NAME: string;
 export declare const MAX_NATIVE_HOST_MESSAGE_BYTES: number;
 export type NativeHostProofMessage = {

package/dist/{src/foundation → foundation}/native-host-protocol/messages.js

@@ -1,4 +1,4 @@
-import { NATIVE_HOST_PROTOCOL_VERSION, assertNativeHostCommand, assertTerminalSessionLaunch, } from "../workspace-contracts/index.js";
+import { NATIVE_HOST_PROTOCOL_VERSION, assertNativeHostCommand, assertTerminalSessionLaunch, } from "../../contracts/workspace/index.js";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 export const NATIVE_HOST_PROTOCOL_NAME = PRODUCT_IDENTITY.protocol.nativeHostSchema;
 export const MAX_NATIVE_HOST_MESSAGE_BYTES = 1024 * 1024;