@timurproko/a1 0.2.6-dev.717 → 0.2.6-dev.734

package/dist/app/session-shell/session-viewport-controller.js

@@ -306,14 +306,14 @@ export class SessionViewportController {
                 if (this.#viewport.clearSelection())
                     this.#requestRender();
             }
-            else {
+            else if (this.#viewport.hasSelection) {
                 const copySelection = this.#viewport.captureSelectedText();
-                if (copySelection !== null) {
-                    this.#viewport.clearSelection();
-                    this.#stopSelectionAutoScroll();
-                    this.#requestRender();
-                    return { data: "", consumed: true, copySelection };
-                }
+                this.#viewport.clearSelection();
+                this.#stopSelectionAutoScroll();
+                this.#requestRender();
+                return copySelection === null
+                    ? { data: "", consumed: true }
+                    : { data: "", consumed: true, copySelection };
             }
         }
         const previousPrompt = SHIFT_UP_INPUTS.has(data) || this.#editor.matchesTerminalKey(data, "alt+home");
@@ -412,12 +412,19 @@ export class SessionViewportController {
                 }
                 if (this.#dockPointerSuppressed || this.#tailPointerSuppressed)
                     return true;
+                const pendingEditorClick = this.#pendingEditorClick;
+                if (pendingEditorClick !== undefined) {
+                    if (event.column === pendingEditorClick.column && event.row === pendingEditorClick.row)
+                        return true;
+                    this.#pendingEditorClick = undefined;
+                    this.#viewport.pressSelection(pendingEditorClick.column, pendingEditorClick.row, now, { continueMultiClick: false });
+                    this.#viewport.extendSelection(event.column, event.row, now, false);
+                    this.#updateSelectionAutoScroll(event.column, event.row, hits.viewportHeight, frame.rows.length);
+                    activity = true;
+                    return true;
+                }
                 if (this.#viewport.selectionActive) {
                     this.#viewport.extendSelection(event.column, event.row, now, false);
-                    if (this.#pendingEditorClick !== undefined
-                        && (event.column !== this.#pendingEditorClick.column || event.row !== this.#pendingEditorClick.row)) {
-                        this.#pendingEditorClick = undefined;
-                    }
                     this.#updateSelectionAutoScroll(event.column, event.row, hits.viewportHeight, frame.rows.length);
                     activity = true;
                     return true;
@@ -500,11 +507,13 @@ export class SessionViewportController {
                 }
                 if (event.row >= 1 && event.row <= frame.rows.length && event.column <= frame.descriptor.width) {
                     if (editorFrame !== undefined && event.row >= editorFrame.rowStart && event.row <= editorFrame.rowEnd) {
+                        // Invariant: no-drag prompt clicks remain visually editor-owned. Distinct
+                        // motion promotes from this exact origin into complete-frame selection.
                         this.#pendingEditorClick = { column: event.column, row: event.row };
                     }
-                    // Invariant: frame selection includes transient and dock rows without changing
-                    // semantic ownership; no-drag editor presses replay on release.
-                    this.#viewport.pressSelection(event.column, event.row, now);
+                    else {
+                        this.#viewport.pressSelection(event.column, event.row, now);
+                    }
                     repaint = true;
                     return true;
                 }
@@ -525,19 +534,22 @@ export class SessionViewportController {
                     repaint = true;
                     return true;
                 }
-                if (this.#viewport.releaseSelection()) {
-                    this.#stopSelectionAutoScroll();
-                    const pendingEditorClick = this.#pendingEditorClick;
+                const pendingEditorClick = this.#pendingEditorClick;
+                if (pendingEditorClick !== undefined) {
                     this.#pendingEditorClick = undefined;
-                    if (pendingEditorClick !== undefined && this.#editorPointerFrame !== undefined) {
-                        this.#viewport.clearSelection();
+                    if (this.#editorPointerFrame !== undefined) {
                         const editorRow = pendingEditorClick.row - this.#editorPointerFrame.rowStart + 1;
                         this.#editor.handlePointer({ kind: "press", button: 0, column: pendingEditorClick.column, row: editorRow });
                         this.#editor.handlePointer({ kind: "release", button: 0, column: pendingEditorClick.column, row: editorRow });
                     }
-                    else if (this.#copyOnSelect) {
+                    forceRepaint = true;
+                    repaint = true;
+                    return true;
+                }
+                if (this.#viewport.releaseSelection()) {
+                    this.#stopSelectionAutoScroll();
+                    if (this.#copyOnSelect)
                         completedCopy = this.#viewport.captureSelectedText() ?? undefined;
-                    }
                     // Platform: restore OSC 8 links only after the held-button selection paint has
                     // ended, then overwrite any terminal-cached hover cells immediately.
                     forceRepaint = true;

package/dist/cli/dispatch.js

@@ -18,6 +18,7 @@ export function cliUsage(capabilities) {
         "remove <source>",
         "uninstall <source>",
         "list",
+        "session worktrees",
         "session link-worktree <path>",
         "session unlink-worktree",
     ]);
@@ -47,6 +48,7 @@ export function cliHelp(capabilities) {
         `  ${command} list`,
         "",
         "Session context:",
+        `  ${command} session worktrees`,
         `  ${command} session link-worktree <path>`,
         `  ${command} session unlink-worktree`,
         "",
@@ -127,12 +129,12 @@ function parseSessionContext(rest) {
             return { kind: "error", message: PRODUCT_TEXT.diagnostic("session link-worktree accepts one path.") };
         return { kind: "session-context", request: { action, path: value } };
     }
-    if (action === "unlink-worktree") {
+    if (action === "unlink-worktree" || action === "worktrees") {
         if (value !== undefined)
-            return { kind: "error", message: PRODUCT_TEXT.diagnostic("session unlink-worktree does not accept arguments.") };
+            return { kind: "error", message: PRODUCT_TEXT.diagnostic(`session ${action} does not accept arguments.`) };
         return { kind: "session-context", request: { action } };
     }
-    return { kind: "error", message: PRODUCT_TEXT.diagnostic("session accepts link-worktree <path> or unlink-worktree.") };
+    return { kind: "error", message: PRODUCT_TEXT.diagnostic("session accepts worktrees, link-worktree <path>, or unlink-worktree.") };
 }
 /**
  * Stable update is the empty form. `--develop` selects the moving development

package/dist/cli/session-context.d.ts

@@ -2,8 +2,12 @@ import { type SessionContextRequest } from "../features/launch/index.js";
 export type { SessionContextRequest } from "../features/launch/index.js";
 export interface SessionContextCommandOptions {
     readonly environment?: NodeJS.ProcessEnv;
+    readonly inspectProcess?: (pid: number) => Promise<{
+        readonly pid: number;
+        readonly startIdentity: string;
+    } | null>;
     readonly stdout?: (message: string) => void;
     readonly stderr?: (message: string) => void;
 }
-/** Apply repository presentation context only when invoked by an active Pi session shell tool. */
+/** Apply repository context only when invoked by an exact live A1 shell-tool runtime. */
 export declare function runSessionContextCommand(request: SessionContextRequest, options?: SessionContextCommandOptions): Promise<number>;

package/dist/cli/session-context.js

@@ -1,29 +1,46 @@
 import { updateSessionRepositoryContext, } from "../features/launch/index.js";
-import { PRODUCT_TEXT } from "../product-identity.js";
-/** Apply repository presentation context only when invoked by an active Pi session shell tool. */
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../product-identity.js";
+/** Apply repository context only when invoked by an exact live A1 shell-tool runtime. */
 export async function runSessionContextCommand(request, options = {}) {
     const environment = options.environment ?? process.env;
     const stdout = options.stdout ?? (message => process.stdout.write(message));
     const stderr = options.stderr ?? (message => process.stderr.write(message));
     const identity = readIdentity(environment);
     if (identity === null) {
-        stderr(`${PRODUCT_TEXT.diagnostic("session context requires an active A1 shell-tool session.")}\n`);
+        stderr(`${PRODUCT_TEXT.diagnostic("session context requires an active A1 shell-tool session runtime.")}\n`);
         return 2;
     }
     try {
-        const cwd = await updateSessionRepositoryContext(identity, request);
-        stdout(cwd === null ? "Session worktree context cleared.\n" : `Session worktree context linked: ${cwd}\n`);
+        if (options.inspectProcess === undefined)
+            throw Object.assign(new Error("native process identity inspection is unavailable"), { code: "process-inspection-unavailable" });
+        const outcome = await updateSessionRepositoryContext({ sessionId: identity.sessionId, sessionFile: identity.sessionFile }, request, { runtimeId: identity.runtimeId, inspectProcess: options.inspectProcess });
+        if (outcome.kind === "unlinked")
+            stdout("Session worktree context cleared.\n");
+        if (outcome.kind === "linked")
+            stdout(`Session worktree context linked: ${outcome.cwd}\n`);
+        if (outcome.kind === "worktrees") {
+            for (const entry of outcome.entries)
+                stdout(`${entry.status}: ${entry.cwd} (${entry.branch})\n`);
+        }
         return 0;
     }
     catch (error) {
-        stderr(`${PRODUCT_TEXT.diagnostic(`could not update session context: ${error instanceof Error ? error.message : String(error)}`)}\n`);
+        const code = errorCode(error);
+        const detail = error instanceof Error ? error.message : String(error);
+        stderr(`${PRODUCT_TEXT.diagnostic(`could not update session context${code === null ? "" : ` (${code})`}: ${detail}`)}\n`);
         return 1;
     }
 }
 function readIdentity(environment) {
     const sessionId = environment.PI_SESSION_ID;
     const sessionFile = environment.PI_SESSION_FILE;
-    if (!sessionId || !sessionFile)
+    const runtimeId = environment[PRODUCT_IDENTITY.environment.sessionRuntimeId];
+    if (!sessionId || !sessionFile || !runtimeId)
         return null;
-    return { sessionId, sessionFile };
+    return { sessionId, sessionFile, runtimeId };
+}
+function errorCode(error) {
+    if (error instanceof Error && "code" in error && typeof error.code === "string")
+        return error.code;
+    return null;
 }

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

@@ -1,15 +1,34 @@
 import type { AvailableRelease, StartupReleaseCheckOptions } from "../foundation/release/latest-release.js";
+import type { NativeProcessIdentity } from "../foundation/lifecycle/model.js";
 import type { SessionSelection } from "../foundation/lifecycle/session-selection.js";
-import type { PiEngineAdapter } from "../integrations/pi/engine/adapter.js";
+import { type PiEngineHostOptions, type PiEngineSessionRequest } from "../integrations/pi/engine/host.js";
+import { type PiSessionPresenterBackend } from "../integrations/pi/session-presenters/index.js";
 import type { PiProjectTrustPreflightPrompt } from "../integrations/pi/engine/project-trust-preflight.js";
 import type { PiSessionForkPrompt } from "../integrations/pi/engine/session-selection.js";
 import { OwnedSettingsManager } from "../ui/settings/manager.js";
 import type { OwnedUiApplicationPort, PresentationTerminalPort } from "../contracts/presentation/index.js";
+import type { AgentSettingsPort } from "../contracts/agent-engine/index.js";
+import type { OwnedUiPromptSuggestionGeneratorPort, UiAccentColor } from "../contracts/owned-ui/index.js";
 import type { ReleaseNoteCatalog } from "../features/owned-ui/release-notes.js";
+/**
+ * The session backend composition wires: the owned-UI port, the prompt-suggestion generator, and
+ * the agent settings port. `settingsPort` stays outside the owned-UI contract because its type
+ * belongs to the agent-engine contracts, which the owned-UI contract may not import.
+ */
+export interface ComposedSessionBackend extends PiSessionPresenterBackend, OwnedUiPromptSuggestionGeneratorPort {
+    settingsPort(): AgentSettingsPort | null;
+}
+/** The process-level engine host as composition drives it: sessions, the live accent, and disposal. */
+export interface ComposedEngineHost {
+    create(request: PiEngineSessionRequest): Promise<ComposedSessionBackend>;
+    setAccentColor(color: UiAccentColor): void;
+    dispose(): Promise<void>;
+}
 export interface OwnedUiCompositionOptions {
     readonly cwd?: string;
     readonly terminal?: PresentationTerminalPort;
-    readonly createPiAdapter?: () => Promise<PiEngineAdapter>;
+    /** Test seam standing in for the Pi engine host; receives the options composition resolved. */
+    readonly createEngineHost?: (options: PiEngineHostOptions) => Promise<ComposedEngineHost>;
     /** Explicit file selection retained for SDK callers. Public CLI uses sessionSelection. */
     readonly sessionPath?: string;
     readonly sessionSelection?: SessionSelection;
@@ -34,6 +53,8 @@ export interface OwnedUiCompositionOptions {
     readonly releaseNotes?: ReleaseNoteCatalog;
     /** Startup release-availability seam; defaults to the throttled registry check. */
     readonly checkForNewerRelease?: (options: StartupReleaseCheckOptions) => Promise<AvailableRelease | null>;
+    /** Exact native process inspection injected by the shipped entry; absent SDK seams do not publish claims. */
+    readonly inspectProcess?: (pid: number) => Promise<NativeProcessIdentity | null>;
 }
 export interface OwnedUiComposition {
     readonly application: OwnedUiApplicationPort;

package/dist/composition/owned-ui.js

@@ -6,47 +6,108 @@ 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 { readSessionRepositoryContext } from "../foundation/lifecycle/session-repository-context.js";
-import { applyConfiguredPiTheme, getAvailablePiThemes } from "../integrations/pi/components/upstream/theme/theme.js";
-import { createPiEngineAdapter } from "../integrations/pi/engine/adapter.js";
+import { applyConfiguredPiTheme, getAvailablePiThemes, setPiAccentColor, setPiPackageBorderProjectionEnabled } from "../integrations/pi/components/upstream/theme/theme.js";
+import { createPiEngineHost } from "../integrations/pi/engine/host.js";
+import { createPiSessionPresenters } from "../integrations/pi/session-presenters/index.js";
 import { ClipboardDiagnosticCapture } from "../app/session-shell/clipboard-diagnostics.js";
+import { createOwnedUiClipboardServices } from "../app/session-shell/clipboard-services.js";
+import { createPiKeybindingsHost } from "../integrations/pi/components/shell-shared-facade.js";
 import { OwnedUiSessionShell } from "../app/session-shell/session-shell.js";
 import { OwnedSettingsManager } from "../ui/settings/manager.js";
 import { createPiTerminalBridge } from "../integrations/pi/tui-runtime/presentation-adapter.js";
 import { createOwnedRouteHost } from "./settings-route-host.js";
 import { renderPiShellChangelogLines } from "../integrations/pi/components/shell-presenters-info.js";
 import { nativeHyperlinkStyle } from "../ui/components/spans.js";
+const SESSION_RUNTIME_REFRESH_MS = 30_000;
 export async function composeOwnedUiApplication(options = {}) {
     return (await composeOwnedUi(options)).application;
 }
 export async function composeOwnedUi(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const ownedSurfaces = options.ownedSurfaces !== "off";
-    const adapter = options.createPiAdapter
-        ? await options.createPiAdapter()
-        : await createPiEngineAdapter({
-            cwd,
-            availableThemes: () => getAvailablePiThemes().map(theme => theme.name),
-            settingsProductMode: ownedSurfaces ? "bare" : "comparison",
-            announceStartupChangelog: !ownedSurfaces,
-            ...(ownedSurfaces ? {
-                repositoryContextReader: async (sessionId, sessionFile, signal) => await readSessionRepositoryContext({ sessionId, sessionFile }, { signal }),
-            } : {}),
-            ...(options.sessionPath === undefined ? {} : { sessionPath: options.sessionPath }),
-            ...(options.sessionSelection === undefined ? {} : { sessionSelection: options.sessionSelection }),
-            ...(options.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: options.sessionForkPrompt }),
-            ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
-        });
+    const sessionRuntimeId = ownedSurfaces ? process.env[PRODUCT_IDENTITY.environment.sessionRuntimeId] : undefined;
+    const inspectSessionProcess = options.inspectProcess;
+    let sessionRuntimeIdentity = null;
+    let activeSessionIdentity = null;
+    let sessionRuntimeRefreshTimer = null;
+    let sessionRuntimeRefresh = Promise.resolve();
+    let sessionRuntimeDisposed = false;
+    const runtimeIdentity = async () => {
+        if (sessionRuntimeId === undefined || inspectSessionProcess === undefined)
+            return null;
+        sessionRuntimeIdentity ??= inspectSessionProcess(process.pid).catch(() => null);
+        return await sessionRuntimeIdentity;
+    };
+    const queueSessionRuntimeRefresh = () => {
+        if (sessionRuntimeDisposed || activeSessionIdentity === null || sessionRuntimeId === undefined || inspectSessionProcess === undefined)
+            return;
+        sessionRuntimeRefresh = sessionRuntimeRefresh.then(async () => {
+            const identity = activeSessionIdentity;
+            if (sessionRuntimeDisposed || identity === null)
+                return;
+            const owner = await runtimeIdentity();
+            if (owner === null)
+                return;
+            const { registerSessionRepositoryRuntime } = await import("../foundation/lifecycle/session-repository-context.js");
+            await registerSessionRepositoryRuntime(identity, sessionRuntimeId, owner, { inspectProcess: inspectSessionProcess });
+        }).catch(() => undefined);
+    };
+    const armSessionRuntimeRefresh = () => {
+        if (sessionRuntimeRefreshTimer !== null)
+            return;
+        sessionRuntimeRefreshTimer = setInterval(queueSessionRuntimeRefresh, SESSION_RUNTIME_REFRESH_MS);
+        sessionRuntimeRefreshTimer.unref();
+    };
     const productPaths = resolveProductPaths();
+    // Rationale: the manager reads the engine's settings port lazily, after the session exists.
+    let backend;
     const settings = options.profileId === undefined
         ? null
         : new OwnedSettingsManager({
             configDir: resolveProductPaths().configDir,
             profileId: options.profileId,
-            agentProvider: () => adapter.settingsPort(),
+            agentProvider: () => backend.settingsPort(),
             hiddenAgentSettingIds: ["fullscreenWheelScrollLines"],
             agentSettingLabelOverrides: { fullscreenCopyOnSelect: "Copy on select" },
         });
+    // Invariant: process-wide engine state has one owner. The host installs the HTTP dispatcher, applies
+    // the theme singletons, and announces startup notices once; every session is created through it.
+    const host = await (options.createEngineHost ?? (async (hostOptions) => createPiEngineHost(hostOptions)))({
+        productMode: ownedSurfaces ? "bare" : "comparison",
+        availableThemes: () => getAvailablePiThemes().map(theme => theme.name),
+        announceStartupChangelog: !ownedSurfaces,
+        theme: {
+            base: ownedSurfaces ? "dark" : "engine-configured",
+            accentColor: settings !== null && ownedSurfaces ? settings.value("accentColor") : "purple",
+            packageBorderProjection: ownedSurfaces,
+            apply: { base: applyConfiguredPiTheme, accentColor: setPiAccentColor, packageBorderProjection: setPiPackageBorderProjectionEnabled },
+        },
+        ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
+    });
+    try {
+        backend = await host.create({
+            cwd,
+            ...(ownedSurfaces ? {
+                repositoryContextReader: async (sessionId, sessionFile, signal) => {
+                    const owner = await runtimeIdentity();
+                    if (owner === null || sessionRuntimeId === undefined || inspectSessionProcess === undefined)
+                        return null;
+                    activeSessionIdentity = { sessionId, sessionFile };
+                    const { activateSessionRepositoryContext } = await import("../foundation/lifecycle/session-repository-context.js");
+                    const context = await activateSessionRepositoryContext(activeSessionIdentity, sessionRuntimeId, owner, { signal, inspectProcess: inspectSessionProcess });
+                    armSessionRuntimeRefresh();
+                    return context;
+                },
+            } : {}),
+            ...(options.sessionPath === undefined ? {} : { sessionPath: options.sessionPath }),
+            ...(options.sessionSelection === undefined ? {} : { sessionSelection: options.sessionSelection }),
+            ...(options.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: options.sessionForkPrompt }),
+        });
+    }
+    catch (error) {
+        await host.dispose();
+        throw error;
+    }
     let releaseNotes = null;
     let releaseNotesFailure;
     if (ownedSurfaces) {
@@ -67,10 +128,9 @@ export async function composeOwnedUi(options = {}) {
         : await import("../features/owned-ui/release-note-state.js").then(module => module.claimReleaseNote({
             configDir: productPaths.configDir, profileId: options.profileId, version: currentReleaseNote.version,
         }));
-    // Compatibility: bare A1 intentionally ships one visual target while its UI is being completed:
-    // dark, regardless of terminal detection or a previously stored Pi theme. The
-    // comparison profile keeps Pi's configured theme behavior and settings surface.
-    applyConfiguredPiTheme(ownedSurfaces ? "dark" : adapter.configuredTheme());
+    const unsubscribeAccent = settings === null || !ownedSurfaces
+        ? () => { }
+        : settings.onChange(current => host.setAccentColor(current.value("accentColor")));
     // Rationale: Routes open only after shell construction.
     const references = {
         changelog: async (input) => {
@@ -84,19 +144,24 @@ export async function composeOwnedUi(options = {}) {
             const { renderPiShellHotkeySections } = await import("../integrations/pi/components/shell-hotkey-sections.js");
             return { sections: width => renderPiShellHotkeySections(presentation, width) };
         },
-        session: () => import("./session-info-reference.js").then(m => m.loadSessionInfoReference(adapter)),
+        session: () => import("./session-info-reference.js").then(m => m.loadSessionInfoReference(backend)),
     };
     const routeHost = settings === null || !ownedSurfaces ? null : createOwnedRouteHost(settings, references);
     const viewportSettings = settings === null || !ownedSurfaces ? null : {
         snapshot: () => viewportSettingsSnapshot(settings),
         onChange: listener => settings.onChange(() => listener(viewportSettingsSnapshot(settings))),
     };
+    const backgroundSettings = settings === null || !ownedSurfaces ? null : {
+        snapshot: () => settings.value("backgroundStyle"),
+        // Rationale: one manager notification also recomputes an accent-derived canvas after accentColor changes.
+        onChange: listener => settings.onChange(current => listener(current.value("backgroundStyle"))),
+    };
     const diagnosticDestination = options.suggestionDiagnosticsPath ?? process.env[PRODUCT_IDENTITY.environment.suggestionDiagnostics];
     const suggestionDiagnostics = settings !== null && ownedSurfaces && diagnosticDestination?.trim()
         ? new SuggestionDiagnosticCapture({ enabled: true, destination: diagnosticDestination }) : null;
     const promptSuggestions = settings === null || !ownedSurfaces ? null : {
         ...(suggestionDiagnostics === null ? {} : { diagnostics: suggestionDiagnostics }),
-        generator: adapter,
+        generator: backend,
         enabled: () => settings.value("promptSuggestions"),
         onChange: (listener) => settings.onChange(() => listener(settings.value("promptSuggestions"))),
     };
@@ -112,12 +177,12 @@ export async function composeOwnedUi(options = {}) {
     const historyLimit = settings?.value("promptHistoryMaxItems");
     const historyProfileLocation = settings === null || !ownedSurfaces || !settings.value("promptHistoryEnabled")
         ? null
-        : resolvePromptHistoryPath(resolvePromptHistoryDataDir(), adapter.agentDir);
+        : resolvePromptHistoryPath(resolvePromptHistoryDataDir(), backend.identity.agentDir);
     const promptHistory = historyProfileLocation === null ? null : {
         limit: typeof historyLimit === "number" ? historyLimit : 100,
         store: new PromptHistoryService({
             dataDir: resolvePromptHistoryDataDir(),
-            profileRoot: adapter.agentDir,
+            profileRoot: backend.identity.agentDir,
             limit: typeof historyLimit === "number" ? historyLimit : 100,
         }),
         imageSidecar: new PromptImageSidecar(historyProfileLocation.imagesDir),
@@ -125,13 +190,18 @@ export async function composeOwnedUi(options = {}) {
     const clipboardDestination = options.clipboardDiagnosticsPath ?? process.env[PRODUCT_IDENTITY.environment.clipboardDiagnostics];
     const clipboardDiagnostics = settings !== null && ownedSurfaces && clipboardDestination?.trim()
         ? new ClipboardDiagnosticCapture(clipboardDestination) : null;
+    // Invariant: process-wide services are created once here and borrowed by every session shell. The
+    // keybinding registry is applied before any presenter is built, so none of them reads Pi's defaults.
+    const keybindings = createPiKeybindingsHost({ profile: ownedSurfaces ? "a1" : "pi", agentDir: backend.identity.agentDir });
+    const clipboardServices = ownedSurfaces ? createOwnedUiClipboardServices() : null;
     let shell;
     let releaseNoteAcknowledgement = null;
     try {
         shell = new OwnedUiSessionShell({
+            presenters: createPiSessionPresenters(backend),
             engine: {
-                backend: adapter,
-                cwd: adapter.cwd,
+                backend,
+                cwd: backend.identity.cwd,
                 ...(routeHost === null ? {} : { routeHost }),
                 ...(currentReleaseNote === null || releaseNoteClaim === null ? {} : {
                     startupRoute: {
@@ -149,6 +219,7 @@ export async function composeOwnedUi(options = {}) {
                 ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
                 ...(clipboardDiagnostics === null ? {} : { input: { onEvent: event => clipboardDiagnostics.runtime(event) } }),
                 ...(viewportSettings === null ? {} : { viewportSettings }),
+                ...(backgroundSettings === null ? {} : { backgroundSettings }),
                 ...(settings === null || !ownedSurfaces ? {} : {
                     quitOutro: { snapshot: () => quitOutroSettingsSnapshot(settings), interactive: process.stdout.isTTY === true },
                 }),
@@ -160,6 +231,7 @@ export async function composeOwnedUi(options = {}) {
             ...(promptSuggestions === null ? {} : { suggestions: promptSuggestions }),
             ...(promptImages === null ? {} : { promptImages }),
             ...(skills === null ? {} : { skills }),
+            shared: { keybindings, ...(clipboardServices === null ? {} : { clipboard: clipboardServices }) },
             ...(promptHistory === null ? {} : { history: {
                     ...promptHistory,
                     editor: await import("../integrations/pi/components/history-editor-loader.js").then(module => module.loadHistoryEditor()),
@@ -167,9 +239,12 @@ export async function composeOwnedUi(options = {}) {
         });
     }
     catch (error) {
+        unsubscribeAccent();
         await releaseNoteClaim?.release();
         clipboardDiagnostics?.dispose();
         suggestionDiagnostics?.dispose();
+        clipboardServices?.dispose();
+        await host.dispose();
         throw error;
     }
     // Rationale: pinned Pi's version check is unreachable because the owned shell never runs its
@@ -185,23 +260,23 @@ export async function composeOwnedUi(options = {}) {
             ...(settings === null || !ownedSurfaces ? {} : { settingEnabled: settings.value("updateCheck") }),
         });
         if (release !== null)
-            adapter.announceReleaseUpdate(release);
+            backend.extensions.announceReleaseUpdate(release);
     };
     const exitNoticePath = process.env[PRODUCT_IDENTITY.environment.exitNoticePath];
     // Security: tools the agent runs must never see, or rewrite, this instance's notice.
     delete process.env[PRODUCT_IDENTITY.environment.exitNoticePath];
     let exitNotice = Promise.resolve(null);
     const application = {
-        get disposed() { return adapter.disposed; },
+        get disposed() { return backend.identity.disposed; },
         start: () => {
             // Performance: the guardian notice loads beside first paint, never on the startup path.
             if (exitNoticePath)
                 exitNotice = import("../app/session-shell/exit-notice.js")
-                    .then(module => module.armExitNotice(adapter, exitNoticePath), () => null);
+                    .then(module => module.armExitNotice(backend, exitNoticePath), () => null);
             shell.start();
             void announceNewerRelease().catch(() => undefined);
         },
-        flush: () => adapter.flushEvents(),
+        flush: () => backend.session.flushEvents(),
         waitUntilStopped: () => shell.waitUntilStopped(),
         dispose: async () => {
             try {
@@ -211,9 +286,25 @@ export async function composeOwnedUi(options = {}) {
                 await releaseNoteAcknowledgement?.catch(() => undefined);
             }
             finally {
+                // Invariant: the shared spares outlive every shell and stop only after the last one is disposed.
+                clipboardServices?.dispose();
+                unsubscribeAccent();
+                sessionRuntimeDisposed = true;
+                if (sessionRuntimeRefreshTimer !== null)
+                    clearInterval(sessionRuntimeRefreshTimer);
+                sessionRuntimeRefreshTimer = null;
+                await sessionRuntimeRefresh;
+                const owner = await runtimeIdentity();
+                if (sessionRuntimeId !== undefined && owner !== null) {
+                    await import("../foundation/lifecycle/session-repository-context.js")
+                        .then(module => module.releaseSessionRepositoryRuntime(sessionRuntimeId, owner))
+                        .catch(() => undefined);
+                }
                 await releaseNoteClaim?.release();
                 suggestionDiagnostics?.dispose();
                 clipboardDiagnostics?.dispose();
+                // Invariant: the host outlives the application; disposing it cancels host-level probes last.
+                await host.dispose();
             }
         },
     };

package/dist/composition/session-info-reference.d.ts

@@ -1,4 +1,4 @@
 import type { ReferenceDocumentProvider } from "../features/owned-ui/reference-screen-app.js";
-import type { PiEngineAdapter } from "../integrations/pi/engine/adapter.js";
+import type { OwnedUiSessionBackend } from "../contracts/owned-ui/index.js";
 /** Captures one current session snapshot and adapts it to the neutral reference document. */
-export declare function loadSessionInfoReference(adapter: PiEngineAdapter): Promise<ReferenceDocumentProvider>;
+export declare function loadSessionInfoReference(backend: OwnedUiSessionBackend): Promise<ReferenceDocumentProvider>;

package/dist/composition/session-info-reference.js

@@ -1,7 +1,7 @@
 import { renderPiShellSessionInfoReferenceDocument } from "../integrations/pi/components/shell-session-info-reference.js";
 /** Captures one current session snapshot and adapts it to the neutral reference document. */
-export async function loadSessionInfoReference(adapter) {
-    const result = await adapter.executeWorkflow({ command: "session", argument: "" });
+export async function loadSessionInfoReference(backend) {
+    const result = await backend.workflows.executeWorkflow({ command: "session", argument: "" });
     if (result.outcome !== "completed")
         throw new Error(result.message);
     if (result.presentation?.kind !== "session-info")

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

@@ -1,6 +1,6 @@
 import { CHANGELOG_ROUTE, HOTKEYS_ROUTE, HOTKEYS_TITLE } from "../features/owned-ui/reference-routes.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 { piTheme, renderPiAccentPreview } from "../integrations/pi/components/upstream/theme/theme.js";
 import { faint } from "../ui/components/text.js";
 /** Declares settings and lazy document routes. */
 export function createOwnedRouteHost(settings, references) {
@@ -130,6 +130,7 @@ function pinnedTheme() {
         fg: (token, text) => piTheme().fg(token, text),
         bold: (text) => piTheme().bold(text),
         plain: (text) => text,
+        accentPreview: (color, text) => renderPiAccentPreview(color, text),
         disabled: (text) => faint(piTheme().fg("dim", text)),
         highlight: (text) => piTheme().bg("selectedBg", text),
         panel: (text) => `\u001b[48;2;55;55;55m${text}\u001b[49m`,