@timurproko/a1 0.1.8-dev.3b54f21 → 0.1.8-dev.407

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

@@ -0,0 +1,10 @@
+import { type SessionSelection, type LaunchProfileId } from "../../foundation/lifecycle/index.js";
+export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
+export type { LaunchProfileId, SessionSelection } from "../../foundation/lifecycle/index.js";
+export interface InteractiveLaunchIntent {
+    readonly kind: "interactive";
+    readonly profileId: LaunchProfileId;
+    readonly sessionSelection?: SessionSelection;
+}
+export type LaunchIntent = InteractiveLaunchIntent;
+export declare function interactiveLaunchIntent(profileId: LaunchProfileId, sessionSelection?: SessionSelection): InteractiveLaunchIntent;

package/dist/features/launch/intent.js

@@ -0,0 +1,8 @@
+import { sessionSelectionArguments } from "../../foundation/lifecycle/index.js";
+export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
+export function interactiveLaunchIntent(profileId, sessionSelection) {
+    if (sessionSelection !== undefined && profileId !== "a1")
+        throw new Error("session selection requires the normal A1 profile");
+    sessionSelectionArguments(sessionSelection);
+    return Object.freeze({ kind: "interactive", profileId, ...(sessionSelection === undefined ? {} : { sessionSelection }) });
+}

package/dist/{src/features → features}/launch/prepare-launch.d.ts

@@ -2,9 +2,7 @@ import { type LaunchProfilePathOptions } from "./profile-paths.js";
 import { initializeProductProfile } from "./initialize-profile.js";
 import type { InteractiveLaunchIntent } from "./intent.js";
 export interface PreparedInteractiveLaunch {
-    readonly intent: InteractiveLaunchIntent;
     readonly environment: NodeJS.ProcessEnv;
-    readonly piArguments: readonly string[];
     readonly configurationRoot: string | null;
 }
 export interface PrepareInteractiveLaunchOptions extends LaunchProfilePathOptions {

package/dist/{src/features → features}/launch/prepare-launch.js

@@ -2,7 +2,7 @@ import { configurationRootForProfile, resolveLaunchProfilePaths } from "./profil
 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);
+    const configurationRoot = configurationRootForProfile(intent.profileId, paths);
     if (configurationRoot !== null)
         await (options.initializeProfile ?? initializeProductProfile)(configurationRoot);
     const childEnvironment = { ...environment };
@@ -10,12 +10,5 @@ export async function prepareInteractiveLaunch(intent, environment = process.env
         delete childEnvironment.PI_CODING_AGENT_DIR;
     else
         childEnvironment.PI_CODING_AGENT_DIR = configurationRoot;
-    const piArguments = intent.profile.projectTrust === "ignore" ? ["--no-approve"] : [];
-    childEnvironment.A1_LAUNCH_ARGUMENTS_JSON = JSON.stringify(piArguments);
-    return Object.freeze({
-        intent,
-        environment: childEnvironment,
-        piArguments: Object.freeze(piArguments),
-        configurationRoot,
-    });
+    return Object.freeze({ environment: childEnvironment, configurationRoot });
 }

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

@@ -1,9 +1,8 @@
-import type { LaunchProfileId } from "./profiles.js";
+import type { LaunchProfileId } from "./intent.js";
 export interface LaunchProfilePaths {
     readonly home: string;
     readonly managedStateRoot: string;
     readonly agentProfile: string;
-    readonly sandbox: string;
 }
 export interface LaunchProfilePathOptions {
     readonly environment?: NodeJS.ProcessEnv;
@@ -12,4 +11,6 @@ export interface LaunchProfilePathOptions {
     readonly platform?: NodeJS.Platform;
 }
 export declare function resolveLaunchProfilePaths(options?: LaunchProfilePathOptions): LaunchProfilePaths;
+/** Select history storage without relocating control state or probing former stores. */
+export declare function resolvePromptHistoryDataDir(options?: LaunchProfilePathOptions): string;
 export declare function configurationRootForProfile(profileId: LaunchProfileId, paths: LaunchProfilePaths): string | null;

package/dist/{src/features → features}/launch/profile-paths.js

@@ -1,26 +1,31 @@
 import { homedir } from "node:os";
 import { posix, win32 } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { resolveProductPaths } from "../../foundation/lifecycle/index.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[PRODUCT_IDENTITY.environment.profileHome] ?? options.readHome?.() ?? homedir();
     const home = validateAbsolutePath(selectedHome, "effective user home", path);
     const agentProfile = path.resolve(home, PRODUCT_IDENTITY.state.piAgentProfile);
-    const managedStateRoot = path.dirname(agentProfile);
     return Object.freeze({
         home,
-        managedStateRoot,
+        managedStateRoot: path.dirname(agentProfile),
         agentProfile,
-        sandbox: path.resolve(home, PRODUCT_IDENTITY.state.piSandboxProfile),
     });
 }
+/** Select history storage without relocating control state or probing former stores. */
+export function resolvePromptHistoryDataDir(options = {}) {
+    const environment = options.environment ?? process.env;
+    const platform = options.platform ?? process.platform;
+    if (environment[PRODUCT_IDENTITY.environment.dataDir] !== undefined) {
+        return resolveProductPaths(environment, platform).dataDir;
+    }
+    const path = platform === "win32" ? win32 : posix;
+    return path.join(resolveLaunchProfilePaths(options).managedStateRoot, "data");
+}
 export function configurationRootForProfile(profileId, paths) {
-    if (profileId === "a1")
-        return paths.agentProfile;
-    if (profileId === "sandbox")
-        return paths.sandbox;
-    return null;
+    return profileId === "a1" ? paths.agentProfile : null;
 }
 function validateAbsolutePath(value, name, path) {
     if (value.length === 0 || value.includes("\0"))

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

@@ -1,10 +1,7 @@
 import { type LaunchProfileId } from "../../foundation/lifecycle/index.js";
 /**
- * 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.
+ * Both interactive commands use the owned composition. Bare A1 enables product
+ * surfaces; the Pi comparison command withholds them and reads Pi's own profile.
  */
 export type OwnedUiProfileId = LaunchProfileId;
 export interface InteractiveRuntimeSelection {

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

@@ -1,4 +1,4 @@
-import { type OwnedUiCommand, type OwnedUiCustomization, type OwnedUiSlotId, type OwnedUiTranscriptBlock } from "../../foundation/owned-ui-contracts/index.js";
+import { type OwnedUiCommand, type OwnedUiCustomization, type OwnedUiSlotId, type OwnedUiTranscriptBlock } from "../../contracts/owned-ui/index.js";
 export interface OwnedUiSlotImplementation {
     readonly payload: unknown;
     render?(input: unknown, width: number): readonly string[];
@@ -12,6 +12,7 @@ export interface OwnedCommandHandlerContext {
     readonly correlationId: string;
 }
 export type OwnedCommandHandler = (context: OwnedCommandHandlerContext) => OwnedUiCommand | Promise<OwnedUiCommand>;
+/** Registers owned UI commands and assigns a monotonic correlation identifier to each dispatch. */
 export declare class OwnedCommandSurface {
     #private;
     register(name: string, handler: OwnedCommandHandler): () => void;
@@ -22,6 +23,7 @@ export interface ResolvedOwnedUiSlot {
     readonly customization: OwnedUiCustomization;
     readonly implementation: OwnedUiSlotImplementation;
 }
+/** Resolves one customization per slot by precedence and version while preserving registration identity. */
 export declare class OwnedUiCustomizationRegistry {
     #private;
     register(customization: OwnedUiCustomization, implementation: OwnedUiSlotImplementation): () => void;

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

@@ -1,4 +1,5 @@
-import { assertOwnedUiCustomization, } from "../../foundation/owned-ui-contracts/index.js";
+import { assertOwnedUiCustomization, } from "../../contracts/owned-ui/index.js";
+/** Registers owned UI commands and assigns a monotonic correlation identifier to each dispatch. */
 export class OwnedCommandSurface {
     #handlers = new Map();
     #sequence = 0;
@@ -17,6 +18,7 @@ export class OwnedCommandSurface {
         return handler({ sessionId, correlationId: `ui-command-${this.#sequence}` });
     }
 }
+/** Resolves one customization per slot by precedence and version while preserving registration identity. */
 export class OwnedUiCustomizationRegistry {
     #registrations = new Map();
     register(customization, implementation) {

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

@@ -1,4 +1,4 @@
-import type { OwnedUiDiagnostics } from "../../foundation/owned-ui-contracts/index.js";
+import type { OwnedUiDiagnostics } from "../../contracts/owned-ui/index.js";
 export interface OwnedUiFrameObservation {
     readonly requestedFrames: number;
     readonly presentedFrames: number;
@@ -17,6 +17,7 @@ export interface OwnedUiDiagnosticsSnapshot {
     readonly resources: OwnedUiResourceObservation | null;
     readonly terminalRestorationFailed: boolean;
 }
+/** Retains bounded, redacted UI diagnostics together with frame and resource observations. */
 export declare class OwnedUiDiagnosticsRecorder {
     #private;
     readonly maximumEntries: number;

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

@@ -1,3 +1,4 @@
+/** Retains bounded, redacted UI diagnostics together with frame and resource observations. */
 export class OwnedUiDiagnosticsRecorder {
     maximumEntries;
     #entries = [];

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

@@ -1,4 +1,6 @@
 export * from "./customization.js";
 export * from "./diagnostics.js";
 export * from "./run.js";
+export * from "./project-trust-prompt.js";
+export * from "./session-fork-prompt.js";
 export * from "./settings-app.js";

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

@@ -1,4 +1,6 @@
 export * from "./customization.js";
 export * from "./diagnostics.js";
 export * from "./run.js";
+export * from "./project-trust-prompt.js";
+export * from "./session-fork-prompt.js";
 export * from "./settings-app.js";

package/dist/features/owned-ui/project-trust-prompt.d.ts

@@ -0,0 +1,25 @@
+import type { Readable, Writable } from "node:stream";
+export interface OwnedProjectTrustPromptRequest {
+    readonly cwd: string;
+    readonly defaultDecision: "ask" | "always" | "never";
+}
+export type OwnedProjectTrustPrompt = (request: OwnedProjectTrustPromptRequest) => Promise<boolean | null>;
+interface RawTtyInput extends Readable {
+    readonly isTTY?: boolean;
+    readonly isRaw?: boolean;
+    setRawMode?(enabled: boolean): this;
+}
+export interface ConsoleProjectTrustPromptOptions {
+    readonly input?: RawTtyInput;
+    readonly output?: Writable & {
+        readonly isTTY?: boolean;
+        readonly columns?: number;
+    };
+}
+/**
+ * Pre-resource startup selector. It uses only fixed product wording and terminal
+ * controls: no project setting, theme, extension, prompt, package, or skill is
+ * consulted before the trust result exists.
+ */
+export declare function createConsoleProjectTrustPrompt(options?: ConsoleProjectTrustPromptOptions): OwnedProjectTrustPrompt;
+export {};

package/dist/features/owned-ui/project-trust-prompt.js

@@ -0,0 +1,149 @@
+const ENTER_ALTERNATE_SCREEN = "\u001b[?1049h";
+const LEAVE_ALTERNATE_SCREEN = "\u001b[?1049l";
+const HIDE_CURSOR = "\u001b[?25l";
+const SHOW_CURSOR = "\u001b[?25h";
+const CLEAR_HOME = "\u001b[2J\u001b[H";
+const ACCENT = "\u001b[38;2;138;190;183m";
+const MUTED = "\u001b[38;2;128;128;128m";
+const DIM = "\u001b[38;2;102;102;102m";
+const RESET_FG = "\u001b[39m";
+const BOLD = "\u001b[1m";
+const RESET_BOLD = "\u001b[22m";
+/**
+ * Pre-resource startup selector. It uses only fixed product wording and terminal
+ * controls: no project setting, theme, extension, prompt, package, or skill is
+ * consulted before the trust result exists.
+ */
+export function createConsoleProjectTrustPrompt(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    return async ({ cwd }) => {
+        if (input.isTTY !== true || output.isTTY !== true) {
+            throw new Error("an interactive terminal is unavailable");
+        }
+        const wasRaw = input.isRaw === true;
+        let selected = 0;
+        let restored = false;
+        const restore = () => {
+            if (restored)
+                return;
+            restored = true;
+            input.setRawMode?.(wasRaw);
+            output.write(`${CLEAR_HOME}${SHOW_CURSOR}${LEAVE_ALTERNATE_SCREEN}`);
+        };
+        const render = () => {
+            const width = Math.max(20, output.columns ?? 80);
+            const lines = [
+                `${BOLD}${ACCENT}Trust project folder?${RESET_FG}${RESET_BOLD}`,
+                cwd,
+                "",
+                "This allows a1 to load project settings and resources, install missing project packages, and execute project extensions.",
+                "",
+                optionRow("Trust", selected === 0),
+                optionRow("Do not trust", selected === 1),
+                "",
+                `${DIM}  ↑/↓ to navigate · Enter to select · Esc to cancel${RESET_FG}`,
+            ];
+            output.write(`${CLEAR_HOME}${lines.map(line => clipAnsiSafe(line, width)).join("\n")}`);
+        };
+        try {
+            output.write(`${ENTER_ALTERNATE_SCREEN}${HIDE_CURSOR}`);
+            input.setRawMode?.(true);
+            render();
+            return await new Promise((resolve, reject) => {
+                let settled = false;
+                const finish = (value) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    restore();
+                    resolve(value);
+                };
+                const fail = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    restore();
+                    reject(error);
+                };
+                const onData = (chunk) => {
+                    const data = chunk.toString();
+                    for (let index = 0; index < data.length;) {
+                        if (data.startsWith("\u001b[A", index)) {
+                            selected = 0;
+                            index += 3;
+                            render();
+                            continue;
+                        }
+                        if (data.startsWith("\u001b[B", index) || data[index] === "\t") {
+                            selected = selected === 0 ? 1 : 0;
+                            index += data[index] === "\t" ? 1 : 3;
+                            render();
+                            continue;
+                        }
+                        const key = data[index] ?? "";
+                        index += 1;
+                        if (key === "\r" || key === "\n") {
+                            finish(selected === 0);
+                            return;
+                        }
+                        if (key === "\u001b" || key === "\u0003") {
+                            finish(null);
+                            return;
+                        }
+                        // Compatibility: retain y/n aliases for terminals or automation that cannot send
+                        // navigation keys; the visible interaction remains selector-first.
+                        if (key === "y" || key === "Y") {
+                            finish(true);
+                            return;
+                        }
+                        if (key === "n" || key === "N") {
+                            finish(false);
+                            return;
+                        }
+                    }
+                };
+                const onEnd = () => finish(null);
+                const onError = (error) => fail(error);
+                const cleanup = () => {
+                    input.off("data", onData);
+                    input.off("end", onEnd);
+                    input.off("error", onError);
+                };
+                input.on("data", onData);
+                input.once("end", onEnd);
+                input.once("error", onError);
+                input.resume();
+            });
+        }
+        finally {
+            restore();
+        }
+    };
+}
+function optionRow(label, selected) {
+    return selected
+        ? `${ACCENT}→ ${label}${RESET_FG}`
+        : `  ${label}`;
+}
+/** Avoid replaying or manufacturing control payloads while keeping fixed SGR. */
+function clipAnsiSafe(line, width) {
+    let visible = 0;
+    let output = "";
+    for (let index = 0; index < line.length && visible < width;) {
+        if (line[index] === "\u001b") {
+            const match = line.slice(index).match(/^\u001b\[[0-9;:]*m/);
+            if (match !== null) {
+                output += match[0];
+                index += match[0].length;
+                continue;
+            }
+        }
+        output += line[index];
+        index += 1;
+        visible += 1;
+    }
+    return `${output}${RESET_FG}${RESET_BOLD}`;
+}

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

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

package/dist/features/owned-ui/run.js

@@ -0,0 +1,32 @@
+import { markStartupPhase } from "../../foundation/startup/index.js";
+import { boundedCleanup } from "../../foundation/terminal-cleanup/index.js";
+export async function runOwnedUi(options) {
+    const { application, settings } = options;
+    let failed = false;
+    let originalFailure;
+    try {
+        if (settings)
+            await settings.load();
+        application.start();
+        await application.flush();
+        await markStartupPhase(process.env, "first-input-ready-render");
+        if (!application.disposed)
+            await application.waitUntilStopped();
+        return 0;
+    }
+    catch (error) {
+        failed = true;
+        originalFailure = error;
+        throw error;
+    }
+    finally {
+        try {
+            await boundedCleanup(() => application.dispose(), 2500);
+        }
+        catch (error) {
+            if (failed)
+                throw new AggregateError([originalFailure, error], "Owned UI run and cleanup failed", { cause: originalFailure });
+            throw error;
+        }
+    }
+}

package/dist/features/owned-ui/session-fork-prompt.d.ts

@@ -0,0 +1,8 @@
+import type { Readable, Writable } from "node:stream";
+/** Pre-resource, line-mode confirmation matching Pi's cross-project CLI fork decision. */
+export declare function createConsoleSessionForkPrompt(options?: {
+    readonly input?: Readable;
+    readonly output?: Writable;
+}): (request: {
+    readonly sourceCwd: string;
+}) => Promise<boolean>;

package/dist/features/owned-ui/session-fork-prompt.js

@@ -0,0 +1,34 @@
+import { createInterface } from "node:readline";
+/** Pre-resource, line-mode confirmation matching Pi's cross-project CLI fork decision. */
+export function createConsoleSessionForkPrompt(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    return async ({ sourceCwd }) => {
+        output.write(`Session found in different project: ${sourceCwd}\n`);
+        const wasFlowing = input.readableFlowing;
+        const readline = createInterface({ input, output });
+        try {
+            return await new Promise((resolve, reject) => {
+                const finish = (accepted) => { cleanup(); resolve(accepted); };
+                const cancel = () => finish(false);
+                const fail = (error) => { cleanup(); reject(error); };
+                const cleanup = () => {
+                    readline.off("close", cancel);
+                    readline.off("SIGINT", cancel);
+                    input.off("error", fail);
+                };
+                readline.once("close", cancel);
+                readline.once("SIGINT", cancel);
+                input.once("error", fail);
+                readline.question("Fork this session into current directory? [y/N] ", answer => {
+                    finish(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+                });
+            });
+        }
+        finally {
+            readline.close();
+            if (wasFlowing !== true)
+                input.pause();
+        }
+    };
+}

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

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