@timurproko/a1 0.1.0 → 0.1.1-dev.1

package/README.md

@@ -1,6 +1,6 @@
-# AddOne
+# A1
 
-AddOne is a terminal-native agent launcher for Windows, Linux, and macOS. Bare `a1` runs the AddOne-owned Pi-compatible UI, while explicit fallback profiles can launch untouched Pi directly. AddOne also manages release selection, process ownership, and updates.
+A1 is a terminal-native agent launcher for Windows, Linux, and macOS. Bare `a1` runs the A1-owned Pi-compatible UI, while explicit fallback profiles can launch untouched Pi directly. A1 also manages release selection, process ownership, and updates.
 
 ## Install
 
@@ -18,7 +18,7 @@ The package installs only the `a1` command.
 ## Commands
 
 ```sh
-a1              # AddOne-owned UI and profile: ~/.a1/agent
+a1              # A1-owned UI and profile: ~/.a1/agent
 a1 pi           # untouched vanilla Pi oracle: ~/.pi/agent
 a1 sandbox      # unchanged isolated vanilla Pi profile: ~/.a1/sandbox
 a1 version      # show Installed, Release (latest), and Next versions
@@ -26,9 +26,9 @@ a1 update       # update to npm latest
 a1 update:next  # update to npm next
 ```
 
-Bare `a1` owns its Pi-compatible TUI composition and uses the public Pi engine, components, and terminal APIs. It does not insert a PTY or terminal-byte relay. Default visuals and workflows track the pinned vanilla Pi baseline; AddOne-specific visual customization and structured tabs remain disabled.
+Bare `a1` owns its Pi-compatible TUI composition and uses the public Pi engine, components, and terminal APIs. It does not insert a PTY or terminal-byte relay. Default visuals and workflows track the pinned vanilla Pi baseline; A1-specific visual customization and structured tabs remain disabled.
 
-`a1 pi` is the untouched upstream fallback and comparison oracle. Use it to distinguish AddOne-owned UI problems from upstream Pi, profile, provider, or terminal problems. The `a1 ui` subcommand was removed and is not a compatibility alias; run bare `a1` for the owned UI.
+`a1 pi` is the untouched upstream fallback and comparison oracle. Use it to distinguish A1-owned UI problems from upstream Pi, profile, provider, or terminal problems. The `a1 ui` subcommand was removed and is not a compatibility alias; run bare `a1` for the owned UI.
 
 `a1 sandbox` is unchanged: it launches vanilla Pi with isolated Pi configuration and resources. “Sandbox” does not mean operating-system, filesystem, process, network, or credential security isolation. See [`docs/features/launch-profiles.md`](docs/features/launch-profiles.md) for first-run directories, independent `/login`, trust behavior, extension placement, and recovery.
 
@@ -40,7 +40,9 @@ npm run build
 npm start
 ```
 
-`npm start` gives each invocation isolated AddOne development state and an isolated development Pi profile. Use `npm start -- --print-environment` to inspect the selected paths without launching the UI.
+`npm start` gives each invocation isolated A1 development state and an isolated development Pi profile. Use `npm start -- --print-environment` to inspect the selected paths without launching the UI.
+
+A1 control state uses `%APPDATA%\\A1` and `%LOCALAPPDATA%\\A1` on Windows, and the `a1` directory under XDG config/data/runtime roots on Unix. Override it only with declared `A1_*` variables such as `A1_CONFIG_DIR`, `A1_DATA_DIR`, `A1_RUNTIME_DIR`, `A1_DATABASE_PATH`, and `A1_ENDPOINT`. Pi profile roots remain `~/.a1/agent`, `~/.pi/agent`, and `~/.a1/sandbox`. This is a no-migration identity hard cut; see [`docs/architecture/toolchain.md`](docs/architecture/toolchain.md#identity-hard-cut-and-cleanup) before removing obsolete control state.
 
 Run the non-desktop gates with:
 

package/bin/a1-ui.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+const { runSelectedInteractiveRuntime } = await import("../dist/src/features/launch/index.js");
+
+runSelectedInteractiveRuntime(process.env.A1_LAUNCH_PROFILE ?? "a1", {
+  ownedUi: async () => {
+    const [{ runOwnedUi }, { composeOwnedUiApplication }] = await Promise.all([
+      import("../dist/src/features/owned-ui/index.js"),
+      import("../dist/src/composition/index.js"),
+    ]);
+    const application = await composeOwnedUiApplication({ cwd: process.cwd() });
+    return await runOwnedUi({ application });
+  },
+  transparent: async profileId => {
+    const { runSelectedTransparentRuntime } = await import("../dist/src/composition/transparent-runtime.js");
+    return await runSelectedTransparentRuntime(profileId);
+  },
+}).then(
+  code => { process.exitCode = code; },
+  error => {
+    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exitCode = 1;
+  },
+);

package/bin/{addone.js → a1.js}

@@ -2,9 +2,9 @@
 
 const packageRoot = new URL("..", import.meta.url);
 const { fileURLToPath } = await import("node:url");
-const { dispatchAddOneCli } = await import("../dist/src/cli/index.js");
+const { dispatchCli } = await import("../dist/src/cli/index.js");
 
-process.exitCode = await dispatchAddOneCli(process.argv.slice(2), {
+process.exitCode = await dispatchCli(process.argv.slice(2), {
   launch: async intent => {
     const [{ prepareInteractiveLaunch }, { runBootstrap }] = await Promise.all([
       import("../dist/src/features/launch/index.js"),

package/dist/src/cli/dispatch.d.ts

@@ -8,9 +8,9 @@ export interface CliHandlers {
 export interface CliOutput {
     readonly stderr: (message: string) => void;
 }
-export declare const ADDONE_USAGE = "Usage: a1 | a1 pi | a1 sandbox | a1 version | a1 update | a1 update:next";
-export declare function dispatchAddOneCli(arguments_: readonly string[], handlers: CliHandlers, output: CliOutput): Promise<number>;
-export type AddOneCommand = {
+export declare const CLI_USAGE: string;
+export declare function dispatchCli(arguments_: readonly string[], handlers: CliHandlers, output: CliOutput): Promise<number>;
+export type CliCommand = {
     readonly kind: "launch";
     readonly profileId: LaunchProfileId;
 } | {
@@ -22,5 +22,4 @@ export type AddOneCommand = {
     readonly kind: "error";
     readonly message: string;
 };
-export declare function parseAddOneCommand(arguments_: readonly string[]): AddOneCommand;
-//# sourceMappingURL=dispatch.d.ts.map
+export declare function parseCliCommand(arguments_: readonly string[]): CliCommand;

package/dist/src/cli/dispatch.js

@@ -1,9 +1,10 @@
 import { interactiveLaunchIntent } from "../features/launch/index.js";
-export const ADDONE_USAGE = "Usage: a1 | a1 pi | a1 sandbox | a1 version | a1 update | a1 update:next";
-export async function dispatchAddOneCli(arguments_, handlers, output) {
-    const command = parseAddOneCommand(arguments_);
+import { PRODUCT_TEXT } from "../product-identity.js";
+export const CLI_USAGE = PRODUCT_TEXT.usage(["", "pi", "sandbox", "version", "update", "update:next"]);
+export async function dispatchCli(arguments_, handlers, output) {
+    const command = parseCliCommand(arguments_);
     if (command.kind === "error") {
-        output.stderr(`${command.message}\n${ADDONE_USAGE}\n`);
+        output.stderr(`${command.message}\n${CLI_USAGE}\n`);
         return 2;
     }
     if (command.kind === "launch")
@@ -12,16 +13,16 @@ export async function dispatchAddOneCli(arguments_, handlers, output) {
         return await handlers.version();
     return await handlers.update(command.channel);
 }
-export function parseAddOneCommand(arguments_) {
+export function parseCliCommand(arguments_) {
     if (arguments_.length === 0)
-        return { kind: "launch", profileId: "addone" };
+        return { kind: "launch", profileId: "a1" };
     if (arguments_.length > 1)
-        return { kind: "error", message: "AddOne commands do not accept additional arguments." };
+        return { kind: "error", message: PRODUCT_TEXT.diagnostic("commands do not accept additional arguments.") };
     const [command] = arguments_;
     if (command === "pi" || command === "sandbox")
         return { kind: "launch", profileId: command };
     if (command === "ui")
-        return { kind: "error", message: "The ui subcommand was removed; run bare a1 for the owned UI." };
+        return { kind: "error", message: `The ui subcommand was removed; run bare ${PRODUCT_TEXT.commandName} for the owned UI.` };
     if (command === "version")
         return { kind: "version" };
     if (command === "update")
@@ -29,7 +30,6 @@ export function parseAddOneCommand(arguments_) {
     if (command === "update:next")
         return { kind: "update", channel: "next" };
     if (command === "agent")
-        return { kind: "error", message: "Bare a1 is the AddOne agent experience; there is no agent subcommand." };
-    return { kind: "error", message: `Unknown AddOne command: ${command ?? ""}` };
+        return { kind: "error", message: `Bare ${PRODUCT_TEXT.commandName} is the ${PRODUCT_TEXT.displayName} agent experience; there is no agent subcommand.` };
+    return { kind: "error", message: PRODUCT_TEXT.diagnostic(`received an unknown command: ${command ?? ""}`) };
 }
-//# sourceMappingURL=dispatch.js.map

package/dist/src/cli/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./dispatch.js";
 export * from "./version.js";
 export * from "./version-stats.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/cli/index.js

@@ -1,4 +1,3 @@
 export * from "./dispatch.js";
 export * from "./version.js";
 export * from "./version-stats.js";
-//# sourceMappingURL=index.js.map

package/dist/src/cli/version-stats.d.ts

@@ -14,4 +14,3 @@ export interface VersionStatsOptions {
 }
 export declare function runVersionStats(options: VersionStatsOptions): Promise<number>;
 export {};
-//# sourceMappingURL=version-stats.d.ts.map

package/dist/src/cli/version-stats.js

@@ -3,7 +3,7 @@ import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import crossSpawn from "cross-spawn";
 import { valid as validSemver } from "semver";
-const ADDONE_PACKAGE = "@timurproko/a1";
+import { PRODUCT_TEXT } from "../product-identity.js";
 const defaultOutput = {
     stdout(message) { process.stdout.write(message); },
     stderr(message) { process.stderr.write(message); },
@@ -17,36 +17,41 @@ export async function runVersionStats(options) {
         installed = parseVersion(manifest.version, "installed package");
     }
     catch (error) {
-        output.stderr(`AddOne could not read its installed version: ${message(error)}\n`);
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`could not read its installed version: ${message(error)}`)}\n`);
         return 1;
     }
-    const [release, next] = await Promise.all([
-        queryTag(runner, "latest"),
-        queryTag(runner, "next"),
-    ]);
-    output.stdout(`Installed: ${installed}\nRelease:   ${release.version ?? "unavailable"}\nNext:      ${next.version ?? "unavailable"}\n`);
-    for (const result of [release, next]) {
-        if (result.error)
-            output.stderr(`AddOne could not resolve npm ${result.tag}: ${result.error}\n`);
-    }
+    const remote = await queryDistTags(runner);
+    output.stdout(`Installed: ${installed}\nRelease:   ${remote.release ?? "unavailable"}\nNext:      ${remote.next ?? "unavailable"}\n`);
+    if (remote.error)
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`could not resolve npm dist-tags: ${remote.error}`)}\n`);
     return 0;
 }
-async function queryTag(runner, tag) {
+async function queryDistTags(runner) {
+    let result;
+    try {
+        result = await runner("npm", ["view", PRODUCT_TEXT.packageName, "dist-tags", "--json"]);
+    }
+    catch (error) {
+        return unavailable(message(error));
+    }
+    if (result.code !== 0)
+        return unavailable(`npm exited with status ${result.code ?? "unknown"}`);
     try {
-        const result = await runner("npm", ["view", `${ADDONE_PACKAGE}@${tag}`, "version"]);
-        if (result.code !== 0)
-            return { tag, version: null, error: `npm exited with status ${result.code ?? "unknown"}` };
-        try {
-            return { tag, version: parseVersion(result.stdout.trim(), `npm ${tag}`), error: null };
-        }
-        catch (error) {
-            return { tag, version: null, error: message(error) };
-        }
+        const metadata = JSON.parse(result.stdout);
+        if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata))
+            throw new TypeError("npm returned a non-object dist-tags value");
+        const tags = metadata;
+        const release = parseVersion(tags.latest, "npm latest");
+        const next = tags.next === undefined ? null : parseVersion(tags.next, "npm next");
+        return { release, next, error: null };
     }
     catch (error) {
-        return { tag, version: null, error: message(error) };
+        return unavailable(message(error));
     }
 }
+function unavailable(error) {
+    return { release: null, next: null, error };
+}
 function createVersionProcessRunner() {
     return async (command, arguments_) => await new Promise((resolvePromise, rejectPromise) => {
         const child = process.platform === "win32"
@@ -65,4 +70,3 @@ function parseVersion(value, source) {
     return parsed;
 }
 function message(error) { return error instanceof Error ? error.message : String(error); }
-//# sourceMappingURL=version-stats.js.map

package/dist/src/cli/version.d.ts

@@ -1,3 +1,2 @@
 export declare function readInstalledVersion(moduleUrl?: string): string;
-export declare const ADDONE_VERSION: string;
-//# sourceMappingURL=version.d.ts.map
+export declare const INSTALLED_VERSION: string;

package/dist/src/cli/version.js

@@ -1,13 +1,14 @@
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { PRODUCT_IDENTITY } from "../product-identity.js";
 export function readInstalledVersion(moduleUrl = import.meta.url) {
     let directory = dirname(fileURLToPath(moduleUrl));
     for (let depth = 0; depth < 4; depth++) {
         const path = join(directory, "package.json");
         try {
             const metadata = JSON.parse(readFileSync(path, "utf8"));
-            if (metadata.name === "@timurproko/a1" && typeof metadata.version === "string")
+            if (metadata.name === PRODUCT_IDENTITY.packageName && typeof metadata.version === "string")
                 return metadata.version;
         }
         catch (error) {
@@ -17,7 +18,6 @@ export function readInstalledVersion(moduleUrl = import.meta.url) {
         }
         directory = dirname(directory);
     }
-    throw new Error("could not locate installed AddOne package metadata");
+    throw new Error(`could not locate installed ${PRODUCT_IDENTITY.displayName} package metadata`);
 }
-export const ADDONE_VERSION = readInstalledVersion();
-//# sourceMappingURL=version.js.map
+export const INSTALLED_VERSION = readInstalledVersion();

package/dist/src/composition/index.d.ts

@@ -0,0 +1,22 @@
+import { type AgentEnginePort } from "../foundation/agent-engine-contracts/index.js";
+import { type PiEngineAdapter } from "../foundation/pi-engine-adapter/index.js";
+import { type OwnedUiApplicationPort, type PresentationComponentPort, type PresentationRuntimePort, type PresentationTerminalPort } from "../foundation/presentation-contracts/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 OwnedUiCompositionOptions {
+    readonly cwd?: string;
+    readonly terminal?: PresentationTerminalPort;
+    readonly createPiAdapter?: () => Promise<PiEngineAdapter>;
+}
+export declare function composeOwnedUiApplication(options?: OwnedUiCompositionOptions): Promise<OwnedUiApplicationPort>;
+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/src/composition/index.js

@@ -0,0 +1,166 @@
+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";
+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 = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const adapter = options.createPiAdapter ? await options.createPiAdapter() : await createPiEngineAdapter({ cwd });
+    const shell = new OwnedUiSessionShell({
+        backend: adapter,
+        cwd,
+        ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
+    });
+    return {
+        get disposed() { return adapter.disposed; },
+        start: () => shell.start(),
+        flush: () => adapter.flushEvents(),
+        waitUntilStopped: () => shell.waitUntilStopped(),
+        dispose: () => shell.dispose(),
+    };
+}
+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 }] };
+}

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,19 @@
+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/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 = [];
@@ -56,4 +56,3 @@ async function ensureOwnedDirectory(path) {
 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