@timurproko/a1 0.1.8-dev.407 → 0.1.8-dev.443

package/bin/cli.js

@@ -2,14 +2,17 @@
 
 const commandStartedAtMs = performance.timeOrigin + performance.now();
 const packageRoot = new URL("..", import.meta.url);
-const startup = await import("../dist/foundation/startup/index.js");
+const startup = await import("../dist/foundation/startup/startup-runtime.js");
 const startupProfile = process.argv[2] === "pi" ? "pi" : "a1";
 startup.initializeStartupTrace(process.env, startupProfile, commandStartedAtMs);
 startup.enableEnvironmentCompileCache(process.env);
 await startup.markStartupPhase(process.env, "command-invoked");
 const { fileURLToPath } = await import("node:url");
 const { readFile } = await import("node:fs/promises");
-const { cliCapabilities, dispatchCli } = await import("../dist/cli/index.js");
+const [{ cliCapabilities }, { dispatchCli }] = await Promise.all([
+  import("../dist/cli/capabilities.js"),
+  import("../dist/cli/dispatch.js"),
+]);
 
 // Compatibility: which commands this build exposes follows from the build's own version, so a
 // released a1 cannot be argued into offering the development profiles.
@@ -18,8 +21,8 @@ const capabilities = cliCapabilities(JSON.parse(await readFile(new URL("package.
 process.exitCode = await dispatchCli(process.argv.slice(2), {
   launch: async intent => {
     const [{ prepareInteractiveLaunch }, { runBootstrap }, { healModuleIdentityAtLaunch, releaseCopyIsLaunchable }] = await Promise.all([
-      import("../dist/features/launch/index.js"),
-      import("../dist/foundation/release/index.js"),
+      import("../dist/features/launch/prepare-launch.js"),
+      import("../dist/foundation/release/bootstrap.js"),
       import("./module-identity.js"),
     ]);
     // Compatibility: self-heal the installed tree before the release store copies it: npm 12
@@ -36,18 +39,20 @@ process.exitCode = await dispatchCli(process.argv.slice(2), {
     });
   },
   version: async () => {
-    const { runVersionStats } = await import("../dist/cli/index.js");
+    const { runVersionStats } = await import("../dist/cli/version-stats.js");
     return await runVersionStats({ packageRoot: fileURLToPath(packageRoot) });
   },
   update: async (channel, target) => {
-    const { runSelfUpdate } = await import("../dist/foundation/release/index.js");
+    const { runSelfUpdate } = await import("../dist/foundation/release/update.js");
     return await runSelfUpdate({ packageRoot: fileURLToPath(packageRoot), channel, ...(target === undefined ? {} : { target }) });
   },
   packages: async request => {
-    const [{ runPackageCommand }, { createPiPackagesPort }] = await Promise.all([
-      import("../dist/cli/index.js"),
-      import("../dist/integrations/pi/engine/index.js"),
+    const [{ runPackageCommand }, identity] = await Promise.all([
+      import("../dist/cli/packages.js"),
+      import("./module-identity.js"),
     ]);
+    identity.configurePinnedPiPublicPackage(fileURLToPath(packageRoot));
+    const { createPiPackagesPort } = await import("../dist/integrations/pi/engine/package-integration.js");
     return await runPackageCommand(request, { createPort: createPiPackagesPort });
   },
 }, {

package/bin/guardian.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
-const startup = await import("../dist/foundation/startup/index.js");
+const startup = await import("../dist/foundation/startup/startup-runtime.js");
 startup.enableEnvironmentCompileCache(process.env);
 await startup.markStartupPhase(process.env, "guardian-start");
 const { resolve } = await import("node:path");
-const { parseSessionSelection } = await import("../dist/foundation/lifecycle/index.js");
-const { runLaunchGuardian } = await import("../dist/foundation/launch-guardian/index.js");
+const { parseSessionSelection } = await import("../dist/foundation/lifecycle/session-selection.js");
+const { runLaunchGuardian } = await import("../dist/foundation/launch-guardian/main.js");
 
 const { readLaunchContext } = await import("../dist/foundation/launch-context/index.js");
 const launchContext = readLaunchContext(process.env, "release");

package/bin/module-identity.js

@@ -88,12 +88,30 @@ function followProxyReExport(resolvedPath) {
  * require resolves pi-tui, which publishes no `exports` map at all.
  */
 export function resolvePinnedPiTui(packageRoot) {
+  const pinnedRoot = resolvePinnedPiRoot(packageRoot);
+  return canonical(createRequire(pathToFileURL(join(pinnedRoot, "package.json")).href).resolve("@earendil-works/pi-tui"));
+}
+
+/**
+ * Bind Pi's documented package-asset override to the exact public package root.
+ * The generated startup facade otherwise inherits its own A1 `import.meta.url`,
+ * which would make Pi read A1's package metadata and themes.
+ */
+export function configurePinnedPiPublicPackage(packageRoot, environment = process.env) {
+  const pinnedRoot = resolvePinnedPiRoot(packageRoot);
+  const manifest = JSON.parse(readFileSync(join(pinnedRoot, "package.json"), "utf8"));
+  if (manifest.name !== "@earendil-works/pi-coding-agent" || typeof manifest.version !== "string") {
+    throw new Error("pinned Pi public package identity is invalid");
+  }
+  environment.PI_PACKAGE_DIR = pinnedRoot;
+  return { root: pinnedRoot, version: manifest.version };
+}
+
+function resolvePinnedPiRoot(packageRoot) {
   let directory = packageRoot;
   while (true) {
     const candidate = join(directory, "node_modules", "@earendil-works", "pi-coding-agent");
-    if (existsSync(join(candidate, "package.json"))) {
-      return canonical(createRequire(pathToFileURL(join(candidate, "package.json")).href).resolve("@earendil-works/pi-tui"));
-    }
+    if (existsSync(join(candidate, "package.json"))) return canonical(candidate);
     const parent = dirname(directory);
     if (parent === directory) throw new Error("pinned Pi is not installed beneath this package root");
     directory = parent;

package/bin/pinned-pi-public.d.ts

@@ -0,0 +1,3 @@
+export function configurePinnedPiPublicPackageEntry(entryUrl: string): { readonly root: string; readonly version: string };
+export function pinnedPiModuleUrl(relativeModule: string): string;
+export function resolvePinnedPiImport(specifier: string): string;

package/bin/pinned-pi-public.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, posix, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/** Bind the generated facade to the package reached through Pi's public entry. */
+export function configurePinnedPiPublicPackageEntry(entryUrl) {
+  const root = dirname(dirname(fileURLToPath(entryUrl)));
+  const manifest = JSON.parse(readFileSync(resolve(root, "package.json"), "utf8"));
+  if (manifest.name !== "@earendil-works/pi-coding-agent" || typeof manifest.version !== "string") {
+    throw new Error("pinned Pi public package identity is invalid");
+  }
+  process.env.PI_PACKAGE_DIR = root;
+  return { root, version: manifest.version };
+}
+
+/** Preserve one bundled Pi module's original public-package URL semantics. */
+export function pinnedPiModuleUrl(relativeModule) {
+  if (typeof relativeModule !== "string" || relativeModule.includes("\\") || relativeModule.startsWith("/")
+    || posix.normalize(relativeModule).startsWith("../") || !relativeModule.endsWith(".js")) {
+    throw new Error("pinned Pi module identity is invalid");
+  }
+  return pathToFileURL(resolve(pinnedRoot(), "dist", relativeModule)).href;
+}
+
+/** Resolve documented Pi dependency exports from the pinned public package tree. */
+export function resolvePinnedPiImport(specifier) {
+  if (typeof specifier !== "string" || specifier.includes("\\") || specifier.includes("\0")) {
+    throw new Error("pinned Pi import specifier is invalid");
+  }
+  const root = pinnedRoot();
+  if (specifier === "@earendil-works/pi-coding-agent") return pathToFileURL(resolve(root, "dist", "index.js")).href;
+  const match = /^(@[^/]+\/[^/]+|[^/]+)(\/.*)?$/.exec(specifier);
+  if (match === null) throw new Error(`pinned Pi import is invalid: ${specifier}`);
+  const packageName = match[1];
+  const subpath = match[2]?.slice(1) ?? "";
+  const packageRoot = resolve(root, "node_modules", ...packageName.split("/"));
+  const manifestPath = resolve(packageRoot, "package.json");
+  if (!existsSync(manifestPath)) throw new Error(`pinned Pi dependency is unavailable: ${packageName}`);
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  const declaredTarget = exportedTarget(manifest.exports, subpath) ?? (subpath.length === 0 ? manifest.module ?? manifest.main : undefined);
+  const target = typeof declaredTarget === "string" && !declaredTarget.startsWith(".") ? `./${declaredTarget}` : declaredTarget;
+  if (typeof target !== "string" || !target.startsWith("./")) throw new Error(`pinned Pi dependency export is unavailable: ${specifier}`);
+  const path = resolve(packageRoot, target);
+  if (!path.startsWith(`${packageRoot}${sep}`) || !existsSync(path)) throw new Error(`pinned Pi dependency export is missing: ${specifier}`);
+  return pathToFileURL(path).href;
+}
+
+function pinnedRoot() {
+  const root = process.env.PI_PACKAGE_DIR;
+  if (!root || !existsSync(resolve(root, "package.json"))) throw new Error("pinned Pi public package directory is not configured");
+  return resolve(root);
+}
+
+function exportedTarget(exports, subpath) {
+  const key = subpath.length === 0 ? "." : `./${subpath}`;
+  if (typeof exports === "string") return subpath.length === 0 ? exports : undefined;
+  if (!exports || typeof exports !== "object") return undefined;
+  const exact = exports[key];
+  if (exact !== undefined) return importCondition(exact);
+  for (const [pattern, value] of Object.entries(exports)) {
+    const star = pattern.indexOf("*");
+    if (star < 0 || !key.startsWith(pattern.slice(0, star)) || !key.endsWith(pattern.slice(star + 1))) continue;
+    const matched = key.slice(star, key.length - (pattern.length - star - 1));
+    const target = importCondition(value);
+    return typeof target === "string" ? target.replaceAll("*", matched) : undefined;
+  }
+  return undefined;
+}
+
+function importCondition(value) {
+  if (typeof value === "string") return value;
+  if (!value || typeof value !== "object") return undefined;
+  return importCondition(value.import ?? value.default);
+}

package/bin/ui.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
-const startup = await import("../dist/foundation/startup/index.js");
+const startup = await import("../dist/foundation/startup/startup-runtime.js");
 startup.enableEnvironmentCompileCache(process.env);
 const { readLaunchContext } = await import("../dist/foundation/launch-context/index.js");
 const launchContext = readLaunchContext(process.env, "profile");
 const profile = launchContext.launchProfile;
-const { installFatalExit } = await import("../dist/foundation/terminal-cleanup/index.js");
-const { resolveProductPaths } = await import("../dist/foundation/lifecycle/index.js");
+const { installFatalExit } = await import("../dist/foundation/terminal-cleanup/fatal-exit.js");
+const { resolveProductPaths } = await import("../dist/foundation/lifecycle/paths.js");
 const { join } = await import("node:path");
 let runningApplication;
 const fatal = profile === "a1" ? installFatalExit({
@@ -14,33 +14,29 @@ const fatal = profile === "a1" ? installFatalExit({
   releaseId: launchContext.releaseId,
   dispose: () => runningApplication?.dispose(),
 }) : undefined;
-// Performance: begin the exact launch graph together while the trace write is pending.
-// Direct owned-module entries avoid evaluating unrelated barrel exports before first paint.
-const modules = Promise.all([
-  import("./module-identity.js"),
+const [{ fileURLToPath }, identity, descriptor] = await Promise.all([
   import("node:url"),
-  import("../dist/features/launch/runtime-selection.js"),
-  import("../dist/foundation/lifecycle/session-selection.js"),
-  import("../dist/features/owned-ui/project-trust-prompt.js"),
-  import("../dist/features/owned-ui/session-fork-prompt.js"),
-  import("../dist/features/owned-ui/run.js"),
-  import("../dist/composition/owned-ui.js"),
+  import("./module-identity.js"),
+  import("../dist/foundation/startup/startup-descriptor.js"),
 ]);
+const packageRootPath = fileURLToPath(new URL("..", import.meta.url));
+identity.configurePinnedPiPublicPackage(packageRootPath);
+// Performance: begin the exact launch graph together while the trace write is pending.
+// Direct owned-module entries avoid evaluating unrelated barrel exports before first paint.
+const modules = descriptor.loadDeclaredStartupGraph();
 await startup.markStartupPhase(process.env, "ui-entry");
 const [
-  { assertSinglePiTuiModuleAtLaunch },
-  { fileURLToPath },
   { runSelectedInteractiveRuntime },
   { parseSessionSelection },
   { createConsoleProjectTrustPrompt },
   { createConsoleSessionForkPrompt },
-  { runOwnedUi },
+  { runOwnedUi, terminateOwnedUiProcess },
   { composeOwnedUi },
 ] = await modules;
 
 // Compatibility: before the composition uses pinned Pi's terminal stack: confirm A1 and Pi
 // resolve it to the same copy, so extensions and the owned UI share one module identity.
-assertSinglePiTuiModuleAtLaunch(fileURLToPath(new URL("..", import.meta.url)), message => process.stderr.write(message));
+identity.assertSinglePiTuiModuleAtLaunch(packageRootPath, message => process.stderr.write(message));
 await startup.markStartupPhase(process.env, "ui-modules-loaded");
 
 const sessionSelection = parseSessionSelection(process.argv.slice(2));
@@ -61,7 +57,10 @@ Promise.resolve().then(() => {
     },
   });
 }).then(
-  code => { fatal?.remove(); process.exitCode = code; },
+  code => {
+    fatal?.remove();
+    return terminateOwnedUiProcess(code);
+  },
   error => {
     if (fatal && error?.name !== "PiSessionSelectionError") { fatal.fail(error); return; }
     fatal?.remove();

package/bin/warmup.js

@@ -1,21 +1,19 @@
 #!/usr/bin/env node
 
-const startup = await import("../dist/foundation/startup/index.js");
+const startup = await import("../dist/foundation/startup/startup-runtime.js");
 startup.assertImmutableWarmupEnvironment(process.env);
 startup.enableEnvironmentCompileCache(process.env);
+const [{ fileURLToPath }, identity, descriptor] = await Promise.all([
+  import("node:url"),
+  import("./module-identity.js"),
+  import("../dist/foundation/startup/startup-descriptor.js"),
+]);
+identity.configurePinnedPiPublicPackage(fileURLToPath(new URL("..", import.meta.url)));
 
 // Security: this entry imports the exact interactive graph but never composes it, so it
 // creates no terminal, profile/session path, trust callback, executable resource loader,
 // extension runner, or network client.
-const [identity, launch, selection, trustPrompt, forkPrompt, run, composition] = await Promise.all([
-  import("./module-identity.js"),
-  import("../dist/features/launch/runtime-selection.js"),
-  import("../dist/foundation/lifecycle/session-selection.js"),
-  import("../dist/features/owned-ui/project-trust-prompt.js"),
-  import("../dist/features/owned-ui/session-fork-prompt.js"),
-  import("../dist/features/owned-ui/run.js"),
-  import("../dist/composition/owned-ui.js"),
-]);
+const [launch, selection, trustPrompt, forkPrompt, run, composition] = await descriptor.loadDeclaredStartupGraph();
 if (typeof identity.assertSinglePiTuiModuleAtLaunch !== "function"
   || typeof launch.runSelectedInteractiveRuntime !== "function"
   || typeof selection.parseSessionSelection !== "function"

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

@@ -1,6 +1,8 @@
-import { type SessionSelection } from "../foundation/lifecycle/index.js";
-import { type PiEngineAdapter, type PiProjectTrustPreflightPrompt, type PiSessionForkPrompt } from "../integrations/pi/engine/index.js";
-import { OwnedUiSettingsSession } from "../ui/settings/index.js";
+import type { SessionSelection } from "../foundation/lifecycle/session-selection.js";
+import type { PiEngineAdapter } from "../integrations/pi/engine/adapter.js";
+import type { PiProjectTrustPreflightPrompt } from "../integrations/pi/engine/project-trust-preflight.js";
+import type { PiSessionForkPrompt } from "../integrations/pi/engine/session-selection.js";
+import { OwnedUiSettingsSession } from "../ui/settings/session.js";
 import type { OwnedUiApplicationPort, PresentationTerminalPort } from "../contracts/presentation/index.js";
 export interface OwnedUiCompositionOptions {
     readonly cwd?: string;

package/dist/composition/owned-ui.js

@@ -1,13 +1,17 @@
-import { SuggestionDiagnosticCapture } from "../features/prompt-suggestions/index.js";
+import { SuggestionDiagnosticCapture } from "../features/prompt-suggestions/diagnostics.js";
 import { PRODUCT_IDENTITY } from "../product-identity.js";
-import { PromptHistoryService, PromptImageSidecar, resolvePromptHistoryPath } from "../features/prompt-history/index.js";
-import { resolvePromptHistoryDataDir } from "../features/launch/index.js";
-import { resolveProductPaths } from "../foundation/lifecycle/index.js";
-import { applyConfiguredPiTheme, getAvailablePiThemes, loadHistoryEditor } from "../integrations/pi/components/index.js";
-import { createPiEngineAdapter, } from "../integrations/pi/engine/index.js";
-import { ClipboardDiagnosticCapture, OwnedUiSessionShell } from "../integrations/pi/session-ui/index.js";
-import { OwnedUiSettingsSession, OwnedUiSettingsStore } from "../ui/settings/index.js";
-import { createPiTerminalBridge } from "../integrations/pi/tui-runtime/index.js";
+import { PromptHistoryService } from "../features/prompt-history/service.js";
+import { PromptImageSidecar } from "../features/prompt-history/image-sidecar.js";
+import { resolvePromptHistoryPath } from "../features/prompt-history/paths.js";
+import { resolvePromptHistoryDataDir } from "../features/launch/profile-paths.js";
+import { resolveProductPaths } from "../foundation/lifecycle/paths.js";
+import { applyConfiguredPiTheme, getAvailablePiThemes } from "../integrations/pi/components/upstream/theme/theme.js";
+import { createPiEngineAdapter } from "../integrations/pi/engine/adapter.js";
+import { ClipboardDiagnosticCapture } from "../integrations/pi/session-ui/clipboard-diagnostics.js";
+import { OwnedUiSessionShell } from "../integrations/pi/session-ui/session-shell.js";
+import { OwnedUiSettingsSession } from "../ui/settings/session.js";
+import { OwnedUiSettingsStore } from "../ui/settings/store.js";
+import { createPiTerminalBridge } from "../integrations/pi/tui-runtime/presentation-adapter.js";
 import { createOwnedRouteHost } from "./settings-route-host.js";
 export async function composeOwnedUiApplication(options = {}) {
     return (await composeOwnedUi(options)).application;
@@ -81,7 +85,10 @@ export async function composeOwnedUi(options = {}) {
             }),
             ...(viewportSettings === null ? {} : { viewportSettings }),
             ...(promptSuggestions === null ? {} : { promptSuggestions }),
-            ...(promptHistory === null ? {} : { promptHistory: { ...promptHistory, editor: await loadHistoryEditor() } }),
+            ...(promptHistory === null ? {} : { promptHistory: {
+                    ...promptHistory,
+                    editor: await import("../integrations/pi/components/history-editor-loader.js").then(module => module.loadHistoryEditor()),
+                } }),
         });
     }
     catch (error) {

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

@@ -1,8 +1,7 @@
-import type { OwnedUiSettingsSession } from "../ui/settings/index.js";
-import { type UiRouteHost } from "../ui/apps/index.js";
+import type { OwnedUiSettingsSession } from "../ui/settings/session.js";
+import type { UiRouteHost } from "../ui/apps/contracts.js";
 /**
- * Registers the A1-owned screens and adapts the app host to the shell's route
- * seam. The shell mounts whatever surface it is handed and forwards keys; it
- * never learns what an app is.
+ * Declares the A1-owned settings route without evaluating its presentation graph
+ * during startup. Opening the route retains input while the optional module loads.
  */
 export declare function createOwnedRouteHost(settings: OwnedUiSettingsSession): UiRouteHost;

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

@@ -1,59 +1,100 @@
-import { SETTINGS_APP_ID, SETTINGS_ROUTE, SettingsApp } from "../features/owned-ui/index.js";
-import { piTheme } from "../integrations/pi/components/index.js";
-import { UiAppHost, UiAppRegistry, } from "../ui/apps/index.js";
-import { faint } from "../ui/components/index.js";
+import { SETTINGS_APP_ID, SETTINGS_ROUTE } from "../features/owned-ui/settings-route.js";
+import { piTheme } from "../integrations/pi/components/upstream/theme/theme.js";
+import { faint } from "../ui/components/text.js";
 /**
- * Registers the A1-owned screens and adapts the app host to the shell's route
- * seam. The shell mounts whatever surface it is handed and forwards keys; it
- * never learns what an app is.
+ * Declares the A1-owned settings route without evaluating its presentation graph
+ * during startup. Opening the route retains input while the optional module loads.
  */
 export function createOwnedRouteHost(settings) {
+    return {
+        claims: route => route === SETTINGS_ROUTE,
+        open: route => route === SETTINGS_ROUTE ? deferredSettingsSurface(settings) : null,
+    };
+}
+function deferredSettingsSurface(settings) {
+    let delegate = null;
+    let closed = false;
+    let failure = null;
+    let onRender = () => undefined;
+    let onExit = () => undefined;
+    const pending = [];
+    void loadSettingsSurface(settings).then(surface => {
+        if (closed) {
+            surface.close();
+            return;
+        }
+        delegate = surface;
+        surface.onRenderRequested(() => onRender());
+        surface.onExitRequested(() => onExit());
+        for (const action of pending.splice(0))
+            action(surface);
+        onRender();
+    }).catch(error => {
+        failure = `Could not load settings: ${error instanceof Error ? error.message : String(error)}`;
+        onRender();
+    });
+    const defer = (action) => {
+        if (delegate !== null)
+            action(delegate);
+        else if (!closed && pending.length < 32)
+            pending.push(action);
+    };
+    return {
+        id: SETTINGS_APP_ID,
+        render: (width, height) => delegate?.render(width, height)
+            ?? [...(height > 0 ? [failure ?? "Loading settings…"] : []), ...Array(Math.max(0, height - 1)).fill("")]
+                .map(line => line.slice(0, Math.max(0, width))),
+        handleInput: data => { defer(surface => surface.handleInput(data)); return true; },
+        handleMouse: event => { defer(surface => surface.handleMouse(event)); return true; },
+        isClosed: () => closed || delegate?.isClosed() === true,
+        close: () => { closed = true; pending.length = 0; delegate?.close(); },
+        onRenderRequested: listener => { onRender = listener; },
+        onExitRequested: listener => { onExit = listener; },
+    };
+}
+async function loadSettingsSurface(settings) {
+    const [{ SettingsApp }, { UiAppHost }, { UiAppRegistry }] = await Promise.all([
+        import("../features/owned-ui/settings-app.js"),
+        import("../ui/apps/host.js"),
+        import("../ui/apps/registry.js"),
+    ]);
     const registry = new UiAppRegistry();
     registry.register({ id: SETTINGS_APP_ID, route: SETTINGS_ROUTE, create: () => new SettingsApp(settings) });
+    let size = { width: 80, height: 24 };
+    let frame = [];
+    let closed = false;
+    let onRender = () => undefined;
+    let onExit = () => undefined;
+    const host = new UiAppHost({
+        registry,
+        closeOnInterrupt: true,
+        theme: pinnedTheme(),
+        surface: {
+            size: () => size,
+            requestRender: () => onRender(),
+            exit: () => onExit(),
+            present: lines => {
+                if (lines === null)
+                    closed = true;
+                else
+                    frame = lines;
+            },
+        },
+    });
+    host.open(SETTINGS_APP_ID);
     return {
-        claims: route => registry.forRoute(route) !== null,
-        open: route => {
-            const registration = registry.forRoute(route);
-            if (registration === null)
-                return null;
-            let size = { width: 80, height: 24 };
-            let frame = [];
-            let closed = false;
-            let onRender = () => undefined;
-            let onExit = () => undefined;
-            const host = new UiAppHost({
-                registry,
-                closeOnInterrupt: true,
-                theme: pinnedTheme(),
-                surface: {
-                    size: () => size,
-                    requestRender: () => onRender(),
-                    exit: () => onExit(),
-                    present: lines => {
-                        if (lines === null)
-                            closed = true;
-                        else
-                            frame = lines;
-                    },
-                },
-            });
-            host.open(registration.id);
-            const surface = {
-                id: registration.id,
-                render: (width, height) => {
-                    size = { width, height };
-                    host.render();
-                    return frame.length === height ? frame : [...frame.slice(0, height), ...Array(Math.max(0, height - frame.length)).fill("")];
-                },
-                handleInput: data => host.handleInput(data).consumed,
-                handleMouse: event => host.handleMouse(event).consumed,
-                isClosed: () => closed || !host.isPresenting,
-                close: () => host.close(),
-                onRenderRequested: listener => { onRender = listener; },
-                onExitRequested: listener => { onExit = listener; },
-            };
-            return surface;
+        id: SETTINGS_APP_ID,
+        render: (width, height) => {
+            size = { width, height };
+            host.render();
+            return frame.length === height ? frame : [...frame.slice(0, height), ...Array(Math.max(0, height - frame.length)).fill("")];
         },
+        handleInput: data => host.handleInput(data).consumed,
+        handleMouse: event => host.handleMouse(event).consumed,
+        isClosed: () => closed || !host.isPresenting,
+        close: () => host.close(),
+        onRenderRequested: listener => { onRender = listener; },
+        onExitRequested: listener => { onExit = listener; },
     };
 }
 /** Maps A1 UI tokens onto the pinned Pi theme so owned screens match the shell. */
@@ -61,14 +102,8 @@ function pinnedTheme() {
     return {
         fg: (token, text) => piTheme().fg(token, text),
         bold: (text) => piTheme().bold(text),
-        // Rationale: 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,
-        // Rationale: quiet, and quieter again: the terminal's own faint attribute over the
-        // dimmest colour the theme has.
         disabled: (text) => faint(piTheme().fg("dim", text)),
-        // Rationale: physical review requires the shared value menu to read as a floating
-        // product surface instead of blending into the settings rows behind it.
         highlight: (text) => `\u001b[48;2;82;82;82m\u001b[97m${text}\u001b[39m\u001b[49m`,
         panel: (text) => `\u001b[48;2;55;55;55m${text}\u001b[49m`,
     };

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

@@ -1,6 +1,8 @@
-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";
+import { type SessionSelection } from "../../foundation/lifecycle/session-selection.js";
+import type { LaunchProfileId } from "../../foundation/lifecycle/model.js";
+export { parseSessionSelection } from "../../foundation/lifecycle/session-selection.js";
+export type { SessionSelection } from "../../foundation/lifecycle/session-selection.js";
+export type { LaunchProfileId } from "../../foundation/lifecycle/model.js";
 export interface InteractiveLaunchIntent {
     readonly kind: "interactive";
     readonly profileId: LaunchProfileId;

package/dist/features/launch/intent.js

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

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

@@ -1,7 +1,7 @@
 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";
+import { resolveProductPaths } from "../../foundation/lifecycle/paths.js";
 export function resolveLaunchProfilePaths(options = {}) {
     const environment = options.environment ?? process.env;
     const path = options.platform === "win32" || (options.platform === undefined && process.platform === "win32") ? win32 : posix;

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

@@ -1,4 +1,4 @@
-import { type LaunchProfileId } from "../../foundation/lifecycle/index.js";
+import { type LaunchProfileId } from "../../foundation/lifecycle/model.js";
 /**
  * Both interactive commands use the owned composition. Bare A1 enables product
  * surfaces; the Pi comparison command withholds them and reads Pi's own profile.

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

@@ -1,4 +1,4 @@
-import { assertLaunchProfileId } from "../../foundation/lifecycle/index.js";
+import { assertLaunchProfileId } from "../../foundation/lifecycle/model.js";
 export function selectInteractiveRuntime(profileId) {
     assertLaunchProfileId(profileId);
     return Object.freeze({

package/dist/features/owned-ui/run.d.ts

@@ -8,4 +8,10 @@ export interface OwnedUiRunOptions {
      */
     readonly settings?: OwnedUiSettingsSession;
 }
+/**
+ * Completes the interactive executable only after runOwnedUi has restored its terminal.
+ * Extensions are untrusted process guests and can retain servers or timers after session
+ * shutdown, so assigning exitCode alone cannot guarantee return to the invoking shell.
+ */
+export declare function terminateOwnedUiProcess(code: number): Promise<never>;
 export declare function runOwnedUi(options: OwnedUiRunOptions): Promise<number>;

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

@@ -1,5 +1,16 @@
-import { markStartupPhase } from "../../foundation/startup/index.js";
-import { boundedCleanup } from "../../foundation/terminal-cleanup/index.js";
+import { markStartupPhase } from "../../foundation/startup/startup-runtime.js";
+import { boundedCleanup } from "../../foundation/terminal-cleanup/terminal-reset.js";
+const PROCESS_OUTPUT_FLUSH_TIMEOUT_MS = 250;
+/**
+ * Completes the interactive executable only after runOwnedUi has restored its terminal.
+ * Extensions are untrusted process guests and can retain servers or timers after session
+ * shutdown, so assigning exitCode alone cannot guarantee return to the invoking shell.
+ */
+export async function terminateOwnedUiProcess(code) {
+    process.exitCode = code;
+    await Promise.all([flushProcessOutput(process.stdout), flushProcessOutput(process.stderr)]);
+    return process.exit(code);
+}
 export async function runOwnedUi(options) {
     const { application, settings } = options;
     let failed = false;
@@ -30,3 +41,24 @@ export async function runOwnedUi(options) {
         }
     }
 }
+async function flushProcessOutput(stream) {
+    if (stream.destroyed || !stream.writable)
+        return;
+    await new Promise(resolve => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve();
+        };
+        const timeout = setTimeout(finish, PROCESS_OUTPUT_FLUSH_TIMEOUT_MS);
+        try {
+            stream.write("", finish);
+        }
+        catch {
+            finish();
+        }
+    });
+}