@timurproko/a1 0.2.7-dev.810 → 0.2.7-dev.831

package/dist/composition/owned-ui.js

@@ -6,11 +6,13 @@ import { PromptImageSidecar } from "../features/prompt-history/image-sidecar.js"
 import { resolvePromptHistoryPath } from "../features/prompt-history/paths.js";
 import { resolveLaunchProfilePaths, resolvePromptHistoryDataDir } from "../features/launch/profile-paths.js";
 import { resolveProductPaths } from "../foundation/lifecycle/paths.js";
+import { MAX_CLIPBOARD_TEXT_BYTES } from "../contracts/owned-ui/index.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 { writeSystemClipboardText } from "../app/session-shell/system-clipboard.js";
 import { createPiKeybindingsHost } from "../integrations/pi/components/shell-shared-facade.js";
 import { OwnedUiSessionPresenter, OwnedUiTerminalHost, sessionTerminalHostOptions, } from "../app/session-shell/session-shell.js";
 import { OwnedSettingsManager } from "../ui/settings/manager.js";
@@ -19,7 +21,7 @@ import { createOwnedRouteHost } from "./settings-route-host.js";
 import { renderPiShellChangelogLines } from "../integrations/pi/components/shell-presenters-info.js";
 import { nativeHyperlinkStyle } from "../ui/components/spans.js";
 import { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.js";
-import { bindResidentTabBridge, correlateResidentTabSubmission, currentBackendSessionFile, residentTabKeybindings } from "./resident-tab-bridge.js";
+import { bindResidentTabBridge, closeResidentUtilityRoute, correlateResidentTabSubmission, currentBackendSessionFile, residentRouteHostOptions, residentTabKeybindings } from "./resident-tab-bridge.js";
 import { SessionRuntimeRegistry } from "./session-runtime-registry.js";
 import { readPackageVersion, StartupReleaseNote } from "./startup-route.js";
 export { bindResidentTabBridge, correlateResidentTabSubmission } from "./resident-tab-bridge.js";
@@ -50,7 +52,7 @@ export async function composeOwnedUi(options = {}) {
             namespace: PRODUCT_IDENTITY.commandName,
             legacyConfigDir: productPaths.configDir,
             agentProvider: () => backend.settingsPort(),
-            ...(options.hideTabSettings ? { hiddenOwnedSettingIds: ["tabsAutoName"] } : {}),
+            ...(options.hideTabSettings ? { hiddenOwnedSettingIds: ["tabsAutoName", "tabsPosition", "tabBarPlusMenu"] } : {}),
             hiddenAgentSettingIds: ["fullscreenWheelScrollLines"],
             agentSettingLabelOverrides: { fullscreenCopyOnSelect: "Copy on select" },
         });
@@ -130,12 +132,15 @@ export async function composeOwnedUi(options = {}) {
             host.setAccentColor(accent);
             tabBridge?.accent(accent);
         });
-    // Rationale: every resident tab is its own process over one shared settings document, so a
-    // change saved in any tab reaches the others only by rereading that document.
-    const unwatchSharedSettings = settings === null || !ownedSurfaces || tabBridge === null
+    // Rationale: resident tabs and separate solo agents share a settings document; a live scope
+    // change saved in either reaches the others only by rereading that document.
+    const unwatchSharedSettings = settings === null || !ownedSurfaces
         ? () => { }
         : watchSharedSettings(settings);
     const unsubscribeAccent = () => { unwatchSharedSettings(); unsubscribeAccentChange(); };
+    // Invariant: the Settings search and agent prompt borrow the same resolved Pi keybindings.
+    const keybindingsHost = createPiKeybindingsHost({ profile: ownedSurfaces ? "a1" : "pi", agentDir: backend.identity.agentDir });
+    const keybindings = residentTabKeybindings(tabBridge, backend.identity.agentDir, keybindingsHost);
     // Rationale: Routes open only after shell construction.
     const references = {
         changelog: async (input) => {
@@ -151,9 +156,8 @@ export async function composeOwnedUi(options = {}) {
         },
         session: () => import("./session-info-reference.js").then(m => m.loadSessionInfoReference(backend)),
     };
-    const routeHost = settings === null || !ownedSurfaces ? null : createOwnedRouteHost(settings, references, {
-        settingsPinned: tabBridge?.tabId.startsWith("settings-") === true,
-    });
+    const routeHost = settings === null || !ownedSurfaces ? null
+        : createOwnedRouteHost(settings, references, settingsRouteOptions(tabBridge, keybindings, backend.identity.agentDir, cwd));
     const viewportSettings = settings === null || !ownedSurfaces ? null : {
         snapshot: () => viewportSettingsSnapshot(settings),
         onChange: listener => settings.onChange(() => listener(viewportSettingsSnapshot(settings))),
@@ -181,26 +185,11 @@ export async function composeOwnedUi(options = {}) {
         // Rationale: one listener covers both the A1 presentation choice and the engine skill-command toggle.
         onChange: (listener) => settings.onChange(() => listener()),
     };
-    const historyLimit = settings?.value("promptHistoryMaxItems");
-    const historyProfileLocation = settings === null || !ownedSurfaces || !settings.value("promptHistoryEnabled")
-        ? null
-        : resolvePromptHistoryPath(resolvePromptHistoryDataDir(), backend.identity.agentDir);
-    const promptHistory = historyProfileLocation === null ? null : {
-        limit: typeof historyLimit === "number" ? historyLimit : 100,
-        store: new PromptHistoryService({
-            dataDir: resolvePromptHistoryDataDir(),
-            profileRoot: backend.identity.agentDir,
-            limit: typeof historyLimit === "number" ? historyLimit : 100,
-        }),
-        imageSidecar: new PromptImageSidecar(historyProfileLocation.imagesDir),
-    };
+    const promptHistory = createPromptHistoryConfiguration(settings, backend, ownedSurfaces);
     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 keybindingsHost = createPiKeybindingsHost({ profile: ownedSurfaces ? "a1" : "pi", agentDir: backend.identity.agentDir });
-    const keybindings = residentTabKeybindings(tabBridge, backend.identity.agentDir, keybindingsHost);
+    // Invariant: process-wide services are created once here and borrowed by every session shell.
     const clipboardServices = ownedSurfaces ? createOwnedUiClipboardServices() : null;
     let createdTerminalHost;
     let terminalHost;
@@ -216,12 +205,8 @@ export async function composeOwnedUi(options = {}) {
                 ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
                 ...(tabBridge === null || tabRecovery === null ? {} : { residentTab: {
                         requestDetach: () => tabBridge.requestDetach(),
-                        closeOwnedRoute: route => {
-                            if (tabBridge.tabId.startsWith("settings-") && route === "settings")
-                                void tabBridge.requestClose();
-                        },
+                        closeOwnedRoute: route => closeResidentUtilityRoute(tabBridge, route),
                         reportStatus: status => tabBridge.status(status),
-                        stallNoticeSeconds: 300,
                         admit: input => tabRecovery.admit({ ...input, incarnation: options.tab.incarnation }),
                         dispatched: () => tabRecovery.dispatched(),
                         correlated: (submissionId, entryId) => correlateResidentTabSubmission(tabRecovery, backend, submissionId, entryId),
@@ -291,18 +276,13 @@ export async function composeOwnedUi(options = {}) {
     // Rationale: pinned Pi's version check is unreachable because the owned shell never runs its
     // InteractiveMode, so A1 checks its own channel. The result is never awaited on the startup path;
     // settings are read here because the runner resolves them only just before start.
-    const announceNewerRelease = async () => {
-        const check = options.checkForNewerRelease
-            ?? (await import("../foundation/release/latest-release.js")).checkForNewerRelease;
-        const release = await check({
-            runningVersion: releaseNote.packageVersion ?? await readPackageVersion(),
-            configDir: productPaths.configDir,
-            interactive: process.stdout.isTTY === true,
-            ...(settings === null || !ownedSurfaces ? {} : { settingEnabled: settings.value("updateCheck") }),
-        });
-        if (release !== null)
-            backend.extensions.announceReleaseUpdate(release);
-    };
+    const releaseUpdates = createStartupReleaseUpdateObservation({
+        backend,
+        configDir: productPaths.configDir,
+        mode: settings === null || !ownedSurfaces ? "auto" : settings.value("updateCheck"),
+        packageVersion: releaseNote.packageVersion, notificationVersion: options.notificationVersion,
+        checkForNewerRelease: options.checkForNewerRelease,
+    });
     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];
@@ -315,11 +295,12 @@ export async function composeOwnedUi(options = {}) {
                 exitNotice = import("../app/session-shell/exit-notice.js")
                     .then(module => module.armExitNotice(backend, exitNoticePath), () => null);
             presenter.start();
-            void announceNewerRelease().catch(() => undefined);
+            releaseUpdates.start();
         },
         flush: () => backend.session.flushEvents(),
         waitUntilStopped: () => presenter.waitUntilStopped(),
         dispose: async () => {
+            releaseUpdates.stop();
             try {
                 await terminalHost.dispose();
                 // Invariant: cleared only once the terminal is restored; a failed dispose leaves it armed.
@@ -344,6 +325,63 @@ export async function composeOwnedUi(options = {}) {
     };
     return { application, settings };
 }
+function createPromptHistoryConfiguration(settings, backend, ownedSurfaces) {
+    const limit = settings?.value("promptHistoryMaxItems") ?? 100;
+    const scope = settings?.value("promptHistoryScope") ?? "unique";
+    const enabled = settings !== null && ownedSurfaces && settings.value("promptHistoryEnabled");
+    const sessionId = enabled ? backend.identity.currentHistorySessionId() : null;
+    if (settings === null || !enabled || (scope === "unique" && sessionId === null))
+        return null;
+    const dataDir = resolvePromptHistoryDataDir();
+    const forScope = (selected, id) => {
+        if (selected === "unique" && id === null)
+            return null;
+        const location = resolvePromptHistoryPath(dataDir, backend.identity.agentDir, process.platform, selected, id ?? "");
+        return {
+            store: new PromptHistoryService({ dataDir, profileRoot: backend.identity.agentDir, limit, scope: selected, sessionId: id ?? "" }),
+            imageSidecar: new PromptImageSidecar(location.imagesDir),
+        };
+    };
+    return {
+        limit, scope,
+        ...(sessionId === null ? {} : { sessionId }),
+        forScope,
+        onScopeChange: (listener) => settings.onChange(() => listener(settings.value("promptHistoryScope"))),
+        ...forScope(scope, sessionId),
+    };
+}
+function createStartupReleaseUpdateObservation(input) {
+    const controller = new AbortController();
+    const observe = async () => {
+        const check = input.checkForNewerRelease
+            ?? (await import("../foundation/release/latest-release.js")).checkForNewerRelease;
+        const runningVersion = input.packageVersion ?? await readPackageVersion();
+        const discoveryVersion = input.mode === "notify" ? input.notificationVersion ?? runningVersion : runningVersion;
+        const release = await check({
+            runningVersion: discoveryVersion,
+            configDir: input.configDir,
+            interactive: process.stdout.isTTY === true,
+            settingMode: input.mode,
+        });
+        if (release === null || controller.signal.aborted)
+            return;
+        if (input.mode === "notify") {
+            input.backend.extensions.announceReleaseUpdate(release);
+            return;
+        }
+        if (input.mode === "auto") {
+            const installed = await import("../foundation/release/automatic-update.js")
+                .then(module => module.requestAutomaticUpdate({ release, runningVersion, signal: controller.signal }));
+            if (installed !== null && !controller.signal.aborted) {
+                input.backend.extensions.announceReleaseUpdate({ status: "installed", version: installed });
+            }
+        }
+    };
+    return {
+        start() { void observe().catch(() => undefined); },
+        stop() { controller.abort(); },
+    };
+}
 const SHARED_SETTINGS_POLL_MS = 250;
 /** Rereads the shared settings document whenever its stat changes; returns the stop. */
 export function watchSharedSettings(settings) {
@@ -359,6 +397,18 @@ export function watchSharedSettings(settings) {
     watchFile(file, { interval: SHARED_SETTINGS_POLL_MS, persistent: false }, listener);
     return () => unwatchFile(file, listener);
 }
+function settingsRouteOptions(tabBridge, keybindings, agentDir, cwd) {
+    return {
+        ...residentRouteHostOptions(tabBridge),
+        keybindings,
+        agentDir,
+        cwd,
+        copyText: text => {
+            if (Buffer.byteLength(text) <= MAX_CLIPBOARD_TEXT_BYTES)
+                void writeSystemClipboardText(text).catch(() => { });
+        },
+    };
+}
 function quitOutroSettingsSnapshot(settings) {
     return {
         enabled: settings.value("quitAnimation"),

package/dist/composition/resident-tab-bridge.d.ts

@@ -1,16 +1,25 @@
 import type { TabBridgeClient } from "../foundation/resident-tabs/bridge-client.js";
+import { type ResidentTabRoute } from "../foundation/resident-tabs/routes.js";
 import type { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.js";
 import type { PiKeybindingsHost } from "../integrations/pi/components/shell-shared-facade.js";
 import type { ComposedSessionBackend } from "./session-backend.js";
+import type { OwnedRouteHostOptions } from "./settings-route-host.js";
 /**
  * The keybindings the shells borrow. Inside a resident tab the host dispatches and labels the tab
  * shortcuts this child projects from its effective declarations, so the projection is published now
  * and again after every customization reload.
  */
 export declare function residentTabKeybindings(tabBridge: TabBridgeClient | null, agentDir: string, keybindingsHost: PiKeybindingsHost): PiKeybindingsHost;
+/**
+ * How owned screens are presented in a resident tab: a Settings or Changelog tab's screen is the tab, and the Plus menu entry opens
+ * the tab bar's own Plus Menu dialog while this tab's controlling client can show it.
+ */
+export declare function residentRouteHostOptions(tabBridge: TabBridgeClient | null): OwnedRouteHostOptions;
+/** Closes a utility tab when its own screen closes. Invariant: a utility tab's screen is the tab. */
+export declare function closeResidentUtilityRoute(tabBridge: Pick<TabBridgeClient, "tabId" | "requestClose">, route: string): void;
 export declare function bindResidentTabBridge(tabBridge: TabBridgeClient, backend: Pick<ComposedSessionBackend, "identity" | "session" | "workflows" | "generateResidentTabName">, recovery?: Pick<ResidentTabRecovery, "settled"> | null, options?: {
     readonly autoName?: boolean;
-    readonly openRoute?: (route: "settings") => void;
+    readonly openRoute?: (route: ResidentTabRoute) => void;
 }): Promise<() => void>;
 export declare function correlateResidentTabSubmission(recovery: Pick<ResidentTabRecovery, "correlated" | "settled">, backend: Pick<ComposedSessionBackend, "identity" | "session">, submissionId: string, entryId: string): Promise<void>;
 export declare function currentBackendSessionFile(backend: Pick<ComposedSessionBackend, "identity">): string | null;

package/dist/composition/resident-tab-bridge.js

@@ -1,3 +1,4 @@
+import { residentUtilityRoute } from "../foundation/resident-tabs/routes.js";
 import { deriveResidentTabStatus } from "../features/resident-tab/status-deriver.js";
 import { projectResidentTabShortcuts } from "../features/resident-tab/shortcut-projection.js";
 import { readShortcutBindingsFile } from "../features/resident-tab/shortcut-bindings-file.js";
@@ -16,6 +17,26 @@ export function residentTabKeybindings(tabBridge, agentDir, keybindingsHost) {
     publish();
     return { ...keybindingsHost, reload: () => { keybindingsHost.reload(); publish(); } };
 }
+/**
+ * How owned screens are presented in a resident tab: a Settings or Changelog tab's screen is the tab, and the Plus menu entry opens
+ * the tab bar's own Plus Menu dialog while this tab's controlling client can show it.
+ */
+export function residentRouteHostOptions(tabBridge) {
+    return {
+        ...(tabBridge === null ? {} : { tabRoute: residentUtilityRoute(tabBridge.tabId) }),
+        configurePlusMenu: () => {
+            if (tabBridge === null || !tabBridge.available || tabBridge.captureAttachment() === null)
+                return false;
+            void tabBridge.requestAction("configure-plus");
+            return true;
+        },
+    };
+}
+/** Closes a utility tab when its own screen closes. Invariant: a utility tab's screen is the tab. */
+export function closeResidentUtilityRoute(tabBridge, route) {
+    if (residentUtilityRoute(tabBridge.tabId) === route)
+        void tabBridge.requestClose();
+}
 export async function bindResidentTabBridge(tabBridge, backend, recovery = null, options = {}) {
     await tabBridge.start().catch(() => false);
     tabBridge.status("starting");

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

@@ -1,6 +1,7 @@
 import type { ReferenceDocumentProvider } from "../features/owned-ui/reference-screen-app.js";
 import type { OwnedSettingsManager } from "../ui/settings/manager.js";
 import type { UiRouteHost, UiRouteInput } from "../ui/apps/contracts.js";
+import type { PiKeybindingsHost } from "../integrations/pi/components/shell-shared-facade.js";
 /** Styled document rows for one content width. */
 export type OwnedReferenceRows = NonNullable<ReferenceDocumentProvider["rows"]>;
 /** Documents supplied by composition so the route host never reads shell data itself. */
@@ -11,8 +12,17 @@ export interface OwnedReferenceProviders {
 }
 /** How the settings route is presented. */
 export interface OwnedRouteHostOptions {
-    /** The resident Settings tab: the screen is the tab, so it offers no screen-level close. */
-    readonly settingsPinned?: boolean;
+    /**
+     * The route whose screen is this resident utility tab. That screen is the tab, so it offers no
+     * screen-level close: neither Esc nor one Ctrl+C dismisses it, and it shows no close hint.
+     */
+    readonly tabRoute?: string | null;
+    /** Opens the tab bar's own Plus Menu dialog; false when no tab bar can show it. */
+    readonly configurePlusMenu?: () => boolean;
+    readonly keybindings?: PiKeybindingsHost;
+    readonly agentDir?: string;
+    readonly cwd?: string;
+    readonly copyText?: (text: string) => void;
 }
 /** Declares settings and lazy document routes. */
 export declare function createOwnedRouteHost(settings: OwnedSettingsManager, references?: OwnedReferenceProviders, options?: OwnedRouteHostOptions): UiRouteHost;

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

@@ -11,13 +11,14 @@ export function createOwnedRouteHost(settings, references, options = {}) {
             if (!routes.has(route))
                 return null;
             if (route === SETTINGS_ROUTE) {
-                return deferredSurface(SETTINGS_APP_ID, "settings", () => loadSettingsSurface(settings, options.settingsPinned === true));
+                return deferredSurface(SETTINGS_APP_ID, "settings", () => loadSettingsSurface(settings, options));
             }
             const changelog = route === CHANGELOG_ROUTE;
             const session = route === "session";
             const title = session ? "Session Info" : changelog ? input ? "What's New" : "Changelog" : HOTKEYS_TITLE;
             const document = session ? references.session() : changelog ? references.changelog(input) : references.hotkeys();
-            return deferredSurface(route, title, () => loadReferenceSurface(settings, route, route, title, document));
+            const pinned = options.tabRoute === route;
+            return deferredSurface(route, title, () => loadReferenceSurface(settings, route, title, document, pinned));
         },
     };
 }
@@ -61,12 +62,27 @@ function deferredSurface(id, label, load) {
         onExitRequested: listener => { onExit = listener; },
     };
 }
-async function loadSettingsSurface(settings, pinned) {
-    const { SettingsApp } = await import("../features/owned-ui/settings-app.js");
-    // Invariant: a pinned Settings tab closes as a tab; neither Esc nor one Ctrl+C dismisses its screen.
-    return hostApp(SETTINGS_APP_ID, SETTINGS_ROUTE, () => new SettingsApp(settings, { pinned }), !pinned);
+async function loadSettingsSurface(settings, options) {
+    const [{ SettingsApp }, { createSettingsSearchInputFactory }] = await Promise.all([
+        import("../features/owned-ui/settings-app.js"),
+        import("./settings-search-input.js"),
+    ]);
+    const pinned = options.tabRoute === SETTINGS_ROUTE;
+    const searchInputFactory = createSettingsSearchInputFactory({
+        ...(options.keybindings === undefined ? {} : { keybindings: options.keybindings }),
+        ...(options.agentDir === undefined ? {} : { agentDir: options.agentDir }),
+        ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    });
+    // Invariant: a pinned Settings tab closes as a tab; neither Esc nor one unclaimed Ctrl+C dismisses its screen.
+    return hostApp(SETTINGS_APP_ID, SETTINGS_ROUTE, () => new SettingsApp(settings, {
+        pinned,
+        searchInputFactory,
+        configurePlusMenu: options.configurePlusMenu ?? null,
+        ...(options.copyText === undefined ? {} : { copyText: options.copyText }),
+    }), !pinned, true);
 }
-async function loadReferenceSurface(settings, id, route, title, document) {
+async function loadReferenceSurface(settings, route, title, document, pinned) {
+    const id = route;
     // Rationale: the app module and the document load together, so a document that fails
     // to render is reported by the placeholder rather than by a screen that never fills.
     const [{ ReferenceScreenApp }, content] = await Promise.all([import("../features/owned-ui/reference-screen-app.js"), document]);
@@ -79,9 +95,10 @@ async function loadReferenceSurface(settings, id, route, title, document) {
             scrollbarStyle: settings.value("scrollbarStyle"),
             scrollbarSpeed: settings.value("scrollbarSpeed"),
         }),
-    }));
+        pinned,
+    }), !pinned);
 }
-async function hostApp(id, route, create, closeOnInterrupt = true) {
+async function hostApp(id, route, create, closeOnInterrupt = true, appInputBeforeInterrupt = false) {
     const [{ UiAppHost }, { UiAppRegistry }] = await Promise.all([
         import("../ui/apps/host.js"),
         import("../ui/apps/registry.js"),
@@ -96,6 +113,7 @@ async function hostApp(id, route, create, closeOnInterrupt = true) {
     const host = new UiAppHost({
         registry,
         closeOnInterrupt,
+        appInputBeforeInterrupt,
         theme: pinnedTheme(),
         surface: {
             size: () => size,

package/dist/composition/settings-search-input.d.ts

@@ -0,0 +1,9 @@
+import type { SettingsSearchInputFactory } from "../features/owned-ui/settings-search-input.js";
+import { type PiKeybindingsHost } from "../integrations/pi/components/shell-shared-facade.js";
+export interface SettingsSearchInputFactoryOptions {
+    readonly keybindings?: PiKeybindingsHost;
+    readonly agentDir?: string;
+    readonly cwd?: string;
+}
+/** Builds Settings search from the same configurable owned editor used by the agent prompt. */
+export declare function createSettingsSearchInputFactory(options?: SettingsSearchInputFactoryOptions): SettingsSearchInputFactory;

package/dist/composition/settings-search-input.js

@@ -0,0 +1,58 @@
+import { editorInsertedText } from "../integrations/pi/components/owned-editor-ux.js";
+import { createPiShellEditor } from "../integrations/pi/components/shell-editor-autocomplete.js";
+import { piShellTruncateToWidth, piShellVisibleWidth, } from "../integrations/pi/components/shell-shared-facade.js";
+import { backgroundSgrSpan } from "../ui/components/spans.js";
+import { caretCell } from "../ui/components/line-input.js";
+import { PromptInput } from "../ui/components/prompt-input.js";
+/** Builds Settings search from the same configurable owned editor used by the agent prompt. */
+export function createSettingsSearchInputFactory(options = {}) {
+    return {
+        isTextInput: data => {
+            const text = editorInsertedText(data);
+            return text !== undefined && /[^\p{Cc}]/u.test(text);
+        },
+        create: surface => createSettingsSearchInput(surface, options),
+    };
+}
+function createSettingsSearchInput(surface, options) {
+    let columns = 80;
+    const editor = createPiShellEditor({
+        keybindingProfile: "a1",
+        inputCapabilities: {
+            singleLine: true,
+            paste: false,
+            autocomplete: false,
+            placeholder: "Search settings",
+        },
+        ...(options.keybindings === undefined ? {} : { keybindings: options.keybindings }),
+        ...(options.agentDir === undefined ? {} : { agentDir: options.agentDir }),
+        cwd: options.cwd ?? process.cwd(),
+        getColumns: () => columns,
+        getRows: surface.getRows,
+        requestRender: surface.requestRender,
+        onSubmit: () => { },
+        onCopyText: text => surface.copyText(text),
+        paintEditorSelection: (line, from, to, atomic) => backgroundSgrSpan(line, from, to, atomic ? "\u001b[7m" : "\u001b[27m\u001b[48;2;38;79;120m", atomic ? "\u001b[27m" : "\u001b[49m", piShellVisibleWidth),
+        promptPresentation: {
+            input: new PromptInput({ fg: (token, text) => surface.theme.fg(token, text) }, {
+                measure: piShellVisibleWidth,
+                truncate: piShellTruncateToWidth,
+            }),
+            styleSuggestion: text => surface.theme.fg("dim", text),
+            styleSuggestionCaret: caretCell,
+        },
+    });
+    editor.setFocused?.(true);
+    return {
+        render(width) {
+            columns = width;
+            return editor.render(width);
+        },
+        handleInput: (data) => editor.handleInput?.(data),
+        handlePointer: (event) => editor.handlePointer(event),
+        getText: () => editor.getText(),
+        hasSelection: () => editor.hasSelection(),
+        ownsPointer: () => editor.ownsPointer(),
+        setFocused: (focused) => editor.setFocused?.(focused),
+    };
+}

package/dist/contracts/owned-ui/session-backend.d.ts

@@ -37,6 +37,8 @@ export interface OwnedUiSessionIdentityPort {
     readonly sessionBindingGeneration: number;
     readonly disposed: boolean;
     currentSessionFile(): string | null;
+    /** The durable conversation identity; unlike sessionId it survives agent process restart. */
+    currentHistorySessionId(): string | null;
     currentSessionResumeMetadata(): OwnedUiSessionResumeMetadata | null;
 }
 /** The session lifecycle, its view, its event stream, and command admission. */

package/dist/contracts/owned-ui/session-workflows.d.ts

@@ -337,9 +337,13 @@ export interface OwnedUiVisualExtensionSupport {
     readonly renderCallbacks: typeof OWNED_UI_EXTENSION_RENDER_CALLBACKS;
     readonly diagnostic: string;
 }
-/** A newer release found by the startup check. */
-export interface OwnedUiReleaseUpdate {
+/** A newer release found by the startup check, or one installed for the next restart. */
+export type OwnedUiReleaseUpdate = {
+    readonly status?: "available";
     readonly version: string;
     readonly command: string;
     readonly changelogUrl: string | null;
-}
+} | {
+    readonly status: "installed";
+    readonly version: string;
+};

package/dist/contracts/presentation/index.d.ts

@@ -14,6 +14,17 @@ export declare const DIALOG_BACK_SHORTCUT_HINT: Readonly<{
     key: string;
     action: string;
 }>;
+/** Global inset inherited by every semantic row inside an A1-owned dialog frame. */
+export declare const DIALOG_CONTENT_PADDING_X = 1;
+export interface DialogFrameGeometry {
+    readonly frameWidth: number;
+    readonly contentPaddingX: number;
+    readonly contentWidth: number;
+}
+/** Shared full-width-rule/content-width geometry for string and component dialog renderers. */
+export declare function dialogFrameGeometry(width: number): DialogFrameGeometry;
+/** Injects a semantic row into the frame's global content inset. */
+export declare function insetDialogContent(row: string, geometry: DialogFrameGeometry): string;
 export interface ShortcutHintRoles {
     key(label: string): string;
     action(name: string): string;

package/dist/contracts/presentation/index.js

@@ -2,6 +2,18 @@
 export const DIALOG_CLOSE_SHORTCUT_HINT = Object.freeze({ key: "esc", action: "close" });
 /** Canonical return guidance for a nested step within a dialog surface. */
 export const DIALOG_BACK_SHORTCUT_HINT = Object.freeze({ key: "esc", action: "back" });
+/** Global inset inherited by every semantic row inside an A1-owned dialog frame. */
+export const DIALOG_CONTENT_PADDING_X = 1;
+/** Shared full-width-rule/content-width geometry for string and component dialog renderers. */
+export function dialogFrameGeometry(width) {
+    const frameWidth = Math.max(0, width);
+    const contentPaddingX = Math.min(DIALOG_CONTENT_PADDING_X, frameWidth);
+    return { frameWidth, contentPaddingX, contentWidth: frameWidth - contentPaddingX };
+}
+/** Injects a semantic row into the frame's global content inset. */
+export function insetDialogContent(row, geometry) {
+    return `${" ".repeat(geometry.contentPaddingX)}${row}`;
+}
 const SHORTCUT_KEY_NAMES = Object.freeze({
     alt: "Alt", backspace: "Backspace", cmd: "Cmd", ctrl: "Ctrl", delete: "Delete", down: "Down", end: "End",
     enter: "Enter", esc: "Esc", escape: "Escape", home: "Home", insert: "Insert", left: "Left", meta: "Meta",

package/dist/features/launch/development-launch.js

@@ -19,6 +19,11 @@ export function resolveDevelopmentLaunchEnvironment(canonicalPackageRoot, releas
         ? join(developmentRoot, "config")
         : join(checkoutRoot, "config");
     const dataDir = resolve(source[PRODUCT_IDENTITY.environment.dataDir] ?? join(developmentRoot, "data"));
+    // Rationale: solo processes keep isolated control state but must see the same history
+    // after selecting Shared; use a checkout-wide root across rebuilds unless overridden.
+    const historyDataDir = resolve(source[PRODUCT_IDENTITY.environment.developmentHistoryDataDir]
+        ?? source[PRODUCT_IDENTITY.environment.dataDir]
+        ?? (selectedDevelopmentRoot ? dataDir : join(checkoutRoot, "data")));
     return {
         checkoutId,
         releaseId,
@@ -27,6 +32,7 @@ export function resolveDevelopmentLaunchEnvironment(canonicalPackageRoot, releas
         environment: {
             ...source,
             [PRODUCT_IDENTITY.environment.developmentInstanceId]: instanceId,
+            [PRODUCT_IDENTITY.environment.developmentHistoryDataDir]: historyDataDir,
             [PRODUCT_IDENTITY.environment.configDir]: resolve(source[PRODUCT_IDENTITY.environment.configDir] ?? persistentConfigDir),
             [PRODUCT_IDENTITY.environment.dataDir]: dataDir,
             [PRODUCT_IDENTITY.environment.runtimeDir]: resolve(source[PRODUCT_IDENTITY.environment.runtimeDir] ?? join(developmentRoot, "runtime")),

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

@@ -18,6 +18,10 @@ export function resolveLaunchProfilePaths(options = {}) {
 export function resolvePromptHistoryDataDir(options = {}) {
     const environment = options.environment ?? process.env;
     const platform = options.platform ?? process.platform;
+    const developmentHistoryDataDir = environment[PRODUCT_IDENTITY.environment.developmentHistoryDataDir];
+    if (developmentHistoryDataDir !== undefined) {
+        return resolveProductPaths({ ...environment, [PRODUCT_IDENTITY.environment.dataDir]: developmentHistoryDataDir }, platform).dataDir;
+    }
     if (environment[PRODUCT_IDENTITY.environment.dataDir] !== undefined) {
         return resolveProductPaths(environment, platform).dataDir;
     }

package/dist/features/owned-ui/plus-menu-dialog.d.ts

@@ -0,0 +1,22 @@
+import type { UiTheme } from "../../ui/components/index.js";
+/** The A1 setting holding the tab kinds the strip's `+` offers. */
+export declare const PLUS_MENU_SETTING_ID = "tabBarPlusMenu";
+/** One tab kind the plus menu can offer. */
+export interface PlusMenuKind {
+    readonly key: string;
+    readonly label: string;
+}
+/**
+ * The plus-menu dialog: every tab kind with `●` when `+` offers it and `○` when not, filtered by typed
+ * text. It owns only its filter and the row in hand; the enabled record and its saving stay with the
+ * Settings screen that opened it.
+ */
+export declare class PlusMenuDialog {
+    #private;
+    constructor(kinds: readonly PlusMenuKind[]);
+    /** The kinds the filter keeps, in kind order. */
+    shown(): readonly PlusMenuKind[];
+    /** Handles one key by its resolved name; `toggle` flips a kind. Returns whether the dialog closed. */
+    handle(name: string, data: string, toggle: (key: string) => void): "close" | "handled";
+    lines(enabled: Readonly<Record<string, boolean | string>>, width: number, theme: UiTheme): readonly string[];
+}