@timurproko/a1 0.2.7-dev.1236 → 0.2.7-dev.1239

package/dist/composition/owned-settings.js

@@ -14,7 +14,7 @@ export function createOwnedSettingsManager(options) {
         legacyConfigDir: productPaths.configDir,
         ...(options.agent === undefined ? {} : { agent: options.agent }),
         ...(options.agentProvider === undefined ? {} : { agentProvider: options.agentProvider }),
-        ...(options.hideTabSettings ? { hiddenOwnedSettingIds: ["tabsAutoName", "tabsPosition", "tabBarPlusMenu"] } : {}),
+        ...(options.hideTabSettings ? { hiddenOwnedSettingIds: ["tabsAutoName", "tabsPosition", "tabBarPlusMenu", "tabBarRightItems"] } : {}),
         hiddenAgentSettingIds: ["fullscreenWheelScrollLines"],
         agentSettingLabelOverrides: { fullscreenCopyOnSelect: "Copy on select" },
     });

package/dist/composition/release-update-observation.js

@@ -4,13 +4,41 @@ class ReleaseUpdateObservation {
     #controller = new AbortController();
     #timer;
     #announced = null;
+    #installedAnnounced = false;
     #eligible;
     #cadence = null;
     #nextDelay = null;
     #started = false;
     #running = false;
     #refresh = false;
+    #stopActiveReleaseObservation = () => { };
     constructor(input) { this.#input = input; this.#eligible = input.mode === "auto"; }
+    #announce(status, version) {
+        const key = `${status}:${version}`;
+        if (key === this.#announced || (status === "installed" && this.#installedAnnounced) || this.#controller.signal.aborted)
+            return;
+        this.#announced = key;
+        if (status === "installed") {
+            this.#installedAnnounced = true;
+            this.#eligible = false;
+            if (this.#timer !== undefined)
+                clearTimeout(this.#timer);
+        }
+        this.#input.backend.extensions.announceReleaseUpdate({ status, version });
+    }
+    async #startActiveReleaseObservation() {
+        const runningVersion = this.#input.packageVersion ?? await this.#input.readPackageVersion();
+        if (this.#controller.signal.aborted)
+            return;
+        const module = await import("../foundation/release/automatic-update.js");
+        if (this.#controller.signal.aborted)
+            return;
+        this.#stopActiveReleaseObservation = module.observeNewerActiveRelease({
+            runningVersion,
+            signal: this.#controller.signal,
+            onNewer: version => this.#announce("installed", version),
+        });
+    }
     async #observe() {
         // Performance: registry modules and their locks stay outside the first-frame startup graph.
         const releases = await import("../foundation/release/latest-release.js");
@@ -41,22 +69,18 @@ class ReleaseUpdateObservation {
         }
         if (input.mode !== "auto")
             return;
-        const announce = (status, version) => {
-            const actual = input.clientVersion?.();
-            const key = `${status}:${version}`;
-            if (key === this.#announced || this.#controller.signal.aborted
-                || status !== "blocked-cleared" && actual && !releases.isNewerRelease(version, actual))
-                return;
-            this.#announced = key;
-            input.backend.extensions.announceReleaseUpdate({ status, version });
-        };
         const installed = await import("../foundation/release/automatic-update.js")
             .then(module => module.requestAutomaticUpdate({
             release, runningVersion, signal: this.#controller.signal,
-            onActivationBlocked: version => announce(version === null ? "blocked-cleared" : "blocked", version ?? release.version),
+            onActivationBlocked: version => {
+                const clientVersion = input.clientVersion?.();
+                if (version !== null && clientVersion && !releases.isNewerRelease(version, clientVersion))
+                    return;
+                this.#announce(version === null ? "blocked-cleared" : "blocked", version ?? release.version);
+            },
         }));
         if (installed !== null)
-            announce("installed", installed);
+            this.#announce("installed", installed);
     }
     async #run() {
         if (this.#running) {
@@ -83,13 +107,18 @@ class ReleaseUpdateObservation {
         if (this.#started || this.#controller.signal.aborted)
             return;
         this.#started = true;
+        void this.#startActiveReleaseObservation().catch(() => undefined);
         void this.#run();
     }
-    stop() { this.#controller.abort(); if (this.#timer !== undefined)
-        clearTimeout(this.#timer); }
+    stop() {
+        this.#controller.abort();
+        this.#stopActiveReleaseObservation();
+        if (this.#timer !== undefined)
+            clearTimeout(this.#timer);
+    }
     clientChanged() {
         this.#announced = null;
-        if (!this.#started || this.#controller.signal.aborted || this.#input.mode === "no")
+        if (!this.#started || this.#controller.signal.aborted || this.#installedAnnounced || this.#input.mode === "no")
             return;
         if (this.#timer !== undefined)
             clearTimeout(this.#timer);

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

@@ -292,7 +292,7 @@ export type OwnedUiJsonValue = null | boolean | number | string | readonly Owned
 /** The layer that installs a setting's live effect. */
 export type OwnedUiSettingOwner = "agent" | "shell" | "terminal" | "startup" | "shutdown" | "installation";
 /** Engine settings whose live effect an owner may bind. */
-export type OwnedUiSessionSettingKey = "autoCompact" | "showImages" | "imageWidthCells" | "autoResizeImages" | "blockImages" | "enableSkillCommands" | "steeringMode" | "followUpMode" | "transport" | "httpIdleTimeoutMs" | "cacheWarmingMode" | "modelThinkingLevels" | "theme" | "hideThinkingBlock" | "mermaidRenderingMode" | "showCacheMissNotices" | "collapseChangelog" | "enableInstallTelemetry" | "quietStartup" | "defaultProjectTrust" | "sessionShareDestination" | "doubleEscapeAction" | "treeFilterMode" | "showHardwareCursor" | "editorPaddingX" | "outputPad" | "autocompleteMaxVisible" | "clearOnShrink" | "showTerminalProgress" | "tuiMode" | "fullscreenExitOutput" | "fullscreenScrollbar" | "fullscreenCopyOnSelect" | "fullscreenWheelScrollLines" | "warnings";
+export type OwnedUiSessionSettingKey = "autoCompact" | "showImages" | "imageWidthCells" | "autoResizeImages" | "blockImages" | "enableSkillCommands" | "steeringMode" | "followUpMode" | "transport" | "httpIdleTimeoutMs" | "cacheWarmingMode" | "defaultModel" | "modelThinkingLevels" | "theme" | "hideThinkingBlock" | "mermaidRenderingMode" | "showCacheMissNotices" | "collapseChangelog" | "enableInstallTelemetry" | "quietStartup" | "defaultProjectTrust" | "sessionShareDestination" | "doubleEscapeAction" | "treeFilterMode" | "showHardwareCursor" | "editorPaddingX" | "outputPad" | "autocompleteMaxVisible" | "clearOnShrink" | "showTerminalProgress" | "tuiMode" | "fullscreenExitOutput" | "fullscreenScrollbar" | "fullscreenCopyOnSelect" | "fullscreenWheelScrollLines" | "warnings";
 export interface OwnedUiSettingEffectHandler {
     /** Install one value in the active owner. Handlers must be idempotent and reversible. */
     apply(value: OwnedUiJsonValue): void | Promise<void>;

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

@@ -6,17 +6,23 @@ 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 {
+/** Presentation copy for a searchable ordered flag multi-select dialog. */
+export interface FlagToggleDialogPresentation {
+    readonly title: string;
+    readonly description: string;
+    readonly empty: string;
+}
+/** Owns only filtering and selection; the Settings screen owns enabled state and persistence. */
+export declare class FlagToggleDialog {
     #private;
-    constructor(kinds: readonly PlusMenuKind[]);
+    constructor(kinds: readonly PlusMenuKind[], presentation: FlagToggleDialogPresentation);
     /** 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[];
 }
+/** The tab bar's specialized flag dialog, retained as the public Plus Menu surface. */
+export declare class PlusMenuDialog extends FlagToggleDialog {
+    constructor(kinds: readonly PlusMenuKind[]);
+}

package/dist/features/owned-ui/plus-menu-dialog.js

@@ -1,8 +1,11 @@
 import { LineInput, handleLineInputKey, padToWidth, renderInputRow, renderShortcutHintsWithClose, truncateToWidth, } from "../../ui/components/index.js";
 /** The A1 setting holding the tab kinds the strip's `+` offers. */
 export const PLUS_MENU_SETTING_ID = "tabBarPlusMenu";
-const TITLE = "Plus Menu";
-const DESCRIPTION = "Choose what the + button in the tab bar can add.";
+const PLUS_MENU_PRESENTATION = Object.freeze({
+    title: "Plus Menu",
+    description: "Choose what the + button in the tab bar can add.",
+    empty: "No tabs match",
+});
 const HINTS = [
     { key: "Type", action: "search" },
     { key: "↑↓", action: "navigate" },
@@ -10,17 +13,15 @@ const HINTS = [
     { key: "esc", action: "close" },
 ];
 const PADDING_X = 2;
-/**
- * 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 class PlusMenuDialog {
+/** Owns only filtering and selection; the Settings screen owns enabled state and persistence. */
+export class FlagToggleDialog {
     #kinds;
+    #presentation;
     #filter = new LineInput("");
     #index = 0;
-    constructor(kinds) {
+    constructor(kinds, presentation) {
         this.#kinds = kinds;
+        this.#presentation = presentation;
     }
     /** The kinds the filter keeps, in kind order. */
     shown() {
@@ -60,7 +61,7 @@ export class PlusMenuDialog {
         const shown = this.shown();
         const index = Math.min(this.#index, Math.max(0, shown.length - 1));
         const rows = shown.length === 0
-            ? [row(theme.fg("dim", "No tabs match"))]
+            ? [row(theme.fg("dim", this.#presentation.empty))]
             : shown.map((kind, position) => {
                 const selected = position === index;
                 const cursor = selected ? "→ " : "  ";
@@ -70,8 +71,8 @@ export class PlusMenuDialog {
             });
         return [
             blank,
-            row(theme.bold(theme.fg("accent", TITLE))),
-            row(theme.fg("dim", DESCRIPTION)),
+            row(theme.bold(theme.fg("accent", this.#presentation.title))),
+            row(theme.fg("dim", this.#presentation.description)),
             blank,
             ...renderInputRow(this.#filter, contentWidth, { ruled: false, promptGlyph: "> ", theme }).lines.map(line => row(line)),
             blank,
@@ -82,3 +83,7 @@ export class PlusMenuDialog {
         ];
     }
 }
+/** The tab bar's specialized flag dialog, retained as the public Plus Menu surface. */
+export class PlusMenuDialog extends FlagToggleDialog {
+    constructor(kinds) { super(kinds, PLUS_MENU_PRESENTATION); }
+}

package/dist/features/owned-ui/settings-app.js

@@ -1,6 +1,6 @@
 import { DIALOG_BACK_SHORTCUT_HINT, DIALOG_CLOSE_SHORTCUT_HINT } from "../../contracts/presentation/index.js";
 import { GLOBAL_SCOPE, LineInput, PLAIN_THEME, ShortcutRegistry, assertNoShortcutConflicts, blockJumpTarget, configureDialogChoiceCapacity, configureDialogTextRows, configureDialogWidth, numericValues, RAIL_COLUMNS, renderCenteredDialogOverlay, renderDialogPanel, renderSteppedDialogPanel, renderEmptyState, renderGroupHeader, renderListRow, renderNote, renderShortcutHintsWithClose, menuRowAt, regionAt, renderValueMenu, withScrollbarRail, stepperEnds, steppedValue, truncateToWidth, valueColumnFor, valueMenuFrame, blockRowSpan, displayWidth, formatLocalTime, handleLineInputKey, humanizeLabel, humanizeTitle, indexOfKey, layoutList, moveSelection, rowKey, scrollForSelection, scrollForTrackPage, scrollbarGeometry, scrollbarPresentation, ScrollbarRails, scrollbarWheelRows, selectableIndexes, } from "../../ui/components/index.js";
-import { PLUS_MENU_SETTING_ID, PlusMenuDialog } from "./plus-menu-dialog.js";
+import { FlagToggleDialog, PLUS_MENU_SETTING_ID, PlusMenuDialog } from "./plus-menu-dialog.js";
 import { SETTINGS_APP_ID } from "./settings-route.js";
 export { SETTINGS_APP_ID, SETTINGS_ROUTE } from "./settings-route.js";
 const SCOPE = SETTINGS_APP_ID;
@@ -22,6 +22,7 @@ const SCROLL_LINGER_MS = 900;
 const SCROLL_LINGER_REPAINT_MS = 925;
 /** What a structured value offers instead of printing itself. */
 const CONFIGURE = "configure";
+const TAB_BAR_RIGHT_ITEMS_SETTING_ID = "tabBarRightItems";
 export const SETTINGS_SHORTCUTS = new ShortcutRegistry();
 SETTINGS_SHORTCUTS.declare({ key: "edit", scope: SCOPE, description: "Search settings", section: "Change", hint: { keys: "Type", does: "search" } }, "edit-filter");
 SETTINGS_SHORTCUTS.declare({ key: "up", scope: SCOPE, description: "Previous setting", section: "Navigate", hint: { keys: "↑↓", does: "navigate" } }, "move-up");
@@ -281,7 +282,7 @@ export class SettingsApp {
                 return { consumed: false };
             case "activate": {
                 const row = rows[selected];
-                if (row?.kind === "element" && row.value.structured)
+                if (row?.kind === "element" && (row.value.structured || isDefaultModelEntry(row.value)))
                     this.#openStructured(row.value);
                 else if (row?.kind === "element" && typeof this.#shownValue(row.value) === "number")
                     this.#cycle(rows, selected, 1);
@@ -469,7 +470,7 @@ export class SettingsApp {
         if (row === undefined || row.kind !== "element")
             return;
         const entry = row.value;
-        if (entry.structured) {
+        if (entry.structured || isDefaultModelEntry(entry)) {
             this.#openStructured(entry);
             return;
         }
@@ -508,9 +509,13 @@ export class SettingsApp {
     }
     // Rationale: a structured setting opens as its own flag list rather than a value menu.
     #openStructured(entry) {
+        const modelDialog = entry.backend === "agent" && entry.id === "modelThinkingLevels"
+            ? "thinking"
+            : isDefaultModelEntry(entry) ? "default" : null;
         // Invariant: the flags come from the declaration, not from the stored value: an unset
-        // flag still has a row, showing the default the source would apply.
-        if (entry.flags.length === 0)
+        // flag still has a row, showing the default the source would apply. The default-model
+        // selector may open empty so it can truthfully report that no authenticated models exist.
+        if (entry.flags.length === 0 && modelDialog !== "default")
             return;
         // Rationale: beside a tab bar, its own Plus Menu dialog configures `+`, so both ways look the same.
         if (entry.backend === "a1" && entry.id === PLUS_MENU_SETTING_ID && this.#options.configurePlusMenu?.() === true)
@@ -530,17 +535,24 @@ export class SettingsApp {
         this.#hoverKey = null;
         this.#hoverRegion = "label";
         this.#rails.clear();
-        const modelDialog = entry.backend === "agent" && entry.id === "modelThinkingLevels";
+        const currentDefault = typeof entry.rawValue === "string" ? entry.rawValue : null;
         this.#structured = {
             entry,
             flags: entry.flags.map(flag => flag.key),
             modelDialog,
-            plusMenu: entry.backend === "a1" && entry.id === PLUS_MENU_SETTING_ID ? new PlusMenuDialog(entry.flags) : null,
-            filter: modelDialog ? new LineInput("") : null,
+            flagDialog: entry.backend !== "a1" ? null
+                : entry.id === PLUS_MENU_SETTING_ID ? new PlusMenuDialog(entry.flags)
+                    : entry.id === TAB_BAR_RIGHT_ITEMS_SETTING_ID ? new FlagToggleDialog(entry.flags, {
+                        title: "Tab Bar Right Side",
+                        description: "Choose what the right side of the tab bar shows.",
+                        empty: "No items match",
+                    }) : null,
+            filter: modelDialog === null ? null : new LineInput(""),
             step: "model",
             modelKey: null,
             modelIndex: 0,
-            index: 0,
+            index: modelDialog === "default" ? Math.max(0, entry.flags.findIndex(flag => flag.key === currentDefault)) : 0,
+            error: null,
             record,
         };
     }
@@ -548,10 +560,10 @@ export class SettingsApp {
         const open = this.#structured;
         if (open === null)
             return { consumed: false };
-        if (open.modelDialog)
+        if (open.modelDialog !== null)
             return this.#modelDialogKey(open, data);
-        if (open.plusMenu !== null) {
-            const outcome = open.plusMenu.handle(KEYS[data] ?? data, data, key => this.#toggleFlag(open.flags.indexOf(key)));
+        if (open.flagDialog !== null) {
+            const outcome = open.flagDialog.handle(KEYS[data] ?? data, data, key => this.#toggleFlag(open.flags.indexOf(key)));
             if (outcome === "close")
                 this.#structured = null;
             return { consumed: true };
@@ -578,6 +590,38 @@ export class SettingsApp {
     }
     #modelDialogKey(open, data) {
         const key = KEYS[data] ?? data;
+        if (open.modelDialog === "default") {
+            const flags = this.#filteredModelFlags(open);
+            const action = MODEL_SHORTCUTS.resolve(key, MODEL_SCOPE) ?? "edit-filter";
+            if (action === "close") {
+                this.#structured = null;
+                return { consumed: true };
+            }
+            if (action === "previous" || action === "next") {
+                open.index = Math.min(Math.max(0, flags.length - 1), Math.max(0, open.index + (action === "next" ? 1 : -1)));
+                return { consumed: true };
+            }
+            if (action === "select") {
+                const selected = flags[open.index];
+                if (selected === undefined)
+                    return { consumed: true, render: false };
+                open.error = null;
+                this.#structured = null;
+                void this.#session.change(open.entry.backend, open.entry.id, selected.key).then(outcome => {
+                    const failure = changeFailure(outcome);
+                    if (failure !== null) {
+                        open.error = `Could not save: ${failure}`;
+                        this.#structured = open;
+                    }
+                });
+                return { consumed: true };
+            }
+            if (open.filter === null)
+                return { consumed: true, render: false };
+            handleLineInputKey(open.filter, data);
+            open.index = 0;
+            return { consumed: true };
+        }
         if (open.step === "model") {
             const flags = this.#filteredModelFlags(open);
             const action = MODEL_SHORTCUTS.resolve(key, MODEL_SCOPE) ?? "edit-filter";
@@ -640,6 +684,7 @@ export class SettingsApp {
         const needle = open.filter?.value.trim().toLowerCase() ?? "";
         return open.entry.flags.filter(flag => needle.length === 0
             || (flag.label ?? humanizeLabel(flag.key)).toLowerCase().includes(needle)
+            || flag.description.toLowerCase().includes(needle)
             || flag.key.toLowerCase().includes(needle));
     }
     #modelLevelOptions(open, selected) {
@@ -897,7 +942,8 @@ export class SettingsApp {
             // Rationale: a section named by the search is what the reader asked for, so it arrives
             // whole rather than narrowed to the entries that happen to repeat its name.
             const named = needle.length > 0 && section.title.toLowerCase().includes(needle);
-            const entries = named ? section.entries : section.entries.filter(matches);
+            const matching = named ? section.entries : section.entries.filter(matches);
+            const entries = orderDefaultModelBeforeThinking(matching, section.id);
             if (needle.length > 0 && entries.length === 0)
                 continue;
             if (rows.length > 0)
@@ -947,7 +993,7 @@ export class SettingsApp {
     #viewRow(entry) {
         const key = `${entry.backend}:${entry.id}`;
         const shown = this.#shownValue(entry);
-        const value = entry.structured
+        const value = entry.structured || isDefaultModelEntry(entry)
             ? CONFIGURE
             : shown === null
                 ? describeRaw(entry.rawValue)
@@ -988,10 +1034,10 @@ export class SettingsApp {
         return renderValueMenu(lines, state, frame, theme);
     }
     #dialogLines(open, width, height, theme) {
-        if (open.modelDialog)
+        if (open.modelDialog !== null)
             return this.#modelDialogLines(open, width, height, theme);
-        if (open.plusMenu !== null)
-            return open.plusMenu.lines(open.record, width, theme);
+        if (open.flagDialog !== null)
+            return open.flagDialog.lines(open.record, width, theme);
         const rows = open.flags.map(key => {
             const declared = open.entry.flags.find(flag => flag.key === key);
             return {
@@ -1005,6 +1051,23 @@ export class SettingsApp {
         return renderDialogPanel({ title: labelOf(open.entry), rows: visible.rows, index: visible.index, hint: SETTINGS_SHORTCUTS.hintEntries(DIALOG_SCOPE) }, width, theme);
     }
     #modelDialogLines(open, width, height, theme) {
+        if (open.modelDialog === "default") {
+            const flags = this.#filteredModelFlags(open);
+            const current = typeof open.entry.rawValue === "string" ? open.entry.rawValue : null;
+            const rows = flags.length === 0
+                ? [{ label: "No models found", value: "" }]
+                : flags.map(flag => ({
+                    ...modelLabelParts(flag.label ?? humanizeLabel(flag.key)),
+                    ...(flag.key === current ? { successSuffix: "✓" } : {}),
+                    value: "",
+                }));
+            const description = open.error ?? "Select the model used for new sessions";
+            const visible = dialogWindow(rows, open.index, configureDialogChoiceCapacity(height, true, configureDialogTextRows(description, width)));
+            return renderSteppedDialogPanel({
+                title: "Default Model", description, input: open.filter ?? new LineInput(""),
+                rows: visible.rows, index: visible.index, hint: MODEL_SHORTCUTS.hintEntries(MODEL_SCOPE),
+            }, width, theme);
+        }
         if (open.step === "model") {
             const flags = this.#filteredModelFlags(open);
             const stored = structuredValue(open.entry, open.record);
@@ -1086,6 +1149,17 @@ function handleSettingsSearchPointer(state, event, panelTop) {
     const handled = input.handlePointer({ kind: event.kind, button: event.button, column: event.column, row });
     return { consumed: handled || overInput, render: handled };
 }
+function orderDefaultModelBeforeThinking(entries, sectionId) {
+    if (sectionId !== "agent")
+        return entries;
+    const defaultModel = entries.find(isDefaultModelEntry);
+    if (defaultModel === undefined)
+        return entries;
+    const ordered = entries.filter(entry => entry !== defaultModel);
+    const thinking = ordered.findIndex(entry => entry.backend === "agent" && entry.id === "modelThinkingLevels");
+    ordered.splice(thinking < 0 ? ordered.length : thinking, 0, defaultModel);
+    return ordered;
+}
 function modelLabelParts(label) {
     const match = /^(.*?)(\s+\[[^\]]+\])$/u.exec(label);
     return match === null ? { label } : { label: match[1] ?? label, labelSuffix: match[2] ?? "" };
@@ -1139,6 +1213,9 @@ function changeFailure(outcome) {
         return outcome.limitationReason ?? "the setting is unavailable";
     return outcome.limitationReason;
 }
+function isDefaultModelEntry(entry) {
+    return entry.backend === "agent" && entry.id === "defaultModel";
+}
 /** The source's own wording when it has one, otherwise the id made readable. */
 function labelOf(entry) {
     return entry.label ?? humanizeLabel(entry.id);

package/dist/foundation/release/automatic-update.d.ts

@@ -2,6 +2,7 @@ import { type AvailableRelease, type ReleaseChannel } from "./latest-release.js"
 export declare const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
 export declare const AUTOMATIC_UPDATE_RETRY_MS: number;
 export declare const AUTOMATIC_UPDATE_ACTIVATION_RETRY_MS: number;
+export declare const ACTIVE_RELEASE_FALLBACK_MS = 5000;
 export interface AutomaticUpdateState {
     readonly schema: typeof AUTOMATIC_UPDATE_STATE_SCHEMA;
     readonly channel: ReleaseChannel;
@@ -18,6 +19,17 @@ export declare class AutomaticUpdateStateStore {
     read(): Promise<AutomaticUpdateState | null>;
     write(value: AutomaticUpdateState): Promise<void>;
 }
+export interface ActiveReleaseObservationOptions {
+    readonly runningVersion: string;
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly signal?: AbortSignal;
+    readonly onNewer: (version: string) => void;
+    readonly fallbackMs?: number;
+}
+/** Read the approved active release only when this process executes an older release on that channel. */
+export declare function readNewerActiveRelease(runningVersion: string, environment?: NodeJS.ProcessEnv): Promise<string | null>;
+/** Observe local release activation promptly, with a bounded fallback for missed filesystem events. */
+export declare function observeNewerActiveRelease(options: ActiveReleaseObservationOptions): () => void;
 export interface AutomaticUpdateRequestOptions {
     readonly release: AvailableRelease;
     readonly runningVersion: string;

package/dist/foundation/release/automatic-update.js

@@ -1,7 +1,8 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+import { watch } from "node:fs";
+import { mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
 import { valid as validSemver } from "semver";
 import { readLaunchContext } from "../launch-context/index.js";
 import { resolveProductPaths } from "../lifecycle/index.js";
@@ -19,6 +20,7 @@ const AUTOMATIC_UPDATE_STATE_FILENAME = "automatic-update.json";
 const MAX_STATE_BYTES = 16_384;
 const OBSERVER_POLL_MS = 250;
 const WORKER_START_GRACE_MS = 5_000;
+export const ACTIVE_RELEASE_FALLBACK_MS = 5_000;
 export class AutomaticUpdateStateStore {
     path;
     constructor(dataDir) { this.path = resolve(dataDir, AUTOMATIC_UPDATE_STATE_FILENAME); }
@@ -59,6 +61,82 @@ export class AutomaticUpdateStateStore {
         }
     }
 }
+/** Read the approved active release only when this process executes an older release on that channel. */
+export async function readNewerActiveRelease(runningVersion, environment = process.env) {
+    const channel = releaseChannelOf(runningVersion);
+    if (channel === null)
+        return null;
+    try {
+        const paths = resolveProductPaths(environment);
+        const active = await activeRelease(paths.dataDir);
+        return activeNewerPackageVersion(active, runningVersion, channel) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Observe local release activation promptly, with a bounded fallback for missed filesystem events. */
+export function observeNewerActiveRelease(options) {
+    if (releaseChannelOf(options.runningVersion) === null || options.signal?.aborted)
+        return () => { };
+    const paths = resolveProductPaths(options.environment ?? process.env);
+    const store = new CohortStateStore(paths.dataDir);
+    let closed = false;
+    let checking = false;
+    let requested = false;
+    let watcher = null;
+    let signature;
+    const stop = () => {
+        if (closed)
+            return;
+        closed = true;
+        clearInterval(fallback);
+        watcher?.close();
+        options.signal?.removeEventListener("abort", stop);
+    };
+    const check = async () => {
+        if (closed)
+            return;
+        if (checking) {
+            requested = true;
+            return;
+        }
+        checking = true;
+        try {
+            const version = await readNewerActiveRelease(options.runningVersion, options.environment);
+            if (version !== null && !closed) {
+                stop();
+                options.onNewer(version);
+            }
+        }
+        finally {
+            checking = false;
+            if (requested && !closed) {
+                requested = false;
+                void check();
+            }
+        }
+    };
+    const checkChanged = async (force) => {
+        const next = await stat(store.path).then(value => `${value.dev}:${value.ino}:${value.ctimeMs}:${value.mtimeMs}:${value.size}`, () => null);
+        if (!force && next === signature)
+            return;
+        signature = next;
+        await check();
+    };
+    const fallback = setInterval(() => { void checkChanged(false); }, options.fallbackMs ?? ACTIVE_RELEASE_FALLBACK_MS);
+    fallback.unref?.();
+    try {
+        watcher = watch(dirname(store.path), { persistent: false }, (_event, filename) => {
+            if (filename === null || filename.toString() === basename(store.path))
+                void checkChanged(false);
+        });
+    }
+    catch { /* Rationale: the bounded metadata fallback remains authoritative when watching is unavailable. */ }
+    options.signal?.addEventListener("abort", stop, { once: true });
+    void checkChanged(true);
+    return stop;
+}
 /** Start or observe one silent update and resolve with the active newer version once restart is useful. */
 export async function requestAutomaticUpdate(options) {
     if (options.signal?.aborted)
@@ -292,9 +370,13 @@ async function spawnAutomaticUpdateWorker(entry, arguments_, environment) {
 }
 async function activeNewerVersion(dataDir, runningVersion, target) {
     const active = await activeRelease(dataDir);
-    return active !== null && releaseChannelOf(active.packageVersion) === target.channel
-        && isNewerRelease(active.packageVersion, runningVersion)
-        && (active.packageVersion === target.version || isNewerRelease(active.packageVersion, target.version))
+    return activeNewerPackageVersion(active, runningVersion, target.channel, target.version);
+}
+function activeNewerPackageVersion(active, runningVersion, channel, minimum) {
+    if (active === null || releaseChannelOf(active.packageVersion) !== channel
+        || !isNewerRelease(active.packageVersion, runningVersion))
+        return null;
+    return minimum === undefined || active.packageVersion === minimum || isNewerRelease(active.packageVersion, minimum)
         ? active.packageVersion : null;
 }
 async function activeRelease(dataDir) {

package/dist/integrations/pi/engine/default-model-setting.d.ts

@@ -0,0 +1,12 @@
+import type { SettingsManager } from "../startup-public.js";
+import type { AgentSettingChangeOutcome, AgentSettingDescriptor } from "../../../contracts/agent-engine/index.js";
+interface DefaultModelChoice {
+    readonly key: string;
+    readonly label: string;
+    readonly name: string;
+}
+export declare const DEFAULT_MODEL_SETTING_KEY = "defaultModel";
+export declare const SUPPLEMENTAL_SETTING_KEYS: readonly ["defaultModel"];
+export declare function defaultModelDescriptor(settings: SettingsManager, models: readonly DefaultModelChoice[]): AgentSettingDescriptor;
+export declare function writeDefaultModel(settings: SettingsManager, models: readonly DefaultModelChoice[], value: unknown): Promise<AgentSettingChangeOutcome>;
+export {};