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

package/README.md

@@ -145,7 +145,13 @@ Stuck on `0.2.2` and `a1 update` fails? Run the installer once, then use `a1 upd
 npm x -y -- @timurproko/a1-install
 ```
 
-A1 shows an `Update Available` notice at most once a day and never installs anything by itself. Turn it off in Settings (`Update check`) or with `A1_SKIP_VERSION_CHECK=1`.
+The **Update** setting controls the at-most-daily startup check:
+
+- **Auto** (default) silently installs a verified update for the running channel, then shows `Update installed · Restart to update`.
+- **Notify** keeps the `Update Available` notice and leaves installation manual.
+- **No** performs no startup update check; updates remain available through the commands above.
+
+`A1_SKIP_VERSION_CHECK=1` also disables the startup check. Manual stable, development, and exact-version update commands remain available in every mode.
 
 <p align="center"><picture><source media="(prefers-color-scheme: dark)" srcset="docs/assets/readme/separator-dark.svg"><img src="docs/assets/readme/separator.svg" alt="" width="280"></picture></p>
 

package/bin/automatic-update.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+import("../dist/foundation/release/automatic-update.js").then(async ({ runAutomaticUpdateWorker }) => {
+  process.exitCode = await runAutomaticUpdateWorker(process.argv.slice(2));
+}).catch(() => {
+  process.exitCode = 1;
+});

package/bin/ui.js

@@ -78,6 +78,7 @@ Promise.resolve().then(async () => {
         cwd: process.cwd(),
         profileId,
         ownedSurfaces,
+        notificationVersion: launchContext.updateVersion,
         ...(hidesTabSettings(launchContext) ? { hideTabSettings: true } : {}),
         ...(processInspector === null ? {} : { inspectProcess: pid => processInspector.observe(pid) }),
         projectTrustPrompt: createConsoleProjectTrustPrompt({ presentation: profile === "a1" ? "bare" : "comparison" }),

package/dist/app/session-shell/session-shell-root.d.ts

@@ -116,6 +116,13 @@ export interface OwnedUiShellPresentationOptions {
 /** Persistent prompt history: its store, its bound, the editor that recalls it, and the image sidecar. */
 export interface OwnedUiShellHistoryOptions {
     readonly store: import("../../contracts/owned-ui/index.js").PromptHistoryPort;
+    /** When present, session replacement selects a new store and sidecar, not the old session's recall. */
+    readonly sessionId?: string;
+    readonly scope?: "unique" | "shared";
+    readonly forSession?: (sessionId: string) => Pick<OwnedUiShellHistoryOptions, "store" | "imageSidecar">;
+    /** A live scope change selects the matching store for this session without copying records. */
+    readonly forScope?: (scope: "unique" | "shared", sessionId: string | null) => Pick<OwnedUiShellHistoryOptions, "store" | "imageSidecar"> | null;
+    readonly onScopeChange?: (listener: (scope: "unique" | "shared") => void) => () => void;
     readonly limit: number;
     readonly editor: import("../../integrations/pi/components/index.js").HistoryEditorConstructor;
     /** Optional per-profile filesystem sidecar for image chip payloads. When present, submit
@@ -191,7 +198,7 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
         readonly requestHyperlinkCleanup?: (rows?: readonly number[]) => void;
         readonly enableDockInputReuse?: boolean;
         readonly persistentHistory?: boolean;
-        readonly hideSettingsCommand?: boolean;
+        readonly hideUtilityTabCommands?: boolean;
         readonly historyEditor?: import("../../integrations/pi/components/index.js").HistoryEditorConstructor;
         readonly onSubmit: (text: string) => void;
         readonly onPasteRejected?: (error: unknown) => void;

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

@@ -27,6 +27,12 @@ import { writeSystemClipboardText, } from "./system-clipboard.js";
 import { OwnedUiSessionShellRoot, shellResourceEntries, } from "./session-shell-root.js";
 // Invariant: a disposed shell leaves the engine a host that holds no reference back to it.
 const DETACHED_WORKFLOW_INTERACTION = { prompt: async () => null, notify() { } };
+/** Resident Agents refuse the commands their tab bar serves instead, naming where they live. */
+const RESIDENT_UTILITY_TAB_REFUSALS = Object.freeze({
+    settings: "Settings is available from the global Settings tab.",
+    changelog: "The changelog opens as its own tab from the command palette (Alt+/).",
+    name: "Rename the session by renaming its tab (F2).",
+});
 export { OwnedUiSessionShellRoot, } from "./session-shell-root.js";
 export { OwnedUiTerminalHost, sessionTerminalHostOptions } from "./shell-host.js";
 export { formatSessionResumeCommand, quoteCommandArgument } from "./session-lifecycle.js";
@@ -55,7 +61,7 @@ export class OwnedUiSessionPresenter {
     #unsubscribeSkills;
     #installedCommandSignature = "";
     #promptHistory = null;
-    #promptHistoryImageSidecar;
+    #historyBinding;
     #extensionBridge;
     #stop = new SessionStopLatch();
     #dialogs;
@@ -169,7 +175,7 @@ export class OwnedUiSessionPresenter {
                 }),
                 enableDockInputReuse: inputPresentation?.viewportReuse !== false,
                 footerSessionName: options.engine.residentTab === undefined,
-                hideSettingsCommand: options.engine.residentTab !== undefined,
+                hideUtilityTabCommands: options.engine.residentTab !== undefined,
                 persistentHistory: this.#customViewport && promptHistory !== undefined,
                 ...(promptHistory === undefined ? {} : { historyEditor: promptHistory.editor }),
                 onSubmit: text => { void this.submit(text).catch(() => this.#submission.reportError()); },
@@ -316,9 +322,10 @@ export class OwnedUiSessionPresenter {
                 });
             };
             applyViewportSettings();
-            this.#unsubscribeSettings = this.#customViewport && viewportSettings
-                ? viewportSettings.onChange(settings => this.root.setViewportConfig(settings))
-                : () => { };
+            const unsubscribeViewport = this.#customViewport && viewportSettings ? viewportSettings.onChange(settings => this.root.setViewportConfig(settings)) : () => { };
+            const unsubscribeHistoryScope = this.#customViewport && promptHistory?.onScopeChange?.(scope => this.#rebindTranscript(scope));
+            this.#unsubscribeSettings = () => { unsubscribeViewport(); if (unsubscribeHistoryScope)
+                unsubscribeHistoryScope(); };
             constructed.push(this.#unsubscribeSettings);
             this.#unbindSessionSettings = bindSessionSettings(this.backend.settings, initialPiSettings, {
                 terminal: this.#terminal,
@@ -331,8 +338,7 @@ export class OwnedUiSessionPresenter {
             }, { customViewport: this.#customViewport });
             constructed.push(this.#unbindSessionSettings);
             if (this.#customViewport && promptHistory !== undefined) {
-                this.#promptHistoryImageSidecar = promptHistory.imageSidecar;
-                const sidecar = this.#promptHistoryImageSidecar;
+                this.#historyBinding = { options: promptHistory, scope: promptHistory.scope ?? "unique", sessionId: promptHistory.sessionId, imageSidecar: promptHistory.imageSidecar };
                 this.#promptHistory = new PromptHistoryController({
                     editor: this.root.editor,
                     store: promptHistory.store,
@@ -340,7 +346,7 @@ export class OwnedUiSessionPresenter {
                     fallback: this.view().transcript.flatMap(block => block.kind === "user" ? [block.text] : []),
                     active: () => this.root.usesDefaultInputSurface(),
                     render: () => this.#terminal.requestRender(),
-                    rehydrate: value => this.root.rehydrateHistoryText(value, id => sidecar?.readAttachment(id) ?? null),
+                    rehydrate: value => this.root.rehydrateHistoryText(value, id => this.#historyBinding?.imageSidecar?.readAttachment(id) ?? null),
                 });
                 constructed.push(() => { void this.#promptHistory?.close().catch(() => false); });
             }
@@ -1154,7 +1160,7 @@ export class OwnedUiSessionPresenter {
             residentTab: this.#resident,
             cwd,
             promptHistory: () => this.#promptHistory,
-            imageSidecar: () => this.#promptHistoryImageSidecar,
+            imageSidecar: () => this.#historyBinding?.imageSidecar,
             disposed: () => this.#disposed,
             correlation: prefix => this.#correlation(prefix),
             lifecycle: () => this.view().lifecycle,
@@ -1183,13 +1189,57 @@ export class OwnedUiSessionPresenter {
             this.#resident,
         ]);
     }
-    // Invariant: delivery recovery invalidates callbacks, not same-session local recall or its draft.
-    #rebindTranscript() {
-        if (this.#sessionBindingGeneration === this.backend.identity.sessionBindingGeneration)
+    // Invariant: delivery recovery does not replace a store; conversation or live scope changes can.
+    #rebindTranscript(scope) {
+        const replaced = this.#sessionBindingGeneration !== this.backend.identity.sessionBindingGeneration;
+        if (!replaced && scope === undefined)
             return;
-        this.#sessionBindingGeneration = this.backend.identity.sessionBindingGeneration;
-        this.root.resetTranscript();
-        this.#promptHistory?.reset(this.view().transcript.flatMap(block => block.kind === "user" ? [block.text] : []));
+        if (replaced) {
+            this.#sessionBindingGeneration = this.backend.identity.sessionBindingGeneration;
+            this.root.resetTranscript();
+        }
+        const binding = this.#historyBinding;
+        if (binding?.options.forSession !== undefined || binding?.options.forScope !== undefined) {
+            const sessionId = this.backend.identity.currentHistorySessionId();
+            const selectedScope = scope ?? binding.scope;
+            if (selectedScope !== binding.scope || sessionId !== binding.sessionId) {
+                if (!replaced)
+                    this.root.editor.recall?.restoreDraft?.();
+                const previous = this.#promptHistory;
+                this.#promptHistory = null;
+                binding.imageSidecar = undefined;
+                binding.scope = selectedScope;
+                binding.sessionId = sessionId ?? undefined;
+                void previous?.close().catch(() => false);
+                const destination = binding.options.forScope !== undefined
+                    ? binding.options.forScope(selectedScope, sessionId)
+                    : sessionId === null ? null : binding.options.forSession(sessionId);
+                if (destination !== null) {
+                    binding.imageSidecar = destination.imageSidecar;
+                    const controller = new PromptHistoryController({
+                        editor: this.root.editor,
+                        store: destination.store,
+                        limit: binding.options.limit,
+                        fallback: replaced ? this.view().transcript.flatMap(block => block.kind === "user" ? [block.text] : []) : [],
+                        active: () => this.root.usesDefaultInputSurface(),
+                        render: () => this.#terminal.requestRender(),
+                        rehydrate: value => this.root.rehydrateHistoryText(value, id => this.#historyBinding?.imageSidecar?.readAttachment(id) ?? null),
+                    });
+                    this.#promptHistory = controller;
+                    if (this.#started)
+                        controller.start();
+                }
+                else {
+                    // Security: missing identity must not reopen Shared or retain another session's recall.
+                    const fallback = replaced ? this.view().transcript.flatMap(block => block.kind === "user" ? [block.text] : []).reverse() : [];
+                    this.root.editor.recall?.reset();
+                    this.root.editor.recall?.replace(fallback);
+                }
+                return;
+            }
+        }
+        if (replaced)
+            this.#promptHistory?.reset(this.view().transcript.flatMap(block => block.kind === "user" ? [block.text] : []));
     }
     #syncTerminalProgress(view) {
         if (!this.#terminal.running)
@@ -1254,9 +1304,9 @@ export class OwnedUiSessionPresenter {
         const separator = body.search(/\s/);
         const name = separator < 0 ? body : body.slice(0, separator);
         const argument = separator < 0 ? "" : body.slice(separator + 1).trimStart();
-        if (name === "settings" && this.#resident.active) {
-            return rejected("Settings is available from the global Settings tab.");
-        }
+        const utilityTab = this.#resident.active ? RESIDENT_UTILITY_TAB_REFUSALS[name] : undefined;
+        if (utilityTab !== undefined)
+            return rejected(utilityTab);
         if (this.#dialogs.claimsRoute(name))
             return this.#dialogs.openRoute(name);
         if (this.#isWorkflowRoute(name))

package/dist/app/session-shell/transcript-document.js

@@ -260,7 +260,7 @@ export class TranscriptDocument {
                 : createPiShellChangelog(diagnostic.message).render(width)));
         rows.push(...diagnostics
             .filter(diagnostic => diagnostic.code !== "engine-startup" && diagnostic.code !== "project-trust"
-            && diagnostic.code !== "release-update"
+            && diagnostic.code !== "release-update" && diagnostic.code !== "release-update-installed"
             && diagnostic.code !== "package-updates" && diagnostic.code !== "changelog-collapsed"
             && diagnostic.code !== "changelog-expanded")
             .slice(-3)

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

@@ -20,17 +20,11 @@ export interface OwnedUiCompositionOptions {
     readonly sessionPath?: string;
     readonly sessionSelection?: SessionSelection;
     readonly sessionForkPrompt?: PiSessionForkPrompt;
-    /**
-     * A1 profile whose settings this session reads and writes. Omitted keeps the
-     * session settings-free, which is what the pinned comparison paths use.
-     */
+    /** A1 settings profile; comparison paths omit it. */
     readonly profileId?: string;
     /** Hide resident-only tab controls for the explicit direct single-agent launch. */
     readonly hideTabSettings?: boolean;
-    /**
-     * Whether A1's product-specific surfaces are reachable. Comparison profiles
-     * use the same composition with those surfaces withheld.
-     */
+    /** `off` withholds A1-specific surfaces from comparison profiles. */
     readonly ownedSurfaces?: "on" | "off";
     readonly projectTrustPrompt?: PiProjectTrustPreflightPrompt;
     /** Explicit local diagnostic destination; ignored by comparison/settings-free compositions. */
@@ -39,18 +33,16 @@ export interface OwnedUiCompositionOptions {
     readonly clipboardDiagnosticsPath?: string;
     /** Deterministic release-note seams for composition tests. */
     readonly packageVersion?: string;
+    readonly notificationVersion?: string | undefined;
     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>;
-    /** Private credentials were consumed by the entry before composition or extensions loaded. */
     readonly tab?: {
         readonly bridge: TabBridgeClient;
         readonly dataDir: string;
         readonly incarnation: number;
     };
-    /** One prompt-adjacent notice explaining why a resident launch fell back. */
     readonly residentFallbackNotice?: string;
 }
 export interface OwnedUiComposition {

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", "tabsPosition"] } : {}),
+            ...(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,10 +205,7 @@ 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),
                         admit: input => tabRecovery.admit({ ...input, incarnation: options.tab.incarnation }),
                         dispatched: () => tabRecovery.dispatched(),
@@ -290,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];
@@ -314,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.
@@ -343,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) {
@@ -358,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;