@timurproko/a1 0.2.6-dev.736 → 0.2.7-dev.1221

package/dist/composition/owned-ui.js

@@ -1,4 +1,3 @@
-import { readFile } from "node:fs/promises";
 import { SuggestionDiagnosticCapture } from "../features/prompt-suggestions/diagnostics.js";
 import { PRODUCT_IDENTITY } from "../product-identity.js";
 import { PromptHistoryService } from "../features/prompt-history/service.js";
@@ -6,93 +5,62 @@ 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 { 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";
 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;
+import { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.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";
+import { createOwnedSettingsManager, watchSharedSettings } from "./owned-settings.js";
+export { bindResidentTabBridge, correlateResidentTabSubmission } from "./resident-tab-bridge.js";
+export function residentStartupPresentation(resident, fallbackNotice) {
+    if (resident)
+        return { startup: { quiet: true } };
+    return fallbackNotice === undefined ? {} : { startup: { notices: [{ kind: "warning", message: fallbackNotice }] } };
+}
 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 sessionRuntimeId = ownedSurfaces ? process.env[PRODUCT_IDENTITY.environment.sessionRuntimeId] : undefined;
-    const inspectSessionProcess = options.inspectProcess;
-    let sessionRuntimeIdentity = null;
-    // Invariant: one entry per agent of this runtime; each agent holds its own claim, and the runtime's exit releases all.
-    const activeSessionIdentities = new Map();
-    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 || activeSessionIdentities.size === 0 || sessionRuntimeId === undefined || inspectSessionProcess === undefined)
-            return;
-        sessionRuntimeRefresh = sessionRuntimeRefresh.then(async () => {
-            if (sessionRuntimeDisposed)
-                return;
-            const owner = await runtimeIdentity();
-            if (owner === null)
-                return;
-            const { registerSessionRepositoryRuntime } = await import("../foundation/lifecycle/session-repository-context.js");
-            for (const [agentId, identity] of activeSessionIdentities) {
-                if (sessionRuntimeDisposed)
-                    return;
-                await registerSessionRepositoryRuntime(identity, sessionRuntimeId, owner, {
-                    inspectProcess: inspectSessionProcess,
-                    ...(agentId === undefined ? {} : { agentId }),
-                }).catch(() => undefined);
-            }
-        }).catch(() => undefined);
-    };
-    /** The repository context reader for one agent; undefined names the primary agent, the only one composed today. */
-    const repositoryContextReaderFor = (agentId) => async (sessionId, sessionFile, signal) => {
-        const owner = await runtimeIdentity();
-        if (owner === null || sessionRuntimeId === undefined || inspectSessionProcess === undefined)
-            return null;
-        const identity = { sessionId, sessionFile };
-        activeSessionIdentities.set(agentId, identity);
-        const { activateSessionRepositoryContext } = await import("../foundation/lifecycle/session-repository-context.js");
-        const context = await activateSessionRepositoryContext(identity, sessionRuntimeId, owner, {
-            signal,
-            inspectProcess: inspectSessionProcess,
-            ...(agentId === undefined ? {} : { agentId }),
-        });
-        armSessionRuntimeRefresh();
-        return context;
-    };
-    const armSessionRuntimeRefresh = () => {
-        if (sessionRuntimeRefreshTimer !== null)
-            return;
-        sessionRuntimeRefreshTimer = setInterval(queueSessionRuntimeRefresh, SESSION_RUNTIME_REFRESH_MS);
-        sessionRuntimeRefreshTimer.unref();
-    };
+    const sessionRuntimes = new SessionRuntimeRegistry({
+        runtimeId: ownedSurfaces ? process.env[PRODUCT_IDENTITY.environment.sessionRuntimeId] : undefined,
+        inspectProcess: options.inspectProcess,
+    });
     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,
+        : createOwnedSettingsManager({
             profileId: options.profileId,
             agentProvider: () => backend.settingsPort(),
-            hiddenAgentSettingIds: ["fullscreenWheelScrollLines"],
-            agentSettingLabelOverrides: { fullscreenCopyOnSelect: "Copy on select" },
+            ...(options.hideTabSettings ? { hideTabSettings: true } : {}),
         });
+    const tabBridge = options.tab?.bridge ?? null;
+    if (tabBridge !== null)
+        await tabBridge.start().catch(() => false);
+    const projectTrustPrompt = options.projectTrustPrompt === undefined ? undefined : async (request) => {
+        tabBridge?.status("needs-input", false, 1, 0);
+        try {
+            return await options.projectTrustPrompt(request);
+        }
+        finally {
+            tabBridge?.status("starting");
+        }
+    };
     // 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)))({
@@ -105,50 +73,73 @@ export async function composeOwnedUi(options = {}) {
             packageBorderProjection: ownedSurfaces,
             apply: { base: applyConfiguredPiTheme, accentColor: setPiAccentColor, packageBorderProjection: setPiPackageBorderProjectionEnabled },
         },
-        ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
+        ...(projectTrustPrompt === undefined ? {} : { projectTrustPrompt }),
     });
+    const sessionForkPrompt = options.sessionForkPrompt === undefined ? undefined : async (request) => {
+        tabBridge?.status("needs-input", false, 1, 0);
+        try {
+            return await options.sessionForkPrompt(request);
+        }
+        finally {
+            tabBridge?.status("starting");
+        }
+    };
     try {
         backend = await host.create({
             cwd,
-            ...(ownedSurfaces ? { repositoryContextReader: repositoryContextReaderFor(undefined) } : {}),
+            ...(ownedSurfaces ? { repositoryContextReader: sessionRuntimes.readerFor(undefined) } : {}),
             ...(options.sessionPath === undefined ? {} : { sessionPath: options.sessionPath }),
             ...(options.sessionSelection === undefined ? {} : { sessionSelection: options.sessionSelection }),
-            ...(options.sessionForkPrompt === undefined ? {} : { sessionForkPrompt: options.sessionForkPrompt }),
+            ...(sessionForkPrompt === undefined ? {} : { sessionForkPrompt }),
         });
     }
     catch (error) {
         await host.dispose();
         throw error;
     }
-    let releaseNotes = null;
-    let releaseNotesFailure;
-    if (ownedSurfaces) {
-        try {
-            releaseNotes = options.releaseNotes
-                ?? await import("../features/owned-ui/release-notes.js").then(module => module.readPackagedReleaseNotes());
-        }
-        catch (error) {
-            releaseNotesFailure = error;
-        }
-    }
-    const packageVersion = ownedSurfaces
-        ? options.packageVersion ?? await readPackageVersion()
-        : null;
-    const currentReleaseNote = packageVersion === null ? null : releaseNotes?.current(packageVersion) ?? null;
-    const releaseNoteClaim = currentReleaseNote === null || options.profileId === undefined
-        ? null
-        : await import("../features/owned-ui/release-note-state.js").then(module => module.claimReleaseNote({
-            configDir: productPaths.configDir, profileId: options.profileId, version: currentReleaseNote.version,
-        }));
-    const unsubscribeAccent = settings === null || !ownedSurfaces
+    let recoveryDegraded = false;
+    let presentRecoveryDegraded = (_degraded) => { };
+    const tabRecovery = options.tab === undefined ? null : new ResidentTabRecovery(options.tab.dataDir, {
+        onDegraded: degraded => {
+            recoveryDegraded = degraded;
+            options.tab.bridge.degraded(degraded);
+            presentRecoveryDegraded(degraded);
+        },
+    });
+    const recoveredTabInput = await tabRecovery?.initialize(currentBackendSessionFile(backend), backend.identity.sessionId);
+    if (tabBridge !== null && settings !== null && ownedSurfaces)
+        tabBridge.accent(settings.value("accentColor"));
+    let removeControllerBoundaryInput = () => { };
+    let unsubscribeTabBridge = () => { };
+    const releaseNote = await StartupReleaseNote.load({
+        ownedSurfaces,
+        configDir: productPaths.configDir,
+        ...(options.releaseNotes === undefined ? {} : { releaseNotes: options.releaseNotes }),
+        ...(options.packageVersion === undefined ? {} : { packageVersion: options.packageVersion }),
+        ...(options.profileId === undefined ? {} : { profileId: options.profileId }),
+    });
+    const unsubscribeAccentChange = settings === null || !ownedSurfaces
         ? () => { }
-        : settings.onChange(current => host.setAccentColor(current.value("accentColor")));
+        : settings.onChange(current => {
+            const accent = current.value("accentColor");
+            host.setAccentColor(accent);
+            tabBridge?.accent(accent);
+        });
+    // 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) => {
-            if (input?.document === undefined && releaseNotesFailure !== undefined)
-                throw releaseNotesFailure;
-            const markdown = input?.document ?? releaseNotes?.completeMarkdown ?? "No A1 release notes found.";
+            if (input?.document === undefined && releaseNote.failure !== undefined)
+                throw releaseNote.failure;
+            const markdown = input?.document ?? releaseNote.catalog?.completeMarkdown ?? "No A1 release notes found.";
             return { rows: width => renderPiShellChangelogLines(markdown, width).map(row => nativeHyperlinkStyle(row)) };
         },
         hotkeys: async () => {
@@ -158,7 +149,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);
+    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))),
@@ -186,30 +178,15 @@ 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 keybindings = createPiKeybindingsHost({ profile: ownedSurfaces ? "a1" : "pi", agentDir: backend.identity.agentDir });
+    // Invariant: process-wide services are created once here and borrowed by every session shell.
     const clipboardServices = ownedSurfaces ? createOwnedUiClipboardServices() : null;
     let createdTerminalHost;
     let terminalHost;
     let presenter;
-    let releaseNoteAcknowledgement = null;
     try {
         const presenterOptions = {
             presenters: createPiSessionPresenters(backend),
@@ -217,24 +194,27 @@ export async function composeOwnedUi(options = {}) {
                 backend,
                 cwd: backend.identity.cwd,
                 ...(routeHost === null ? {} : { routeHost }),
-                ...(currentReleaseNote === null || releaseNoteClaim === null ? {} : {
-                    startupRoute: {
-                        route: "changelog",
-                        input: { document: currentReleaseNote.markdown },
-                        onClosed: () => {
-                            releaseNoteAcknowledgement ??= releaseNoteClaim.acknowledge();
-                            return releaseNoteAcknowledgement;
-                        },
-                    },
-                }),
+                ...(releaseNote.startupRoute === undefined ? {} : { startupRoute: releaseNote.startupRoute }),
                 ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
+                ...(tabBridge === null || tabRecovery === null ? {} : { residentTab: {
+                        requestDetach: () => tabBridge.requestDetach(),
+                        closeOwnedRoute: route => closeResidentUtilityRoute(tabBridge, route),
+                        reportStatus: status => tabBridge.status(status),
+                        admit: input => tabRecovery.admit({ ...input, incarnation: options.tab.incarnation }),
+                        dispatched: () => tabRecovery.dispatched(),
+                        correlated: (submissionId, entryId) => correlateResidentTabSubmission(tabRecovery, backend, submissionId, entryId),
+                        checkpoint: text => tabRecovery.checkpoint(text),
+                        gracefulStop: sessionFile => tabRecovery.gracefulStop(sessionFile),
+                        ...(recoveredTabInput === undefined ? {} : { recovered: recoveredTabInput }),
+                    } }),
             },
             presentation: {
                 ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
+                ...residentStartupPresentation(tabBridge !== null, options.residentFallbackNotice),
                 ...(clipboardDiagnostics === null ? {} : { input: { onEvent: event => clipboardDiagnostics.runtime(event) } }),
                 ...(viewportSettings === null ? {} : { viewportSettings }),
                 ...(backgroundSettings === null ? {} : { backgroundSettings }),
-                ...(settings === null || !ownedSurfaces ? {} : {
+                ...(settings === null || !ownedSurfaces || tabBridge !== null ? {} : {
                     quitOutro: { snapshot: () => quitOutroSettingsSnapshot(settings), interactive: process.stdout.isTTY === true },
                 }),
             },
@@ -254,13 +234,32 @@ export async function composeOwnedUi(options = {}) {
         // Invariant: one terminal host owns the process terminal; the session presenter reaches it only through
         // the host and paints once attached.
         terminalHost = createdTerminalHost = new OwnedUiTerminalHost(sessionTerminalHostOptions(presenterOptions));
+        if (tabBridge !== null) {
+            removeControllerBoundaryInput = terminalHost.runtime.addPreInputListener(data => ({
+                data: tabBridge.consumeControllerBoundaryInput(data),
+            }));
+        }
         presenter = new OwnedUiSessionPresenter(terminalHost, presenterOptions);
+        presentRecoveryDegraded = degraded => {
+            if (!degraded)
+                return;
+            presenter.root.appendWorkflowStatus("draft recovery degraded");
+            terminalHost.runtime.requestRender();
+        };
+        if (recoveryDegraded)
+            presentRecoveryDegraded(true);
         terminalHost.attach(presenter);
+        if (tabBridge !== null) {
+            unsubscribeTabBridge = await bindResidentTabBridge(tabBridge, backend, tabRecovery, {
+                autoName: settings?.value("tabsAutoName") ?? true,
+                openRoute: route => presenter.openOwnedRoute(route),
+            });
+        }
     }
     catch (error) {
         await createdTerminalHost?.dispose().catch(() => undefined);
         unsubscribeAccent();
-        await releaseNoteClaim?.release();
+        await releaseNote.releaseClaim();
         clipboardDiagnostics?.dispose();
         suggestionDiagnostics?.dispose();
         clipboardServices?.dispose();
@@ -270,18 +269,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: 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];
@@ -294,35 +288,29 @@ 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.
                 (await exitNotice)?.clear();
-                await releaseNoteAcknowledgement?.catch(() => undefined);
+                await releaseNote.settleAcknowledgement();
             }
             finally {
                 // Invariant: the shared spares outlive every shell and stop only after the last one is disposed.
                 clipboardServices?.dispose();
+                removeControllerBoundaryInput();
                 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();
+                await sessionRuntimes.dispose();
+                await releaseNote.releaseClaim();
                 suggestionDiagnostics?.dispose();
                 clipboardDiagnostics?.dispose();
+                unsubscribeTabBridge();
+                tabBridge?.close();
                 // Invariant: the host outlives the application; disposing it cancels host-level probes last.
                 await host.dispose();
             }
@@ -330,12 +318,75 @@ export async function composeOwnedUi(options = {}) {
     };
     return { application, settings };
 }
-async function readPackageVersion() {
-    const manifest = JSON.parse(await readFile(new URL("../../package.json", import.meta.url), "utf8"));
-    const version = manifest?.version;
-    if (typeof version !== "string")
-        throw new Error("A1 package version is unavailable");
-    return version;
+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(); },
+    };
+}
+export { watchSharedSettings } from "./owned-settings.js";
+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 {
@@ -344,6 +395,7 @@ function quitOutroSettingsSnapshot(settings) {
 }
 function viewportSettingsSnapshot(settings) {
     return {
+        timeFormat: settings.value("timeFormat"),
         scrollbarAppearance: settings.value("scrollbarAppearance"),
         scrollbarStyle: settings.value("scrollbarStyle"),
         scrollbarSpeed: settings.value("scrollbarSpeed"),

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

@@ -0,0 +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: 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;