@timurproko/a1 0.1.0 → 0.1.1-dev.10

package/dist/src/composition/index.js

@@ -0,0 +1,258 @@
+import { AGENT_ENGINE_CONTRACT_VERSION, assertAgentCapabilityContract, assertAgentCommand, } from "../foundation/agent-engine-contracts/index.js";
+import { createPiEngineAdapter } from "../foundation/pi-engine-adapter/index.js";
+import { createPiPresentationRuntime, createPiTerminalBridge } from "../foundation/pi-tui-runtime-adapter/index.js";
+import { assertPresentationComponent, assertPresentationRuntime, } from "../foundation/presentation-contracts/index.js";
+import { OwnedUiSessionShell } from "../foundation/pi-owned-ui-integration/index.js";
+import { OwnedUiSettingsSession, OwnedUiSettingsStore } from "../foundation/owned-ui-settings/index.js";
+import { UiAppHost, UiAppRegistry } from "../foundation/ui-apps/index.js";
+import { applyConfiguredPiTheme, getAvailablePiThemes, piTheme } from "../foundation/pi-component-adapter/index.js";
+import { faint } from "../foundation/ui-components/index.js";
+import { SETTINGS_APP_ID, SETTINGS_ROUTE, SettingsApp } from "../features/owned-ui/index.js";
+import { resolveProductPaths } from "../foundation/lifecycle/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 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 };
+}
+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 = new PiAgentEngineBridge(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");
+        },
+    };
+}
+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 owned = toOwnedCommand(command);
+        const result = await this.adapter.execute(owned);
+        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 }] };
+}
+/**
+ * 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/launch/development-launch.d.ts

@@ -6,4 +6,3 @@ export interface DevelopmentLaunchEnvironment {
     readonly environment: NodeJS.ProcessEnv;
 }
 export declare function resolveDevelopmentLaunchEnvironment(canonicalPackageRoot: string, releaseId: string, source?: NodeJS.ProcessEnv, temporaryDirectory?: string): DevelopmentLaunchEnvironment;
-//# sourceMappingURL=development-launch.d.ts.map

package/dist/src/features/launch/development-launch.js

@@ -1,14 +1,16 @@
 import { createHash, randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
 export function resolveDevelopmentLaunchEnvironment(canonicalPackageRoot, releaseId, source = process.env, temporaryDirectory = tmpdir()) {
     const checkoutId = createHash("sha256").update(resolve(canonicalPackageRoot).toLowerCase()).digest("hex").slice(0, 16);
-    const instanceId = source.ADDONE_DEV_INSTANCE_ID
-        ? createHash("sha256").update(source.ADDONE_DEV_INSTANCE_ID).digest("hex").slice(0, 16)
+    const selectedInstanceId = source[PRODUCT_IDENTITY.environment.developmentInstanceId];
+    const instanceId = selectedInstanceId
+        ? createHash("sha256").update(selectedInstanceId).digest("hex").slice(0, 16)
         : randomUUID().replaceAll("-", "").slice(0, 16);
-    const developmentRoot = resolve(source.ADDONE_DEV_ROOT
-        ?? join(temporaryDirectory, "addone-development", checkoutId, releaseId, "instances", instanceId));
-    const dataDir = resolve(source.ADDONE_DATA_DIR ?? join(developmentRoot, "data"));
+    const developmentRoot = resolve(source[PRODUCT_IDENTITY.environment.developmentRoot]
+        ?? join(temporaryDirectory, PRODUCT_IDENTITY.state.developmentDirectory, checkoutId, releaseId, "instances", instanceId));
+    const dataDir = resolve(source[PRODUCT_IDENTITY.environment.dataDir] ?? join(developmentRoot, "data"));
     return {
         checkoutId,
         releaseId,
@@ -16,12 +18,11 @@ export function resolveDevelopmentLaunchEnvironment(canonicalPackageRoot, releas
         developmentRoot,
         environment: {
             ...source,
-            ADDONE_DEV_INSTANCE_ID: instanceId,
-            ADDONE_CONFIG_DIR: resolve(source.ADDONE_CONFIG_DIR ?? join(developmentRoot, "config")),
-            ADDONE_DATA_DIR: dataDir,
-            ADDONE_RUNTIME_DIR: resolve(source.ADDONE_RUNTIME_DIR ?? join(developmentRoot, "runtime")),
-            ADDONE_DATABASE_PATH: resolve(source.ADDONE_DATABASE_PATH ?? join(dataDir, "control.sqlite3")),
+            [PRODUCT_IDENTITY.environment.developmentInstanceId]: instanceId,
+            [PRODUCT_IDENTITY.environment.configDir]: resolve(source[PRODUCT_IDENTITY.environment.configDir] ?? join(developmentRoot, "config")),
+            [PRODUCT_IDENTITY.environment.dataDir]: dataDir,
+            [PRODUCT_IDENTITY.environment.runtimeDir]: resolve(source[PRODUCT_IDENTITY.environment.runtimeDir] ?? join(developmentRoot, "runtime")),
+            [PRODUCT_IDENTITY.environment.databasePath]: resolve(source[PRODUCT_IDENTITY.environment.databasePath] ?? join(dataDir, PRODUCT_IDENTITY.endpoint.databaseFilename)),
         },
     };
 }
-//# sourceMappingURL=development-launch.js.map

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

@@ -5,4 +5,3 @@ export * from "./profile-paths.js";
 export * from "./prepare-launch.js";
 export * from "./profiles.js";
 export * from "./runtime-selection.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -5,4 +5,3 @@ export * from "./profile-paths.js";
 export * from "./prepare-launch.js";
 export * from "./profiles.js";
 export * from "./runtime-selection.js";
-//# sourceMappingURL=index.js.map

package/dist/src/features/launch/initialize-profile.d.ts

@@ -3,5 +3,4 @@ export interface InitializedProfile {
     readonly root: string;
     readonly directories: readonly string[];
 }
-export declare function initializeAddOneProfile(root: string): Promise<InitializedProfile>;
-//# sourceMappingURL=initialize-profile.d.ts.map
+export declare function initializeProductProfile(root: string): Promise<InitializedProfile>;

package/dist/src/features/launch/initialize-profile.js

@@ -6,7 +6,7 @@ export const PI_PROFILE_RESOURCE_DIRECTORIES = Object.freeze([
     "prompts",
     "themes",
 ]);
-export async function initializeAddOneProfile(root) {
+export async function initializeProductProfile(root) {
     const normalizedRoot = resolve(root);
     await ensureSafeDirectoryChain(normalizedRoot);
     const directories = [];
@@ -38,7 +38,7 @@ async function ensureSafeDirectoryChain(root) {
         current = parent;
     }
     for (const path of missing.reverse())
-        await mkdir(path, { mode: 0o700 });
+        await createOwnedDirectory(path, "profile path");
 }
 async function ensureOwnedDirectory(path) {
     const metadata = await lstat(path).catch(error => {
@@ -51,9 +51,29 @@ async function ensureOwnedDirectory(path) {
             throw new Error(`profile resource path is not an owned directory: ${path}`);
         return;
     }
-    await mkdir(path, { mode: 0o700 });
+    await createOwnedDirectory(path, "profile resource path");
+}
+/**
+ * Creates a directory, treating "it already exists" as another launch having won
+ * the race rather than as a failure — but still refusing what it finds if that is
+ * not an owned directory.
+ */
+async function createOwnedDirectory(path, subject) {
+    try {
+        await mkdir(path, { mode: 0o700 });
+        return;
+    }
+    catch (error) {
+        if (!isAlreadyThere(error))
+            throw error;
+    }
+    const metadata = await lstat(path);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink())
+        throw new Error(`${subject} is not an owned directory: ${path}`);
+}
+function isAlreadyThere(error) {
+    return typeof error === "object" && error !== null && error.code === "EEXIST";
 }
 function isMissing(error) {
     return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
-//# sourceMappingURL=initialize-profile.js.map

package/dist/src/features/launch/intent.d.ts

@@ -5,4 +5,3 @@ export interface InteractiveLaunchIntent {
 }
 export type LaunchIntent = InteractiveLaunchIntent;
 export declare function interactiveLaunchIntent(profileId: LaunchProfileId): InteractiveLaunchIntent;
-//# sourceMappingURL=intent.d.ts.map

package/dist/src/features/launch/intent.js

@@ -2,4 +2,3 @@ import { launchProfileContract } from "./profiles.js";
 export function interactiveLaunchIntent(profileId) {
     return Object.freeze({ kind: "interactive", profile: launchProfileContract(profileId) });
 }
-//# sourceMappingURL=intent.js.map

package/dist/src/features/launch/prepare-launch.d.ts

@@ -1,5 +1,5 @@
 import { type LaunchProfilePathOptions } from "./profile-paths.js";
-import { initializeAddOneProfile } from "./initialize-profile.js";
+import { initializeProductProfile } from "./initialize-profile.js";
 import type { InteractiveLaunchIntent } from "./intent.js";
 export interface PreparedInteractiveLaunch {
     readonly intent: InteractiveLaunchIntent;
@@ -8,7 +8,6 @@ export interface PreparedInteractiveLaunch {
     readonly configurationRoot: string | null;
 }
 export interface PrepareInteractiveLaunchOptions extends LaunchProfilePathOptions {
-    readonly initializeProfile?: typeof initializeAddOneProfile;
+    readonly initializeProfile?: typeof initializeProductProfile;
 }
 export declare function prepareInteractiveLaunch(intent: InteractiveLaunchIntent, environment?: NodeJS.ProcessEnv, options?: PrepareInteractiveLaunchOptions): Promise<PreparedInteractiveLaunch>;
-//# sourceMappingURL=prepare-launch.d.ts.map

package/dist/src/features/launch/prepare-launch.js

@@ -1,17 +1,17 @@
 import { configurationRootForProfile, resolveLaunchProfilePaths } from "./profile-paths.js";
-import { initializeAddOneProfile } from "./initialize-profile.js";
+import { initializeProductProfile } from "./initialize-profile.js";
 export async function prepareInteractiveLaunch(intent, environment = process.env, options = {}) {
     const paths = resolveLaunchProfilePaths({ ...options, environment });
     const configurationRoot = configurationRootForProfile(intent.profile.id, paths);
     if (configurationRoot !== null)
-        await (options.initializeProfile ?? initializeAddOneProfile)(configurationRoot);
+        await (options.initializeProfile ?? initializeProductProfile)(configurationRoot);
     const childEnvironment = { ...environment };
     if (configurationRoot === null)
         delete childEnvironment.PI_CODING_AGENT_DIR;
     else
         childEnvironment.PI_CODING_AGENT_DIR = configurationRoot;
     const piArguments = intent.profile.projectTrust === "ignore" ? ["--no-approve"] : [];
-    childEnvironment.ADDONE_LAUNCH_ARGUMENTS_JSON = JSON.stringify(piArguments);
+    childEnvironment.A1_LAUNCH_ARGUMENTS_JSON = JSON.stringify(piArguments);
     return Object.freeze({
         intent,
         environment: childEnvironment,
@@ -19,4 +19,3 @@ export async function prepareInteractiveLaunch(intent, environment = process.env
         configurationRoot,
     });
 }
-//# sourceMappingURL=prepare-launch.js.map

package/dist/src/features/launch/profile-paths.d.ts

@@ -1,8 +1,8 @@
 import type { LaunchProfileId } from "./profiles.js";
 export interface LaunchProfilePaths {
     readonly home: string;
-    readonly addoneRoot: string;
-    readonly addoneAgent: string;
+    readonly managedStateRoot: string;
+    readonly agentProfile: string;
     readonly sandbox: string;
 }
 export interface LaunchProfilePathOptions {
@@ -13,4 +13,3 @@ export interface LaunchProfilePathOptions {
 }
 export declare function resolveLaunchProfilePaths(options?: LaunchProfilePathOptions): LaunchProfilePaths;
 export declare function configurationRootForProfile(profileId: LaunchProfileId, paths: LaunchProfilePaths): string | null;
-//# sourceMappingURL=profile-paths.d.ts.map

package/dist/src/features/launch/profile-paths.js

@@ -1,21 +1,23 @@
 import { homedir } from "node:os";
 import { posix, win32 } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
 export function resolveLaunchProfilePaths(options = {}) {
     const environment = options.environment ?? process.env;
     const path = options.platform === "win32" || (options.platform === undefined && process.platform === "win32") ? win32 : posix;
-    const selectedHome = options.home ?? environment.ADDONE_PROFILE_HOME ?? options.readHome?.() ?? homedir();
+    const selectedHome = options.home ?? environment[PRODUCT_IDENTITY.environment.profileHome] ?? options.readHome?.() ?? homedir();
     const home = validateAbsolutePath(selectedHome, "effective user home", path);
-    const addoneRoot = path.resolve(home, ".a1");
+    const agentProfile = path.resolve(home, PRODUCT_IDENTITY.state.piAgentProfile);
+    const managedStateRoot = path.dirname(agentProfile);
     return Object.freeze({
         home,
-        addoneRoot,
-        addoneAgent: path.resolve(addoneRoot, "agent"),
-        sandbox: path.resolve(addoneRoot, "sandbox"),
+        managedStateRoot,
+        agentProfile,
+        sandbox: path.resolve(home, PRODUCT_IDENTITY.state.piSandboxProfile),
     });
 }
 export function configurationRootForProfile(profileId, paths) {
-    if (profileId === "addone")
-        return paths.addoneAgent;
+    if (profileId === "a1")
+        return paths.agentProfile;
     if (profileId === "sandbox")
         return paths.sandbox;
     return null;
@@ -27,4 +29,3 @@ function validateAbsolutePath(value, name, path) {
         throw new TypeError(`${name} must be absolute`);
     return path.resolve(value);
 }
-//# sourceMappingURL=profile-paths.js.map

package/dist/src/features/launch/profiles.d.ts

@@ -1,13 +1,12 @@
 import type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
 export type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
-export type PiConfigurationRootPolicy = "addone-agent" | "pi-default" | "addone-sandbox";
+export type ConfigurationRootPolicy = "agent-profile" | "pi-default" | "sandbox-profile";
 export type ProjectTrustPolicy = "pi-default" | "ignore";
 export interface LaunchProfileContract {
     readonly id: LaunchProfileId;
     readonly productSurface: "agent" | "vanilla-baseline" | "isolated-profile";
-    readonly piConfigurationRoot: PiConfigurationRootPolicy;
+    readonly configurationRootPolicy: ConfigurationRootPolicy;
     readonly projectTrust: ProjectTrustPolicy;
-    readonly terminalCapability: "owned-ui" | "transparent";
+    readonly terminalCapability: "owned-ui";
 }
 export declare function launchProfileContract(id: LaunchProfileId): LaunchProfileContract;
-//# sourceMappingURL=profiles.d.ts.map

package/dist/src/features/launch/profiles.js

@@ -1,27 +1,26 @@
 const contracts = Object.freeze({
-    addone: Object.freeze({
-        id: "addone",
+    "a1": Object.freeze({
+        id: "a1",
         productSurface: "agent",
-        piConfigurationRoot: "addone-agent",
+        configurationRootPolicy: "agent-profile",
         projectTrust: "pi-default",
         terminalCapability: "owned-ui",
     }),
     pi: Object.freeze({
         id: "pi",
         productSurface: "vanilla-baseline",
-        piConfigurationRoot: "pi-default",
+        configurationRootPolicy: "pi-default",
         projectTrust: "pi-default",
-        terminalCapability: "transparent",
+        terminalCapability: "owned-ui",
     }),
     sandbox: Object.freeze({
         id: "sandbox",
         productSurface: "isolated-profile",
-        piConfigurationRoot: "addone-sandbox",
+        configurationRootPolicy: "sandbox-profile",
         projectTrust: "ignore",
-        terminalCapability: "transparent",
+        terminalCapability: "owned-ui",
     }),
 });
 export function launchProfileContract(id) {
     return contracts[id];
 }
-//# sourceMappingURL=profiles.js.map

package/dist/src/features/launch/runtime-selection.d.ts

@@ -1,15 +1,19 @@
 import { type LaunchProfileId } from "../../foundation/lifecycle/index.js";
-export type TransparentInteractiveProfileId = Exclude<LaunchProfileId, "addone">;
-export type InteractiveRuntimeSelection = {
+/**
+ * Every interactive command is the same composition. What differs is the
+ * configuration root each one reads and whether A1's own screens are reachable:
+ * bare `a1` is the product, while `a1 pi` and `a1 sandbox` present pinned Pi's
+ * interface and nothing of A1's own, against Pi's own profile and against an
+ * isolated one.
+ */
+export type OwnedUiProfileId = LaunchProfileId;
+export interface InteractiveRuntimeSelection {
     readonly kind: "owned-ui";
-} | {
-    readonly kind: "transparent";
-    readonly profileId: TransparentInteractiveProfileId;
-};
+    readonly profileId: OwnedUiProfileId;
+    readonly ownedSurfaces: "on" | "off";
+}
 export interface InteractiveRuntimeRunners {
-    readonly ownedUi: () => Promise<number>;
-    readonly transparent: (profileId: TransparentInteractiveProfileId) => Promise<number>;
+    readonly ownedUi: (profileId: OwnedUiProfileId, ownedSurfaces: "on" | "off") => Promise<number>;
 }
 export declare function selectInteractiveRuntime(profileId: string): InteractiveRuntimeSelection;
 export declare function runSelectedInteractiveRuntime(profileId: string, runners: InteractiveRuntimeRunners): Promise<number>;
-//# sourceMappingURL=runtime-selection.d.ts.map

package/dist/src/features/launch/runtime-selection.js

@@ -1,14 +1,13 @@
 import { assertLaunchProfileId } from "../../foundation/lifecycle/index.js";
 export function selectInteractiveRuntime(profileId) {
     assertLaunchProfileId(profileId);
-    return profileId === "addone"
-        ? Object.freeze({ kind: "owned-ui" })
-        : Object.freeze({ kind: "transparent", profileId });
+    return Object.freeze({
+        kind: "owned-ui",
+        profileId,
+        ownedSurfaces: profileId === "a1" ? "on" : "off",
+    });
 }
 export async function runSelectedInteractiveRuntime(profileId, runners) {
     const selection = selectInteractiveRuntime(profileId);
-    return selection.kind === "owned-ui"
-        ? await runners.ownedUi()
-        : await runners.transparent(selection.profileId);
+    return await runners.ownedUi(selection.profileId, selection.ownedSurfaces);
 }
-//# sourceMappingURL=runtime-selection.js.map

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

@@ -1,4 +1,4 @@
-import { type OwnedUiCommand, type OwnedUiCustomization, type OwnedUiSlotId } from "../../foundation/owned-ui-contracts/index.js";
+import { type OwnedUiCommand, type OwnedUiCustomization, type OwnedUiSlotId, type OwnedUiTranscriptBlock } from "../../foundation/owned-ui-contracts/index.js";
 export interface OwnedUiSlotImplementation {
     readonly payload: unknown;
     render?(input: unknown, width: number): readonly string[];
@@ -32,5 +32,7 @@ export declare class OwnedUiCustomizationRegistry {
     clear(): void;
     installCommands(surface: OwnedCommandSurface, sessionId: string): readonly string[];
 }
-export declare function createVanillaUiCustomizationRegistry(): OwnedUiCustomizationRegistry;
-//# sourceMappingURL=customization.d.ts.map
+export interface VanillaUiCustomizationPorts {
+    readonly renderTranscriptBlock: (block: OwnedUiTranscriptBlock, width: number) => readonly string[];
+}
+export declare function createVanillaUiCustomizationRegistry(ports: VanillaUiCustomizationPorts): OwnedUiCustomizationRegistry;

package/dist/src/features/owned-ui/customization.js

@@ -1,5 +1,4 @@
 import { assertOwnedUiCustomization, } from "../../foundation/owned-ui-contracts/index.js";
-import { renderPiShellTranscriptBlock } from "../../foundation/pi-component-adapter/index.js";
 export class OwnedCommandSurface {
     #handlers = new Map();
     #sequence = 0;
@@ -81,7 +80,7 @@ export class OwnedUiCustomizationRegistry {
         return registrations;
     }
 }
-export function createVanillaUiCustomizationRegistry() {
+export function createVanillaUiCustomizationRegistry(ports) {
     const registry = new OwnedUiCustomizationRegistry();
     const register = (slot, id, label, implementation = { payload: {} }) => registry.register({
         id,
@@ -96,7 +95,7 @@ export function createVanillaUiCustomizationRegistry() {
     });
     register("transcript-block", "vanilla-transcript", "Vanilla transcript", {
         payload: {},
-        render: (input, width) => renderPiShellTranscriptBlock(input, width, process.cwd()),
+        render: (input, width) => ports.renderTranscriptBlock(input, width),
     });
     register("tool-card", "vanilla-tool-card", "Vanilla tool cards");
     register("editor", "vanilla-editor", "Vanilla editor");
@@ -107,4 +106,3 @@ export function createVanillaUiCustomizationRegistry() {
     register("layout", "vanilla-fullscreen", "Fullscreen session");
     return registry;
 }
-//# sourceMappingURL=customization.js.map

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

@@ -31,4 +31,3 @@ export declare class OwnedUiDiagnosticsRecorder {
     snapshot(): OwnedUiDiagnosticsSnapshot;
 }
 export declare function redactDiagnosticMessage(message: string): string;
-//# sourceMappingURL=diagnostics.d.ts.map

package/dist/src/features/owned-ui/diagnostics.js

@@ -92,4 +92,3 @@ function sanitizeDiagnosticCode(code) {
         throw new TypeError("diagnostic code is invalid");
     return normalized.slice(0, 128);
 }
-//# sourceMappingURL=diagnostics.js.map