@timurproko/a1 0.1.1-dev.7 → 0.1.1-dev.8

package/bin/{a1-guardian.js → guardian.js}

@@ -10,7 +10,7 @@ const profileId = process.env.A1_LAUNCH_PROFILE ?? "a1";
 runLaunchGuardian({
   profileId,
   releaseRoot,
-  uiEntry: resolve(releaseRoot, "bin", "a1-ui.js"),
+  uiEntry: resolve(releaseRoot, "bin", "ui.js"),
   environment: process.env,
   cwd: process.cwd(),
 }).then(

package/bin/{a1-ui.js → ui.js}

@@ -3,21 +3,14 @@
 const { runSelectedInteractiveRuntime } = await import("../dist/src/features/launch/index.js");
 
 runSelectedInteractiveRuntime(process.env.A1_LAUNCH_PROFILE ?? "a1", {
-  ownedUi: async profileId => {
+  ownedUi: async (profileId, ownedSurfaces) => {
     const [{ runOwnedUi }, { composeOwnedUi }] = await Promise.all([
       import("../dist/src/features/owned-ui/index.js"),
       import("../dist/src/composition/index.js"),
     ]);
-    // A1_OWNED_SURFACES=off presents pinned Pi's interface through A1's own
-    // rendering and input, which is what the parity comparison measures.
-    const ownedSurfaces = process.env.A1_OWNED_SURFACES === "off" ? "off" : "on";
     const { application, settings } = await composeOwnedUi({ cwd: process.cwd(), profileId, ownedSurfaces });
     return await runOwnedUi({ application, ...(settings === null ? {} : { settings }) });
   },
-  transparent: async profileId => {
-    const { runSelectedTransparentRuntime } = await import("../dist/src/composition/transparent-runtime.js");
-    return await runSelectedTransparentRuntime(profileId);
-  },
 }).then(
   code => { process.exitCode = code; },
   error => {

package/dist/native/darwin-arm64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-22T13:11:56.818Z",
+  "builtAt": "2026-08-22T17:52:01.473Z",
   "artifact": {
-    "filename": "a1-process-guardian",
-    "sha256": "bb07d029b67a5eae4fbf3dea64f96cdf03462920949f2ea7e9e7b1bd33dbabc1",
+    "filename": "process-guardian",
+    "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",
     "size": 356368
   },
   "provenance": {

package/dist/native/linux-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-22T13:12:07.615Z",
+  "builtAt": "2026-08-22T17:52:01.995Z",
   "artifact": {
-    "filename": "a1-process-guardian",
-    "sha256": "f66cc7ac6d30ad424bc00992e4c5425259d36f055893d872eda9cf518bdb2ed0",
+    "filename": "process-guardian",
+    "sha256": "29e22fe29de2828982bc67ef418c4adcaab1490281477b7bea592ec6fe621bcd",
     "size": 415696
   },
   "provenance": {

package/dist/native/win32-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-22T13:12:29.999Z",
+  "builtAt": "2026-08-22T17:52:47.054Z",
   "artifact": {
-    "filename": "a1-process-guardian.exe",
-    "sha256": "83641a8a264dae32e57020ef1f37823ffe186b5acd28df18eae1afa80d25854c",
+    "filename": "process-guardian.exe",
+    "sha256": "ed14b51aeb577ecd86df4a8a9ca3ea33c27885da8d3d196b26b0d705d70a0b71",
     "size": 172544
   },
   "provenance": {

package/dist/src/composition/index.js

@@ -5,7 +5,7 @@ import { assertPresentationComponent, assertPresentationRuntime, } from "../foun
 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 { getAvailablePiThemes, piTheme } from "../foundation/pi-component-adapter/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";
@@ -29,6 +29,9 @@ export async function composeOwnedUi(options = {}) {
             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,
@@ -243,6 +246,9 @@ 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)),

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

@@ -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,7 +51,28 @@ 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";

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

@@ -7,6 +7,6 @@ export interface LaunchProfileContract {
     readonly productSurface: "agent" | "vanilla-baseline" | "isolated-profile";
     readonly configurationRootPolicy: ConfigurationRootPolicy;
     readonly projectTrust: ProjectTrustPolicy;
-    readonly terminalCapability: "owned-ui" | "transparent";
+    readonly terminalCapability: "owned-ui";
 }
 export declare function launchProfileContract(id: LaunchProfileId): LaunchProfileContract;

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

@@ -11,14 +11,14 @@ const contracts = Object.freeze({
         productSurface: "vanilla-baseline",
         configurationRootPolicy: "pi-default",
         projectTrust: "pi-default",
-        terminalCapability: "transparent",
+        terminalCapability: "owned-ui",
     }),
     sandbox: Object.freeze({
         id: "sandbox",
         productSurface: "isolated-profile",
         configurationRootPolicy: "sandbox-profile",
         projectTrust: "ignore",
-        terminalCapability: "transparent",
+        terminalCapability: "owned-ui",
     }),
 });
 export function launchProfileContract(id) {

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, "a1">;
-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 profileId: Extract<LaunchProfileId, "a1">;
-} | {
-    readonly kind: "transparent";
-    readonly profileId: TransparentInteractiveProfileId;
-};
+    readonly profileId: OwnedUiProfileId;
+    readonly ownedSurfaces: "on" | "off";
+}
 export interface InteractiveRuntimeRunners {
-    readonly ownedUi: (profileId: Extract<LaunchProfileId, "a1">) => 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>;

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

@@ -1,13 +1,13 @@
 import { assertLaunchProfileId } from "../../foundation/lifecycle/index.js";
 export function selectInteractiveRuntime(profileId) {
     assertLaunchProfileId(profileId);
-    return profileId === "a1"
-        ? Object.freeze({ kind: "owned-ui", profileId: "a1" })
-        : 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(selection.profileId)
-        : await runners.transparent(selection.profileId);
+    return await runners.ownedUi(selection.profileId, selection.ownedSurfaces);
 }

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

@@ -208,10 +208,12 @@ export class SettingsApp {
             const overRow = menuRowAt(frame, event.row - 1, event.column);
             const overMenu = overRow !== null;
             if (event.kind === "motion") {
-                // While the menu is open it owns the pointer: the row under it lights up,
-                // and nothing behind it hovers.
-                const hadHover = this.#hoverKey !== null;
-                this.#hoverKey = null;
+                // The menu owns the pointer, but the row it came from is still the thing
+                // being changed, so its value keeps reading as the one under the pointer.
+                // Only a dialog that takes the screen puts that out.
+                const hadHover = this.#hoverKey !== menu.anchorKey || this.#hoverRegion !== "value";
+                this.#hoverKey = menu.anchorKey;
+                this.#hoverRegion = "value";
                 if (!overMenu) {
                     const cleared = menu.index !== -1;
                     menu.index = -1;

package/dist/src/foundation/pi-component-adapter/index.d.ts

@@ -3,7 +3,7 @@ export * from "./conformance.js";
 export * from "./shell-components.js";
 export * from "./theme.js";
 export * from "./upstream/theme/theme-controller.js";
-export { getAvailablePiThemes } from "./upstream/theme/theme.js";
+export { applyConfiguredPiTheme, getAvailablePiThemes } from "./upstream/theme/theme.js";
 export * from "./upstream/components/countdown-timer.js";
 export * from "./upstream/components/extension-editor.js";
 export * from "./upstream/components/session-selector.js";

package/dist/src/foundation/pi-component-adapter/index.js

@@ -3,7 +3,7 @@ export * from "./conformance.js";
 export * from "./shell-components.js";
 export * from "./theme.js";
 export * from "./upstream/theme/theme-controller.js";
-export { getAvailablePiThemes } from "./upstream/theme/theme.js";
+export { applyConfiguredPiTheme, getAvailablePiThemes } from "./upstream/theme/theme.js";
 export * from "./upstream/components/countdown-timer.js";
 export * from "./upstream/components/extension-editor.js";
 export * from "./upstream/components/session-selector.js";

package/dist/src/foundation/pi-component-adapter/upstream/theme/theme.d.ts

@@ -51,3 +51,11 @@ export declare function resolvePiThemeSetting(setting: string | undefined, termi
 export declare function detectPiTerminalBackgroundFromEnv(environment?: NodeJS.ProcessEnv): PiTerminalThemeDetection;
 export declare function detectPiTerminalBackgroundTheme(ui: PiTerminalThemeDetector, timeoutMs: number, environment?: NodeJS.ProcessEnv): Promise<PiTerminalThemeDetection>;
 export declare function detectPiTerminalThemeForAuto(ui: PiTerminalThemeDetector, timeoutMs: number, environment?: NodeJS.ProcessEnv): Promise<PiTerminalTheme>;
+/**
+ * Applies the theme the reader configured, as the engine does at startup. The
+ * setting is either a theme's name or the `light/dark` pair meaning "follow the
+ * terminal", and only the pair consults the terminal's own background. An
+ * unreadable or absent setting falls back to that detection, which is what the
+ * engine does with an unset theme.
+ */
+export declare function applyConfiguredPiTheme(setting: string | undefined): PiThemeResult;

package/dist/src/foundation/pi-component-adapter/upstream/theme/theme.js

@@ -312,3 +312,15 @@ function ansi256ToHex(index) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/**
+ * Applies the theme the reader configured, as the engine does at startup. The
+ * setting is either a theme's name or the `light/dark` pair meaning "follow the
+ * terminal", and only the pair consults the terminal's own background. An
+ * unreadable or absent setting falls back to that detection, which is what the
+ * engine does with an unset theme.
+ */
+export function applyConfiguredPiTheme(setting) {
+    const detected = detectPiTerminalBackgroundFromEnv();
+    const resolved = resolvePiThemeSetting(setting, detected.theme);
+    return applyPiTheme(resolved ?? detected.theme);
+}

package/dist/src/foundation/pi-engine-adapter/adapter.d.ts

@@ -113,6 +113,11 @@ export declare class PiEngineAdapter {
     unbindExtensionUi(): Promise<void>;
     workflowAutocompleteCommands(): readonly PiWorkflowAutocompleteCommand[];
     cycleModelWorkflow(direction: "forward" | "backward"): Promise<PiWorkflowResult>;
+    /**
+     * The theme the engine is configured with, in the engine's own grammar: a
+     * theme's name, or a `light/dark` pair meaning "follow the terminal".
+     */
+    configuredTheme(): string | undefined;
     /** Settings port for the live runtime, or null before the runtime is available. */
     settingsPort(): AgentSettingsPort | null;
     pinnedModelSelectorContext(): {

package/dist/src/foundation/pi-engine-adapter/adapter.js

@@ -380,6 +380,13 @@ export class PiEngineAdapter {
             return workflowResult("model", "failed", error instanceof Error ? error.message : String(error));
         }
     }
+    /**
+     * The theme the engine is configured with, in the engine's own grammar: a
+     * theme's name, or a `light/dark` pair meaning "follow the terminal".
+     */
+    configuredTheme() {
+        return this.#runtime?.services.settingsManager.getThemeSetting();
+    }
     /** Settings port for the live runtime, or null before the runtime is available. */
     settingsPort() {
         const settings = this.#runtime?.services.settingsManager;

package/dist/src/foundation/pi-engine-adapter/settings-integration.d.ts

@@ -17,8 +17,6 @@ export interface PiSettingsProviders {
  * entry per terminal appearance.
  */
 export declare const AUTOMATIC_THEME = "automatic";
-export declare const LIGHT_THEME_KEY = "themeLight";
-export declare const DARK_THEME_KEY = "themeDark";
 interface AutomaticTheme {
     readonly light: string;
     readonly dark: string;

package/dist/src/foundation/pi-engine-adapter/settings-integration.js

@@ -7,8 +7,9 @@ import piSettingsMetadata from "./pi-settings-metadata.json" with { type: "json"
  * entry per terminal appearance.
  */
 export const AUTOMATIC_THEME = "automatic";
-export const LIGHT_THEME_KEY = "themeLight";
-export const DARK_THEME_KEY = "themeDark";
+/** The themes an automatic setting names for each terminal appearance. */
+const LIGHT_APPEARANCE_THEME = "light";
+const DARK_APPEARANCE_THEME = "dark";
 const THEME_KEY = "theme";
 const THINKING_KEY = "thinkingLevel";
 /** A stored theme is automatic when it names one theme per terminal appearance. */
@@ -47,10 +48,6 @@ export function settingsInventoryDrift(presented, mapped) {
     };
 }
 /** What the engine offers for a setting, as the strings it words them with. */
-/** One appearance of an automatic theme, offered as an ordinary setting. */
-function appearance(key, label, description, themes) {
-    return { key, valueType: "enum", writable: true, choices: themes, label, description, resolvedWhenRead: true };
-}
 function offered(key) {
     return PRESENTATION.settings[key]?.values ?? [];
 }
@@ -95,15 +92,9 @@ export class PiSettingsIntegration {
         })
             .map(descriptor => this.#resolved(descriptor))
             .sort((left, right) => rank(left.key) - rank(right.key));
-        const pair = parseAutomaticTheme(this.#storedTheme());
-        if (pair === null)
-            return listed;
-        const themes = this.#themes();
-        return [
-            ...listed,
-            appearance(LIGHT_THEME_KEY, "Light theme", "Theme to use in automatic mode when the terminal is light", themes),
-            appearance(DARK_THEME_KEY, "Dark theme", "Theme to use in automatic mode when the terminal is dark", themes),
-        ];
+        // Following the terminal is one choice on the theme itself, not two further
+        // settings: the pair behind it is the engine's grammar, not a reader's task.
+        return listed;
     }
     /** Overlays the values a setting can only offer once something is running. */
     #resolved(descriptor) {
@@ -129,20 +120,16 @@ export class PiSettingsIntegration {
         return typeof stored === "string" ? stored : "";
     }
     async readSetting(key) {
-        if (key === THEME_KEY || key === LIGHT_THEME_KEY || key === DARK_THEME_KEY) {
+        if (key === THEME_KEY) {
             const pair = parseAutomaticTheme(this.#storedTheme());
-            if (key === THEME_KEY)
-                return pair === null ? this.#operations.get(key)?.read() : AUTOMATIC_THEME;
-            if (pair === null)
-                return undefined;
-            return key === LIGHT_THEME_KEY ? pair.light : pair.dark;
+            return pair === null ? this.#operations.get(key)?.read() : AUTOMATIC_THEME;
         }
         return this.#operations.get(key)?.read();
     }
     async writeSetting(key, value) { this.writeSettingNow(key, value); }
     writeSettingNow(key, value) {
-        if (typeof value === "string" && (key === THEME_KEY || key === LIGHT_THEME_KEY || key === DARK_THEME_KEY)) {
-            this.#writeTheme(key, value);
+        if (typeof value === "string" && key === THEME_KEY) {
+            this.#writeTheme(value);
             return;
         }
         const operation = this.#operations.get(key);
@@ -151,26 +138,26 @@ export class PiSettingsIntegration {
         operation.write(value);
     }
     /**
-     * Composes the stored theme from the part that changed. Turning automatic on
-     * starts from the theme already in use for both appearances, which is where
-     * the engine's own editor starts too.
+     * Writes the theme in the engine's own grammar. Following the terminal is
+     * stored as the pair the engine reads for it, made of the themes named for
+     * each appearance when they are installed; where they are not, the theme
+     * already in use stands for both, so the setting still round-trips.
      */
-    #writeTheme(key, value) {
+    #writeTheme(value) {
         const theme = this.#operations.get(THEME_KEY);
         if (!theme)
-            throw new Error(`setting is unavailable: ${key}`);
-        const current = this.#storedTheme();
-        const pair = parseAutomaticTheme(current);
-        if (key === THEME_KEY) {
-            if (value !== AUTOMATIC_THEME)
-                theme.write(value);
-            else if (pair === null)
-                theme.write(`${current}/${current}`);
+            throw new Error(`setting is unavailable: ${THEME_KEY}`);
+        if (value !== AUTOMATIC_THEME) {
+            theme.write(value);
             return;
         }
-        if (pair === null)
+        if (parseAutomaticTheme(this.#storedTheme()) !== null)
             return;
-        theme.write(key === LIGHT_THEME_KEY ? `${value}/${pair.dark}` : `${pair.light}/${value}`);
+        const installed = this.#themes();
+        const current = this.#storedTheme();
+        const light = installed.includes(LIGHT_APPEARANCE_THEME) ? LIGHT_APPEARANCE_THEME : current;
+        const dark = installed.includes(DARK_APPEARANCE_THEME) ? DARK_APPEARANCE_THEME : current;
+        theme.write(`${light}/${dark}`);
     }
     async flush() { await this.settings.flush(); }
 }

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

@@ -138,7 +138,7 @@ export async function certifyMaterializedRelease(release, dataDir, verification
     return path;
 }
 export async function startSupervisor(release, environment) {
-    const entry = await resolveReleaseEntryPoint(release, "bin/a1-supervisor.js");
+    const entry = await resolveReleaseEntryPoint(release, "bin/supervisor.js");
     const child = spawn(process.execPath, [entry], {
         detached: true,
         env: releaseEnvironment(environment, release),
@@ -152,7 +152,7 @@ export async function startSupervisor(release, environment) {
     child.unref();
 }
 async function launchUi(release, environment) {
-    const entry = await resolveReleaseEntryPoint(release, "bin/a1-guardian.js");
+    const entry = await resolveReleaseEntryPoint(release, "bin/guardian.js");
     return await new Promise((resolvePromise, rejectPromise) => {
         const child = spawn(process.execPath, [entry], {
             env: releaseEnvironment(environment, release),

package/dist/src/foundation/ui-components/list-view.js

@@ -23,21 +23,21 @@ export function renderGroupHeader(title, width, theme) {
 export function renderListRow(row, state, valueColumn, width, theme) {
     const cursor = state.selected ? "→ " : "  ";
     const leftRaw = `${cursor}  ${row.label}`;
-    const left = `${theme.fg("accent", cursor)}  ${theme.fg(state.selected ? "accent" : "text", row.label)}`;
+    const left = `${theme.fg("accent", cursor)}  ${state.selected ? theme.fg("accent", row.label) : theme.plain(row.label)}`;
     const gap = Math.max(2, valueColumn - displayWidth(leftRaw));
     // Pointing anywhere on the row is pointing at the item; pointing at the value
     // is what brightens it. The selection speaks through the label alone.
     const valueHovered = state.hovered && state.region !== "label";
     const stepper = row.stepper !== undefined && valueHovered;
-    const value = theme.fg(valueHovered ? "text" : "muted", row.value);
+    const value = valueHovered ? theme.plain(row.value) : theme.fg("muted", row.value);
     const minus = stepper
         ? row.stepper?.lower === true
-            ? theme.fg(state.region === "minus" ? "text" : "dim", "- ")
+            ? state.region === "minus" ? theme.plain("- ") : theme.fg("dim", "- ")
             : theme.disabled("- ")
         : "";
     const plus = stepper
         ? row.stepper?.raise === true
-            ? theme.fg(state.region === "plus" ? "text" : "dim", " +")
+            ? state.region === "plus" ? theme.plain(" +") : theme.fg("dim", " +")
             : theme.disabled(" +")
         : "";
     const indent = Math.max(2, stepper ? gap - STEPPER_RESERVE : gap);

package/dist/src/foundation/ui-components/theme.d.ts

@@ -6,6 +6,12 @@ export type UiThemeToken = "accent" | "text" | "muted" | "dim" | "border" | "err
 export interface UiTheme {
     fg(token: UiThemeToken, text: string): string;
     bold(text: string): string;
+    /**
+     * The terminal's own foreground, left unpainted. What a list's own text is:
+     * a theme built for a light background would otherwise write near-black rows
+     * into a dark terminal, which is how the engine leaves its lists too.
+     */
+    plain(text: string): string;
     /** Inverted styling for the active row of a floating surface. */
     highlight(text: string): string;
     /** A control that is present but cannot act: quieter than quiet text. */

package/dist/src/foundation/ui-components/theme.js

@@ -6,6 +6,7 @@
 export const PLAIN_THEME = Object.freeze({
     fg: (_token, text) => text,
     bold: (text) => text,
+    plain: (text) => text,
     highlight: (text) => text,
     disabled: (text) => text,
     panel: (text) => text,

package/dist/src/product-identity.json

@@ -86,13 +86,13 @@
         "piEventFrameParitySchema": "a1-pi-event-frame-parity-v1"
     },
     "artifacts": {
-        "cliEntry": "bin/a1.js",
-        "supervisorEntry": "bin/a1-supervisor.js",
-        "guardianEntry": "bin/a1-guardian.js",
-        "uiEntry": "bin/a1-ui.js",
-        "nativeExecutable": "a1-terminal-host",
-        "nativeCrate": "a1-terminal-host",
-        "processGuardianExecutable": "a1-process-guardian",
+        "cliEntry": "bin/cli.js",
+        "supervisorEntry": "bin/supervisor.js",
+        "guardianEntry": "bin/guardian.js",
+        "uiEntry": "bin/ui.js",
+        "nativeExecutable": "terminal-host",
+        "nativeCrate": "terminal-host",
+        "processGuardianExecutable": "process-guardian",
         "releaseTarballStem": "timurproko-a1",
         "diagnosticStem": "a1"
     }

package/docs/architecture/process-guardian-provenance.md

@@ -1,6 +1,6 @@
 # Process guardian provenance
 
-A1 launch-instance containment uses a standalone native executable named `a1-process-guardian`. The approved implementation is a separate Rust crate at `native/process-guardian`; it is not a Node-API addon and does not reuse or resume the held composed terminal-host implementation.
+A1 launch-instance containment uses a standalone native executable named `process-guardian`. The approved implementation is a separate Rust crate at `native/process-guardian`; it is not a Node-API addon and does not reuse or resume the held composed terminal-host implementation.
 
 ## Boundary
 
@@ -13,10 +13,10 @@ On Windows it uses `windows-sys 0.61.2` to create a Job Object, enables `JOB_OBJ
 Release builds place the exact executable at:
 
 ```text
-dist/native/win32-x64/a1-process-guardian.exe
-dist/native/linux-x64/a1-process-guardian
-dist/native/darwin-x64/a1-process-guardian
-dist/native/darwin-arm64/a1-process-guardian
+dist/native/win32-x64/process-guardian.exe
+dist/native/linux-x64/process-guardian
+dist/native/darwin-x64/process-guardian
+dist/native/darwin-arm64/process-guardian
 ```
 
 Each supported artifact must be named in the release integrity manifest with target triple, crate version, guardian protocol version, SHA-256, byte size, build provenance, and signature/attestation status. A missing, altered, incompatible, or wrong-platform artifact is a concise unsupported-containment launch error; A1 never silently falls back to PID-only cleanup.

package/docs/architecture/toolchain.md

@@ -65,9 +65,9 @@ This mandatory candidate workflow checks documented package-root exports and the
 npm run sync:pi-ui
 ```
 
-This optional, mutating presentation-maintenance workflow regenerates component and event-frame parity evidence when maintainers deliberately adopt upstream UI changes. Review generated diffs, attribution, source-ledger records, and terminal parity before committing them. It is never an engine candidate acceptance gate and is not run by `check`, `prepack`, or release publication.
+This optional, mutating presentation-maintenance workflow regenerates component and event-frame parity evidence when maintainers deliberately adopt upstream UI changes. Review generated diffs, attribution, and source-ledger records before committing them. It is never an engine candidate acceptance gate and is not run by `check`, `prepack`, or release publication.
 
-`npm run test:pi-terminal-parity` remains an explicit presentation acceptance command. `node scripts/check-pinned-pi-source-ledger.mjs` validates accepted provenance; its `--engine-only` mode validates the ownership partition without comparing private upstream source.
+Presentation acceptance is the reader comparing `a1 pi` with pinned Pi. `node scripts/check-pinned-pi-source-ledger.mjs` validates accepted provenance; its `--engine-only` mode validates the ownership partition without comparing private upstream source.
 
 ## Preview publication
 

package/docs/manual-terminal-colour-check.md

@@ -0,0 +1,55 @@
+# Terminal colour check
+
+## What can go wrong
+
+Every colour the interface draws is 24-bit: the pinned dark theme's accent is
+`#8abeb7`, its border `#5f87ff`, its headings `#f0c674`. On Windows, Node decides
+once at startup whether it may send those sequences to the terminal at all. It
+asks the console to enable virtual terminal processing; when that fails it renders
+ANSI itself, and its renderer knows only the sixteen SGR colours. Each 24-bit
+colour is then replaced by the terminal's nearest palette entry, so the whole
+interface shifts at once — accent to the terminal's cyan, headings to its yellow —
+while the application still writes exactly the bytes it always wrote.
+
+That decision is made per process, from the console handle the process was given,
+and every process it launches inherits the result. It is a property of how the
+session was started, not of what is drawn.
+
+## Launching so colour survives
+
+The installed command is an npm shim — a shell script that `exec`s Node — and that
+shape keeps 24-bit colour. So does `pi`, for the same reason.
+
+- Installed: `a1`, `a1 pi`
+- From a checkout: `scripts/dev` and `scripts/dev pi`
+
+`npm start` and `npm run start:pi` build first and then launch through the same
+entry, but a package manager on Windows hands the script to `cmd.exe`, which can
+leave the launch without a terminal on its input; the launcher says so and stops
+rather than opening a session that closes as it starts. Running `scripts/dev`
+from the shell is the direct path.
+
+A directly launched `node scripts/start-local.mjs` under Git Bash does not, and
+neither does a directly launched `node …/pi/dist/cli.js`: the collapse belongs to
+the launch, not to either application.
+
+## Checking a terminal
+
+```
+node scripts/check-terminal-colour.mjs
+```
+
+It prints the same colour as 24-bit, as a 256-colour index, and as the terminal's
+own palette entry. When the first block is indistinguishable from the third, this
+launch collapses colour and any comparison made in it is a comparison of two wrong
+screens.
+
+## What the gates hold
+
+- `test/features/launch/terminal-colour-fidelity.test.ts` holds the emitted bytes:
+  the pinned palette resolves to 24-bit sequences, a 256-colour terminal stays on
+  indices, and the launch chain keeps inheriting the terminal it was started from
+  rather than opening a console of its own.
+- The reader compares `a1 pi` with pinned Pi in the same terminal. Run the colour
+  check first: a launch that collapses colour makes both sessions equally wrong, so
+  they would agree with each other and disagree with what a user sees.

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.1-dev.7",
+  "version": "0.1.1-dev.8",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",
   "bin": {
-    "a1": "bin/a1.js"
+    "a1": "bin/cli.js"
   },
   "files": [
     "bin",
@@ -34,19 +34,19 @@
     "test:full": "node scripts/run-validation-tier.mjs full-release",
     "test:release": "node scripts/run-release-gates.mjs",
     "test:terminal-host": "node scripts/run-terminal-host-probe.mjs",
-    "test:pi-terminal-parity": "npm run build --silent && node scripts/run-pi-terminal-parity.mjs",
     "test:pi-engine-conformance": "vitest run test/foundation/pi-engine-adapter/conformance.test.ts test/foundation/pi-engine-adapter/runtime-integration.test.ts test/foundation/pi-engine-adapter/session-integration.test.ts",
     "report:pi-engine-conformance": "npm run build --silent && node scripts/run-pi-engine-conformance.mjs",
     "sync:pi-ui": "npm run update:pi-component-parity && npm run update:pi-event-frame-parity && npm run update:pi-settings-metadata",
     "update:pi-component-parity": "tsx scripts/update-pi-component-parity.ts",
     "update:pi-event-frame-parity": "tsx scripts/update-pi-event-frame-parity.ts",
     "proof:terminal-host": "node scripts/run-terminal-host.mjs",
-    "start": "npm run build && node scripts/start-local.mjs",
+    "start": "npm run build && node scripts/dev-launch.mjs",
+    "start:pi": "npm run build && node scripts/dev-launch.mjs pi",
+    "start:sandbox": "npm run build && node scripts/dev-launch.mjs sandbox",
     "prepack": "node scripts/prepack-gate.mjs",
     "prepublishOnly": "npm run test:release",
     "prepare": "npm run build",
-    "update:pi-settings-metadata": "node scripts/update-pi-settings-metadata.mjs",
-    "clean:worktrees": "node scripts/clean-worktrees.mjs"
+    "update:pi-settings-metadata": "node scripts/update-pi-settings-metadata.mjs"
   },
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.84.2",

package/dist/src/composition/transparent-runtime.d.ts

@@ -1,6 +0,0 @@
-import type { LaunchProfileId } from "../foundation/lifecycle/index.js";
-export declare function selectTransparentChild(environment?: NodeJS.ProcessEnv, executable?: string, compositionUrl?: string): {
-    readonly executable: string;
-    readonly arguments: readonly string[];
-};
-export declare function runSelectedTransparentRuntime(profileId: Exclude<LaunchProfileId, "a1">, environment?: NodeJS.ProcessEnv): Promise<number>;

package/dist/src/composition/transparent-runtime.js

@@ -1,19 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { runTransparentForeground } from "../foundation/transparent-terminal/index.js";
-export function selectTransparentChild(environment = process.env, executable = process.execPath, compositionUrl = import.meta.url) {
-    const entry = fileURLToPath(new URL("../foundation/pi-engine-adapter/public-main-entry.js", compositionUrl));
-    return { executable, arguments: [entry, ...parseSelectedArguments(environment.A1_LAUNCH_ARGUMENTS_JSON)] };
-}
-export async function runSelectedTransparentRuntime(profileId, environment = process.env) {
-    const child = selectTransparentChild(environment);
-    return await runTransparentForeground({ profileId, environment, ...child });
-}
-function parseSelectedArguments(source) {
-    if (!source)
-        return [];
-    const value = JSON.parse(source);
-    if (!Array.isArray(value) || value.some(item => typeof item !== "string")) {
-        throw new TypeError("A1_LAUNCH_ARGUMENTS_JSON must be a JSON array of strings");
-    }
-    return value;
-}

package/dist/src/foundation/transparent-terminal/command-resolution.d.ts

@@ -1,13 +0,0 @@
-export interface ResolvedTransparentCommand {
-    readonly executable: string;
-    readonly arguments: readonly string[];
-    readonly source: "exact" | "path" | "npm-windows-shim";
-}
-export interface TransparentCommandResolutionOptions {
-    readonly platform?: NodeJS.Platform;
-    readonly cwd: string;
-    readonly environment: Readonly<Record<string, string>>;
-    readonly nodeExecutable?: string;
-}
-/** Resolve a command without invoking a command interpreter. */
-export declare function resolveTransparentCommand(executable: string, arguments_: readonly string[], options: TransparentCommandResolutionOptions): Promise<ResolvedTransparentCommand>;

package/dist/src/foundation/transparent-terminal/command-resolution.js

@@ -1,72 +0,0 @@
-import { access, readFile } from "node:fs/promises";
-import { extname, isAbsolute, resolve } from "node:path";
-/** Resolve a command without invoking a command interpreter. */
-export async function resolveTransparentCommand(executable, arguments_, options) {
-    const platform = options.platform ?? process.platform;
-    return platform === "win32"
-        ? await resolveWindowsCommand(executable, arguments_, options)
-        : { executable, arguments: [...arguments_], source: "exact" };
-}
-async function resolveWindowsCommand(command, commandArguments, options) {
-    const resolved = await resolveWindowsPathCommand(command, options.cwd, options.environment);
-    const selected = resolved ?? throwCommandNotFound(command);
-    if (extname(selected).toLowerCase() !== ".cmd") {
-        return { executable: selected, arguments: [...commandArguments], source: "path" };
-    }
-    return await unwrapNpmWindowsShim(selected, commandArguments, options.nodeExecutable ?? process.execPath);
-}
-async function resolveWindowsPathCommand(executable, cwd, environment) {
-    const hasPath = isAbsolute(executable) || executable.includes("/") || executable.includes("\\");
-    const roots = hasPath ? [cwd] : windowsPath(environment).split(";").filter(Boolean);
-    const extension = extname(executable);
-    const extensions = extension ? [""] : windowsExecutableExtensions(environment);
-    for (const root of roots) {
-        const base = hasPath ? resolve(cwd, executable) : resolve(root.replace(/^"|"$/g, ""), executable);
-        for (const suffix of extensions) {
-            const candidate = `${base}${suffix}`;
-            if (await isFile(candidate))
-                return candidate;
-        }
-    }
-    return null;
-}
-async function unwrapNpmWindowsShim(shimPath, arguments_, fallbackNodeExecutable) {
-    const source = (await readFile(shimPath, "utf8")).replace(/^\uFEFF/, "");
-    const targetMatch = source.match(/"%_prog%"\s+"%dp0%\\([^"\r\n]+)"\s+%\*/i);
-    if (!targetMatch?.[1]) {
-        throw Object.assign(new Error(`transparent launch refuses arbitrary Windows command script ${shimPath}; configure an executable binary instead`), { code: "UNSUPPORTED_WINDOWS_COMMAND_SHIM" });
-    }
-    const shimRoot = resolve(shimPath, "..");
-    const target = resolve(shimRoot, targetMatch[1].replaceAll("\\", "/"));
-    if (!await isFile(target))
-        throw Object.assign(new Error(`npm command shim target is missing: ${target}`), { code: "ENOENT" });
-    const localNode = resolve(shimRoot, "node.exe");
-    const nodeExecutable = await isFile(localNode) ? localNode : fallbackNodeExecutable;
-    return {
-        executable: nodeExecutable,
-        arguments: [target, ...arguments_],
-        source: "npm-windows-shim",
-    };
-}
-function throwCommandNotFound(command) {
-    throw Object.assign(new Error(`spawn ${command} ENOENT`), { code: "ENOENT" });
-}
-function windowsPath(environment) {
-    return environment.Path ?? environment.PATH ?? "";
-}
-function windowsExecutableExtensions(environment) {
-    const source = environment.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
-    return [...new Set(source.split(";").filter(Boolean).flatMap(value => {
-            const extension = value.startsWith(".") ? value : `.${value}`;
-            return [extension, extension.toLowerCase()];
-        }))];
-}
-async function isFile(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/src/foundation/transparent-terminal/foreground-broker.d.ts

@@ -1,24 +0,0 @@
-import type { NativeProcessIdentity, TransparentTerminalLaunchProfile, TransparentTerminalLifecycleOutcome } from "../lifecycle/index.js";
-export type TransparentStopReason = "owner-disconnect" | "user-request" | "update";
-export interface TransparentChildHandle {
-    readonly processIdentity: NativeProcessIdentity;
-    readonly outcome: Promise<TransparentTerminalLifecycleOutcome>;
-    stop(reason: TransparentStopReason): Promise<TransparentTerminalLifecycleOutcome>;
-}
-export interface TransparentNativeLauncher {
-    launch(profile: TransparentTerminalLaunchProfile): Promise<TransparentChildHandle>;
-}
-export interface ForegroundBrokerRequest {
-    readonly profile: TransparentTerminalLaunchProfile;
-    readonly stopRequested?: Promise<TransparentStopReason>;
-}
-export interface ForegroundBrokerResult {
-    readonly processIdentity: NativeProcessIdentity | null;
-    readonly outcome: TransparentTerminalLifecycleOutcome;
-}
-/**
- * Waits for one directly attached child. Launch-instance registration and
- * process-tree containment belong to the outer profile-neutral guardian.
- * Ordinary terminal data never enters this object.
- */
-export declare function runForegroundBroker(request: ForegroundBrokerRequest, launcher: TransparentNativeLauncher): Promise<ForegroundBrokerResult>;

package/dist/src/foundation/transparent-terminal/foreground-broker.js

@@ -1,30 +0,0 @@
-import { assertNativeProcessIdentity, assertTransparentTerminalLaunchProfile } from "../lifecycle/index.js";
-/**
- * Waits for one directly attached child. Launch-instance registration and
- * process-tree containment belong to the outer profile-neutral guardian.
- * Ordinary terminal data never enters this object.
- */
-export async function runForegroundBroker(request, launcher) {
-    assertTransparentTerminalLaunchProfile(request.profile);
-    let handle;
-    try {
-        handle = await launcher.launch(request.profile);
-        assertNativeProcessIdentity(handle.processIdentity);
-    }
-    catch (error) {
-        return {
-            processIdentity: null,
-            outcome: { kind: "spawn-error", message: errorMessage(error), code: errorCode(error) },
-        };
-    }
-    const outcome = request.stopRequested
-        ? await Promise.race([handle.outcome, request.stopRequested.then(async (reason) => await handle.stop(reason))])
-        : await handle.outcome;
-    return { processIdentity: handle.processIdentity, outcome };
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function errorCode(error) {
-    return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : null;
-}

package/dist/src/foundation/transparent-terminal/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./command-resolution.js";
-export * from "./foreground-broker.js";
-export * from "./main.js";
-export * from "./native-launcher.js";

package/dist/src/foundation/transparent-terminal/index.js

@@ -1,4 +0,0 @@
-export * from "./command-resolution.js";
-export * from "./foreground-broker.js";
-export * from "./main.js";
-export * from "./native-launcher.js";

package/dist/src/foundation/transparent-terminal/main.d.ts

@@ -1,9 +0,0 @@
-import { type LaunchProfileId } from "../lifecycle/index.js";
-export interface TransparentForegroundOptions {
-    readonly environment?: NodeJS.ProcessEnv;
-    readonly profileId?: LaunchProfileId;
-    readonly cwd?: string;
-    readonly executable: string;
-    readonly arguments: readonly string[];
-}
-export declare function runTransparentForeground(options: TransparentForegroundOptions): Promise<number>;

package/dist/src/foundation/transparent-terminal/main.js

@@ -1,87 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { realpath } from "node:fs/promises";
-import { resolve } from "node:path";
-import { assertLaunchProfileId } from "../lifecycle/index.js";
-import { runForegroundBroker } from "./foreground-broker.js";
-import { createPlatformTransparentLauncher } from "./native-launcher.js";
-export async function runTransparentForeground(options) {
-    const environment = { ...(options.environment ?? process.env) };
-    const profileId = options.profileId ?? environment.A1_LAUNCH_PROFILE ?? "a1";
-    assertLaunchProfileId(profileId);
-    const profile = await launchProfile(environment, options, profileId);
-    const stop = stopSignal();
-    try {
-        const result = await runForegroundBroker({ profile, stopRequested: stop.requested }, createPlatformTransparentLauncher());
-        if (result.outcome.kind === "exited")
-            return result.outcome.exitCode;
-        if (result.outcome.kind === "signaled")
-            return 1;
-        if (result.outcome.kind === "stopped" || result.outcome.kind === "detached")
-            return 0;
-        throw Object.assign(new Error(result.outcome.message), { code: result.outcome.code ?? undefined });
-    }
-    finally {
-        stop.dispose();
-    }
-}
-async function launchProfile(environment, options, profileId) {
-    const executable = options.executable;
-    const arguments_ = options.arguments;
-    const cwd = await realpath(options.cwd ?? process.cwd());
-    const terminalType = environment.TERM?.trim() || "xterm-256color";
-    return {
-        id: `${profileId}-transparent-${randomUUID()}`,
-        terminalCapability: "transparent",
-        executable,
-        arguments: arguments_,
-        cwd,
-        environment: selectedChildEnvironment(environment),
-        terminalType,
-        dimensions: terminalDimensions(environment),
-        ownerDisconnect: "stop",
-        recovery: "none",
-        surface: "none",
-        visualReconnection: "none",
-    };
-}
-function selectedChildEnvironment(environment) {
-    const selected = {};
-    for (const [name, value] of Object.entries(environment)) {
-        if (value !== undefined && !name.startsWith("A1_"))
-            selected[name] = value;
-    }
-    return selected;
-}
-function terminalDimensions(environment) {
-    const columns = positiveInteger(environment.COLUMNS) ?? 80;
-    const rows = positiveInteger(environment.LINES) ?? 24;
-    return { columns: Math.min(500, Math.max(2, columns)), rows: Math.min(300, Math.max(1, rows)) };
-}
-function positiveInteger(value) {
-    const parsed = Number(value);
-    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
-}
-function stopSignal() {
-    let resolveStop;
-    let settled = false;
-    const requested = new Promise(resolve => { resolveStop = resolve; });
-    const request = (reason) => {
-        if (settled)
-            return;
-        settled = true;
-        resolveStop(reason);
-    };
-    const onSigterm = () => request("user-request");
-    // The attached child shares foreground signal delivery. Keep the broker alive
-    // without translating or forwarding Ctrl+C.
-    const onSigint = () => undefined;
-    process.once("SIGTERM", onSigterm);
-    process.on("SIGINT", onSigint);
-    return {
-        requested,
-        dispose() {
-            process.off("SIGTERM", onSigterm);
-            process.off("SIGINT", onSigint);
-        },
-    };
-}

package/dist/src/foundation/transparent-terminal/native-launcher.d.ts

@@ -1,25 +0,0 @@
-import { type ChildProcess, type SpawnOptions } from "node:child_process";
-import type { TransparentTerminalLaunchProfile } from "../lifecycle/index.js";
-import type { TransparentChildHandle, TransparentNativeLauncher } from "./foreground-broker.js";
-export interface NativeSpawnAdapter {
-    resolveCommand(profile: TransparentTerminalLaunchProfile): Promise<{
-        readonly executable: string;
-        readonly arguments: readonly string[];
-    }>;
-    spawn(executable: string, arguments_: readonly string[], options: SpawnOptions): ChildProcess;
-    observeStartIdentity(child: ChildProcess): Promise<string>;
-    identityMatches(child: ChildProcess, expectedStartIdentity: string): Promise<boolean>;
-    stop(child: ChildProcess, force: boolean): Promise<void>;
-    waitForExit(child: ChildProcess, timeoutMs: number): Promise<boolean>;
-}
-export declare function createPlatformTransparentLauncher(platform?: NodeJS.Platform, adapter?: NativeSpawnAdapter): TransparentNativeLauncher;
-export declare class WindowsTransparentLauncher implements TransparentNativeLauncher {
-    private readonly adapter;
-    constructor(adapter?: NativeSpawnAdapter);
-    launch(profile: TransparentTerminalLaunchProfile): Promise<TransparentChildHandle>;
-}
-export declare class UnixTransparentLauncher implements TransparentNativeLauncher {
-    private readonly adapter;
-    constructor(adapter?: NativeSpawnAdapter);
-    launch(profile: TransparentTerminalLaunchProfile): Promise<TransparentChildHandle>;
-}

package/dist/src/foundation/transparent-terminal/native-launcher.js

@@ -1,146 +0,0 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { resolveTransparentCommand } from "./command-resolution.js";
-export function createPlatformTransparentLauncher(platform = process.platform, adapter = defaultSpawnAdapter) {
-    if (platform === "win32")
-        return new WindowsTransparentLauncher(adapter);
-    if (platform === "linux" || platform === "darwin")
-        return new UnixTransparentLauncher(adapter);
-    throw new Error(`transparent terminal attachment is unsupported on ${platform}`);
-}
-export class WindowsTransparentLauncher {
-    adapter;
-    constructor(adapter = defaultSpawnAdapter) {
-        this.adapter = adapter;
-    }
-    async launch(profile) {
-        return await launchInherited(profile, this.adapter, {
-            windowsHide: true,
-            windowsVerbatimArguments: false,
-            detached: false,
-        });
-    }
-}
-export class UnixTransparentLauncher {
-    adapter;
-    constructor(adapter = defaultSpawnAdapter) {
-        this.adapter = adapter;
-    }
-    async launch(profile) {
-        // Staying in the foreground process group preserves the inherited controlling
-        // terminal without an intermediary or synthetic terminal restoration.
-        return await launchInherited(profile, this.adapter, {
-            detached: false,
-        });
-    }
-}
-async function launchInherited(profile, adapter, platformOptions) {
-    const command = await adapter.resolveCommand(profile);
-    const child = adapter.spawn(command.executable, command.arguments, {
-        ...platformOptions,
-        cwd: profile.cwd,
-        env: { ...profile.environment, TERM: profile.terminalType },
-        shell: false,
-        stdio: "inherit",
-    });
-    await spawned(child);
-    if (!child.pid)
-        throw Object.assign(new Error("transparent child has no process identity"), { code: "NO_PROCESS_ID" });
-    const outcome = childOutcome(child);
-    const startIdentity = await adapter.observeStartIdentity(child);
-    const processIdentity = { pid: child.pid, startIdentity };
-    let stopOutcome = null;
-    return {
-        processIdentity,
-        outcome,
-        stop(reason) {
-            stopOutcome ??= stopOwnedChild(child, adapter, processIdentity.startIdentity, reason);
-            return stopOutcome;
-        },
-    };
-}
-function spawned(child) {
-    return new Promise((resolve, reject) => {
-        if (child.pid) {
-            resolve();
-            return;
-        }
-        child.once("spawn", resolve);
-        child.once("error", reject);
-    });
-}
-function childOutcome(child) {
-    return new Promise(resolve => {
-        child.once("error", error => resolve({ kind: "broker-error", message: error.message, code: errorCode(error) }));
-        child.once("close", (exitCode, signal) => {
-            if (signal)
-                resolve({ kind: "signaled", signal });
-            else
-                resolve({ kind: "exited", exitCode: exitCode ?? 1 });
-        });
-    });
-}
-async function stopOwnedChild(child, adapter, expectedStartIdentity, reason) {
-    if (!await adapter.identityMatches(child, expectedStartIdentity)) {
-        return { kind: "broker-error", message: "refusing cleanup because transparent child ownership changed", code: "PROCESS_IDENTITY_MISMATCH" };
-    }
-    await adapter.stop(child, false);
-    if (!await adapter.waitForExit(child, 1_500)) {
-        if (!await adapter.identityMatches(child, expectedStartIdentity)) {
-            return { kind: "broker-error", message: "refusing forced cleanup because transparent child ownership changed", code: "PROCESS_IDENTITY_MISMATCH" };
-        }
-        await adapter.stop(child, true);
-        if (!await adapter.waitForExit(child, 1_500)) {
-            return { kind: "broker-error", message: "transparent child did not exit within the bounded cleanup deadline", code: "CLEANUP_TIMEOUT" };
-        }
-    }
-    return { kind: "stopped", reason };
-}
-function errorCode(error) {
-    return "code" in error && typeof error.code === "string" ? error.code : null;
-}
-const observedStartIdentities = new WeakMap();
-const defaultSpawnAdapter = {
-    async resolveCommand(profile) {
-        return await resolveTransparentCommand(profile.executable, profile.arguments, {
-            cwd: profile.cwd,
-            environment: profile.environment,
-        });
-    },
-    spawn(executable, arguments_, options) {
-        return spawn(executable, [...arguments_], options);
-    },
-    async observeStartIdentity(child) {
-        if (!child.pid)
-            throw new Error("transparent child has no PID");
-        const identity = `${child.pid}:${randomUUID()}`;
-        observedStartIdentities.set(child, identity);
-        return identity;
-    },
-    async identityMatches(child, expectedStartIdentity) {
-        return child.pid !== undefined
-            && child.exitCode === null
-            && child.signalCode === null
-            && observedStartIdentities.get(child) === expectedStartIdentity;
-    },
-    async stop(child, force) {
-        if (child.exitCode !== null || child.signalCode !== null)
-            return;
-        child.kill(force ? "SIGKILL" : "SIGTERM");
-    },
-    async waitForExit(child, timeoutMs) {
-        if (child.exitCode !== null || child.signalCode !== null)
-            return true;
-        return await new Promise(resolve => {
-            const timer = setTimeout(() => finish(false), timeoutMs);
-            timer.unref();
-            const finish = (exited) => {
-                clearTimeout(timer);
-                child.off("close", onClose);
-                resolve(exited);
-            };
-            const onClose = () => finish(true);
-            child.once("close", onClose);
-        });
-    },
-};