@timurproko/a1 0.2.7-dev.1221 → 0.2.7-dev.1225

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

@@ -1,5 +1,5 @@
 import { DIALOG_BACK_SHORTCUT_HINT, DIALOG_CLOSE_SHORTCUT_HINT } from "../../contracts/presentation/index.js";
-import { GLOBAL_SCOPE, LineInput, PLAIN_THEME, ShortcutRegistry, assertNoShortcutConflicts, blockJumpTarget, numericValues, RAIL_COLUMNS, 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 { 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 { SETTINGS_APP_ID } from "./settings-route.js";
 export { SETTINGS_APP_ID, SETTINGS_ROUTE } from "./settings-route.js";
@@ -125,7 +125,11 @@ export class SettingsApp {
      */
     constructor(session, options) {
         this.#session = session;
-        this.#options = { pinned: options.pinned === true, configurePlusMenu: options.configurePlusMenu ?? null };
+        this.#options = {
+            pinned: options.pinned === true,
+            configurePlusMenu: options.configurePlusMenu ?? null,
+            dialogPanel: options.dialogPanel ?? null,
+        };
         this.#search = {
             input: null,
             scrollBefore: null,
@@ -148,12 +152,11 @@ export class SettingsApp {
     }
     render(rect, host) {
         const theme = host.theme ?? PLAIN_THEME;
-        const rows = this.#rows();
-        const selected = indexOfKey(rows, this.#selectedKey);
+        const rows = this.#rows(), selected = indexOfKey(rows, this.#selectedKey);
         const footer = this.#footerLines(rect.width, theme);
-        // Invariant: the shared search input and structured panel each begin with their own standard rule.
-        // That rule replaces the ordinary content/footer divider instead of stacking beneath it.
-        const dividerRows = this.#search.input === null && this.#structured === null ? SETTINGS_FOOTER_DIVIDER_ROWS : 0;
+        // Invariant: search owns its ruled footer. Configure dialogs float over the complete ordinary
+        // Settings frame, so the standing divider and guidance remain visible in the dimmed backdrop.
+        const dividerRows = this.#search.input === null ? SETTINGS_FOOTER_DIVIDER_ROWS : 0;
         const topRows = Math.min(SETTINGS_TOP_RULE_ROWS, rect.height);
         const contentHeight = Math.max(0, rect.height - topRows - dividerRows - footer.length);
         let titleRows = this.#scroll <= 0 ? Math.min(SETTINGS_TITLE_ROWS, contentHeight) : 0;
@@ -246,7 +249,8 @@ export class SettingsApp {
         });
         const rule = theme.fg("border", "─".repeat(Math.max(0, rect.width)));
         const frame = this.#withMenu([rule, ...withRail, ...(dividerRows === 0 ? [] : [rule]), ...footer], selected, layout, valueColumn, theme, rect, reservesRail ? RAIL_COLUMNS : 0);
-        return frame.slice(0, rect.height).concat(Array(Math.max(0, rect.height - frame.length)).fill(""));
+        const complete = frame.slice(0, rect.height).concat(Array(Math.max(0, rect.height - frame.length)).fill("")), open = this.#structured, dialogTheme = this.#options.dialogPanel === null ? theme : { ...theme, panel: this.#options.dialogPanel };
+        return open === null ? complete : renderCenteredDialogOverlay(complete, this.#dialogLines(open, configureDialogWidth(rect.width), rect.height, dialogTheme), rect, dialogTheme);
     }
     onInput(data, host) {
         if (data === "\u0003" && this.#search.input === null)
@@ -983,9 +987,9 @@ export class SettingsApp {
         this.#menuFrame = frame;
         return renderValueMenu(lines, state, frame, theme);
     }
-    #dialogLines(open, width, theme) {
+    #dialogLines(open, width, height, theme) {
         if (open.modelDialog)
-            return this.#modelDialogLines(open, width, theme);
+            return this.#modelDialogLines(open, width, height, theme);
         if (open.plusMenu !== null)
             return open.plusMenu.lines(open.record, width, theme);
         const rows = open.flags.map(key => {
@@ -997,9 +1001,10 @@ export class SettingsApp {
                 ...(declared?.description === undefined ? {} : { description: declared.description }),
             };
         });
-        return renderDialogPanel({ title: labelOf(open.entry), rows, index: open.index, hint: SETTINGS_SHORTCUTS.hintEntries(DIALOG_SCOPE) }, width, theme);
+        const visible = dialogWindow(rows, open.index, configureDialogChoiceCapacity(height, false, configureDialogTextRows(rows[open.index]?.description ?? "", width)));
+        return renderDialogPanel({ title: labelOf(open.entry), rows: visible.rows, index: visible.index, hint: SETTINGS_SHORTCUTS.hintEntries(DIALOG_SCOPE) }, width, theme);
     }
-    #modelDialogLines(open, width, theme) {
+    #modelDialogLines(open, width, height, theme) {
         if (open.step === "model") {
             const flags = this.#filteredModelFlags(open);
             const stored = structuredValue(open.entry, open.record);
@@ -1009,12 +1014,13 @@ export class SettingsApp {
                     ...modelLabelParts(flag.label ?? humanizeLabel(flag.key)),
                     value: stored[flag.key] === undefined ? "" : String(stored[flag.key]),
                 }));
-            const visible = dialogWindow(allRows, open.index, 10);
+            const description = "Select a model to configure";
+            const visible = dialogWindow(allRows, open.index, configureDialogChoiceCapacity(height, true, configureDialogTextRows(description, width)));
             return renderSteppedDialogPanel({
                 title: "Thinking Level",
                 step: 1,
                 steps: 2,
-                description: "Select a model to configure",
+                description,
                 ...(open.filter === null ? {} : { input: open.filter }),
                 rows: visible.rows,
                 index: visible.index,
@@ -1027,21 +1033,19 @@ export class SettingsApp {
             label: choice.value === current ? `✓ ${choice.label}` : choice.label,
             value: choice.description,
         }));
-        const visible = dialogWindow(allRows, open.index, 10);
+        const description = `Select default thinking level for ${selected?.label ?? open.modelKey ?? "model"}`;
+        const visible = dialogWindow(allRows, open.index, configureDialogChoiceCapacity(height, false, configureDialogTextRows(description, width)));
         return renderSteppedDialogPanel({
             title: "Thinking Level",
             step: 2,
             steps: 2,
-            description: `Select default thinking level for ${selected?.label ?? open.modelKey ?? "model"}`,
+            description,
             rows: visible.rows,
             index: visible.index,
             hint: MODEL_SHORTCUTS.hintEntries(MODEL_LEVEL_SCOPE),
         }, width, theme);
     }
     #footerLines(width, theme) {
-        const open = this.#structured;
-        if (open !== null)
-            return this.#dialogLines(open, width, theme);
         // Rationale: standing guidance is more useful than transient feedback; failures still
         // roll back without displacing the Settings interaction contract.
         const entries = SETTINGS_SHORTCUTS.hintEntries(SCOPE).filter(entry => !this.#options.pinned

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

@@ -9,7 +9,8 @@ import { CohortStateStore } from "./cohort-state.js";
 import { processIsAlive } from "./process-cleanup.js";
 import { isNewerRelease, releaseChannelOf } from "./latest-release.js";
 import { readCertifiedReleaseManifest, resolveReleaseEntryPoint } from "./release-store.js";
-import { readUpdateExecutionOwner } from "./update-execution-lease.js";
+import { acquireUpdateExecutionLease, readUpdateExecutionOwner } from "./update-execution-lease.js";
+import { UpdateTransactionStore } from "./update-transaction.js";
 import { runSelfUpdate, UPDATE_ALREADY_RUNNING_EXIT_CODE } from "./update.js";
 export const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
 export const AUTOMATIC_UPDATE_RETRY_MS = 24 * 60 * 60_000;
@@ -72,10 +73,37 @@ export async function requestAutomaticUpdate(options) {
     catch {
         return null;
     }
-    const readActiveVersion = options.activeVersion ?? (async () => await activeNewerVersion(paths.dataDir, options.runningVersion));
+    const readActiveVersion = options.activeVersion ?? (async () => await activeNewerVersion(paths.dataDir, options.runningVersion, options.release));
     const active = await readActiveVersion();
     if (active !== null)
         return active;
+    let owner;
+    try {
+        owner = await readUpdateExecutionOwner(paths.dataDir);
+    }
+    catch {
+        return null;
+    }
+    let transaction;
+    try {
+        transaction = await new UpdateTransactionStore(paths.dataDir).read();
+    }
+    catch {
+        return null;
+    }
+    // Invariant: recovery of a foreign in-progress transaction belongs to its own owner.
+    if (transaction?.status === "active" && (transaction.targetVersion !== options.release.version
+        || transaction.channel !== (options.release.channel === "stable" ? "stable" : "next")))
+        return null;
+    if (existing?.status === "running" && now() - existing.updatedAt >= WORKER_START_GRACE_MS
+        && (owner === null || !processIsAlive(owner.pid))) {
+        // Invariant: a coordinator record is not ownership. Settle only when no transaction
+        // remains to recover; never overwrite or roll back a foreign in-progress target.
+        if (transaction === null) {
+            existing = { ...existing, status: "failed", updatedAt: now(), failure: "worker-exited" };
+            await store.write(existing).catch(() => undefined);
+        }
+    }
     if (existing?.status === "failed" && existing.channel === options.release.channel && now() - existing.attemptedAt >= 0
         && now() - existing.attemptedAt < AUTOMATIC_UPDATE_RETRY_MS
         && !isNewerRelease(options.release.version, existing.targetVersion))
@@ -100,15 +128,16 @@ export async function requestAutomaticUpdate(options) {
         "--target-version", options.release.version,
         "--data-dir", paths.dataDir,
     ];
-    let owner;
-    try {
-        owner = await readUpdateExecutionOwner(paths.dataDir);
-    }
-    catch {
-        return null;
-    }
     if (owner === null || !processIsAlive(owner.pid)) {
-        await (options.spawnWorker ?? spawnAutomaticUpdateWorker)(worker.entry, arguments_, environment).catch(() => undefined);
+        try {
+            await (options.spawnWorker ?? spawnAutomaticUpdateWorker)(worker.entry, arguments_, environment);
+        }
+        catch {
+            // Invariant: no worker began this attempt. Do not invent a successful install or an owner.
+            await store.write(state({ packageRoot: worker.packageRoot, channel: options.release.channel,
+                targetVersion: options.release.version, dataDir: paths.dataDir }, "failed", now(), null, "worker-start-failed")).catch(() => undefined);
+            return null;
+        }
     }
     const startedAt = now();
     const sleep = options.sleep ?? (async (durationMs) => await new Promise(resolvePromise => {
@@ -134,15 +163,22 @@ export async function runAutomaticUpdateWorker(argv, environment = process.env)
     const paths = resolveProductPaths(environment);
     if (!samePath(parsed.dataDir, paths.dataDir))
         return 1;
-    const launch = readLaunchContext(environment, "release");
-    const cohort = await new CohortStateStore(paths.dataDir).read();
-    const record = launch.releaseId === undefined ? undefined : cohort.releases[launch.releaseId];
-    if (!record || record.approval !== "approved" || !samePath(record.releaseRoot, launch.releaseRoot ?? "")
-        || record.contentDigest !== launch.releaseDigest)
-        return 1;
-    const selected = await readCertifiedReleaseManifest(record, resolve(paths.dataDir, "releases"));
-    if (!samePath(selected.packageRoot, parsed.packageRoot))
+    let verified = false;
+    try {
+        const launch = readLaunchContext(environment, "release");
+        const cohort = await new CohortStateStore(paths.dataDir).read();
+        const record = launch.releaseId === undefined ? undefined : cohort.releases[launch.releaseId];
+        if (record?.approval === "approved" && samePath(record.releaseRoot, launch.releaseRoot ?? "")
+            && record.contentDigest === launch.releaseDigest) {
+            const selected = await readCertifiedReleaseManifest(record, resolve(paths.dataDir, "releases"));
+            verified = samePath(selected.packageRoot, parsed.packageRoot);
+        }
+    }
+    catch { /* Security: invalid provenance fails closed without running the updater. */ }
+    if (!verified) {
+        await recordAutomaticPreflightFailure(parsed, paths.dataDir);
         return 1;
+    }
     const store = new AutomaticUpdateStateStore(paths.dataDir);
     const attemptedAt = Date.now();
     const output = { stdout() { }, stderr() { } };
@@ -166,7 +202,10 @@ export async function runAutomaticUpdateWorker(argv, environment = process.env)
             return 0;
         if (code !== 0) {
             await runningWrite;
-            await store.write(state(parsed, "failed", attemptedAt, null, `exit-${code}`));
+            if (acquired)
+                await store.write(state(parsed, "failed", attemptedAt, null, `exit-${code}`));
+            else
+                await recordAutomaticPreflightFailure(parsed, paths.dataDir);
             return code;
         }
         const active = await activeRelease(paths.dataDir);
@@ -176,6 +215,8 @@ export async function runAutomaticUpdateWorker(argv, environment = process.env)
                 await runningWrite;
                 await store.write(state(parsed, "failed", attemptedAt, null, "target-not-active"));
             }
+            else
+                await recordAutomaticPreflightFailure(parsed, paths.dataDir);
             return 1;
         }
         await runningWrite;
@@ -184,10 +225,34 @@ export async function runAutomaticUpdateWorker(argv, environment = process.env)
     }
     catch (error) {
         await runningWrite.catch(() => undefined);
-        await store.write(state(parsed, "failed", attemptedAt, null, errorMessage(error).slice(0, 512))).catch(() => undefined);
+        if (acquired)
+            await store.write(state(parsed, "failed", attemptedAt, null, errorMessage(error).slice(0, 512))).catch(() => undefined);
+        else
+            await recordAutomaticPreflightFailure(parsed, paths.dataDir);
         return 1;
     }
 }
+async function recordAutomaticPreflightFailure(parsed, dataDir) {
+    // Security: even a rejected worker must claim the ordinary update lease before recording
+    // failure, so it cannot overwrite another owner's result or an unfinished transaction.
+    const lease = await acquireUpdateExecutionLease({ dataDir, packageRoot: parsed.packageRoot,
+        channel: parsed.channel === "stable" ? "stable" : "next", targetVersion: parsed.targetVersion, mode: "automatic" }).catch(() => null);
+    if (lease?.status !== "acquired")
+        return;
+    try {
+        if (await new UpdateTransactionStore(dataDir).read() !== null)
+            return;
+        const store = new AutomaticUpdateStateStore(dataDir);
+        const existing = await store.read();
+        if (existing !== null && (existing.targetVersion !== parsed.targetVersion || existing.status === "installed"))
+            return;
+        await store.write(state(parsed, "failed", Date.now(), null, "worker-preflight-failed"));
+    }
+    catch { /* Rationale: preflight failure is best effort; never mask the rejected worker. */ }
+    finally {
+        await lease.release().catch(() => undefined);
+    }
+}
 async function spawnAutomaticUpdateWorker(entry, arguments_, environment) {
     const child = spawn(process.execPath, [entry, ...arguments_], {
         detached: true,
@@ -201,9 +266,12 @@ async function spawnAutomaticUpdateWorker(entry, arguments_, environment) {
     });
     child.unref();
 }
-async function activeNewerVersion(dataDir, runningVersion) {
+async function activeNewerVersion(dataDir, runningVersion, target) {
     const active = await activeRelease(dataDir);
-    return active !== null && isNewerRelease(active.packageVersion, runningVersion) ? active.packageVersion : null;
+    return active !== null && releaseChannelOf(active.packageVersion) === target.channel
+        && isNewerRelease(active.packageVersion, runningVersion)
+        && (active.packageVersion === target.version || isNewerRelease(active.packageVersion, target.version))
+        ? active.packageVersion : null;
 }
 async function activeRelease(dataDir) {
     const cohort = await new CohortStateStore(dataDir).read();

package/dist/foundation/release/bootstrap.js

@@ -31,8 +31,8 @@ async function runBootstrapAttempt(options, retriesRemaining) {
     await markStartupPhase(environment, "bootstrap-start");
     assertLaunchProfileId(launchProfileId);
     const sessionArgs = sessionSelectionArguments(options.launchIntent?.sessionSelection);
-    if (sessionArgs.length > 0 && (launchProfileId !== "a1" || launchMode === "solo")) {
-        throw new Error("session selection requires the normal tabbed A1 launch");
+    if (sessionArgs.length > 0 && launchProfileId !== "a1") {
+        throw new Error("session selection requires the A1 profile");
     }
     const output = options.output ?? process.stderr;
     const paths = resolveProductPaths(environment);

package/dist/foundation/release/latest-release.d.ts

@@ -21,6 +21,7 @@ export interface AvailableRelease {
 }
 export declare const DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
 export declare const UPDATE_CHECK_INTERVAL_MS: number;
+export declare const NOTIFY_CHECK_INTERVAL_MS: number;
 /** One published version with the pull request its manifest records, when it records one. */
 export interface PublishedVersion {
     readonly version: string;
@@ -54,7 +55,7 @@ export declare function parsePublishedVersions(document: unknown): PublishedVers
 /** Forget the startup release check so the next interactive launch asks the registry again. */
 export declare function invalidateReleaseCheckCache(configDir: string): Promise<void>;
 export declare function unavailableDistTags(error: string): DistTagVersions;
-export declare function createRegistryFetcher(timeoutMs: number): RegistryFetcher;
+export declare function createRegistryFetcher(timeoutMs: number, signal?: AbortSignal): RegistryFetcher;
 export interface StartupReleaseCheckOptions {
     readonly runningVersion: string;
     readonly configDir: string;
@@ -64,6 +65,9 @@ export interface StartupReleaseCheckOptions {
     /** The bare-A1 `updateCheck` setting; comparison profiles omit it and use auto. */
     readonly settingMode?: StartupUpdateMode;
     readonly fetcher?: RegistryFetcher;
+    readonly signal?: AbortSignal;
+    /** Remaining cache lifetime for a live Auto observer, when discovery succeeds. */
+    readonly onNextCheckDelay?: (milliseconds: number) => void;
     readonly now?: () => number;
 }
 /** Why the startup check is skipped before any cache read or network access, or null when it may run. */

package/dist/foundation/release/latest-release.js

@@ -2,12 +2,14 @@ import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { gt, prerelease, valid as validSemver } from "semver";
+import lockfile from "proper-lockfile";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 export const DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
-export const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60_000;
+export const UPDATE_CHECK_INTERVAL_MS = 15 * 60_000;
+export const NOTIFY_CHECK_INTERVAL_MS = 24 * 60 * 60_000;
 const STARTUP_FETCH_TIMEOUT_MS = 3_000;
 const CACHE_FILENAME = "update-check.json";
-const CACHE_VERSION = 1;
+const CACHE_VERSION = 2;
 const MAX_CACHE_BYTES = 4096;
 const MAX_PACKAGE_DOCUMENT_BYTES = 32 * 1024 * 1024;
 const DEVELOPMENT_BUILD = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-dev\.(0|[1-9]\d*)$/u;
@@ -105,13 +107,14 @@ export function parsePublishedVersions(document) {
 }
 /** Forget the startup release check so the next interactive launch asks the registry again. */
 export async function invalidateReleaseCheckCache(configDir) {
-    await rm(join(configDir, CACHE_FILENAME), { force: true });
+    await withCacheLock(configDir, async () => { await rm(join(configDir, CACHE_FILENAME), { force: true }); });
 }
 export function unavailableDistTags(error) {
     return { release: null, develop: null, error };
 }
-export function createRegistryFetcher(timeoutMs) {
-    return async (url) => await fetch(url, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(timeoutMs) });
+export function createRegistryFetcher(timeoutMs, signal) {
+    return async (url) => await fetch(url, { headers: { accept: "application/json" },
+        signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs) });
 }
 /** Why the startup check is skipped before any cache read or network access, or null when it may run. */
 export function startupReleaseCheckSkipReason(options) {
@@ -136,22 +139,33 @@ export function startupReleaseCheckSkipReason(options) {
  * answer replaces the cache. Every failure resolves to null: the notice is best-effort.
  */
 export async function checkForNewerRelease(options) {
-    if (startupReleaseCheckSkipReason(options) !== null)
+    if (options.signal?.aborted || startupReleaseCheckSkipReason(options) !== null)
         return null;
     const channel = releaseChannelOf(options.runningVersion);
     const environment = options.environment ?? process.env;
     const now = options.now ?? Date.now;
     const cachePath = join(options.configDir, CACHE_FILENAME);
     try {
-        let latest = await readFreshCache(cachePath, channel, now());
-        if (latest === null) {
-            const tags = await queryRegistryDistTags(options.fetcher ?? createRegistryFetcher(STARTUP_FETCH_TIMEOUT_MS), environment.npm_config_registry?.trim() || undefined);
-            latest = channel === "stable" ? tags.release : tags.develop;
-            if (tags.error !== null || latest === null)
+        const interval = options.settingMode === "notify" ? NOTIFY_CHECK_INTERVAL_MS : UPDATE_CHECK_INTERVAL_MS;
+        const latest = await withCacheLock(options.configDir, async () => {
+            if (options.signal?.aborted)
                 return null;
-            await writeCache(options.configDir, cachePath, { version: CACHE_VERSION, channel, latest, checkedAt: now() }).catch(() => undefined);
-        }
-        return isNewerRelease(latest, options.runningVersion) ? availableRelease(channel, latest) : null;
+            const document = await readCache(cachePath);
+            const cached = freshVersion(document[channel], now(), interval);
+            if (cached !== null)
+                return cached;
+            const tags = await queryRegistryDistTags(options.fetcher ?? createRegistryFetcher(STARTUP_FETCH_TIMEOUT_MS, options.signal), environment.npm_config_registry?.trim() || undefined);
+            const discovered = channel === "stable" ? tags.release : tags.develop;
+            if (tags.error !== null || discovered === null || options.signal?.aborted)
+                return null;
+            const entry = { latest: discovered, checkedAt: now() };
+            await writeCache(options.configDir, cachePath, { ...document, [channel]: entry }).catch(() => undefined);
+            return entry;
+        });
+        if (options.signal?.aborted || latest === null)
+            return null;
+        options.onNextCheckDelay?.(Math.min(interval, Math.max(1, interval - (now() - latest.checkedAt))));
+        return isNewerRelease(latest.latest, options.runningVersion) ? availableRelease(channel, latest.latest) : null;
     }
     catch {
         return null;
@@ -165,29 +179,58 @@ export function availableRelease(channel, version) {
         changelogUrl: channel === "stable" ? `${RELEASE_PAGE}${version}` : null,
     };
 }
-async function readFreshCache(path, channel, now) {
-    let parsed;
+function validEntry(value, channel) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const entry = value;
+    return typeof entry.latest === "string" && releaseChannelOf(entry.latest) === channel
+        && typeof entry.checkedAt === "number" && Number.isFinite(entry.checkedAt) ? { latest: entry.latest, checkedAt: entry.checkedAt } : undefined;
+}
+async function readCache(path) {
     try {
         const source = await readFile(path, "utf8");
-        if (source.length > MAX_CACHE_BYTES)
-            return null;
-        parsed = JSON.parse(source);
+        if (Buffer.byteLength(source, "utf8") > MAX_CACHE_BYTES)
+            return { version: CACHE_VERSION };
+        const value = JSON.parse(source);
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return { version: CACHE_VERSION };
+        const cache = value;
+        if (cache.version === 1) {
+            // Compatibility: an old cache has exactly one channel; do not infer a value for the other.
+            if (cache.channel !== "stable" && cache.channel !== "development")
+                return { version: CACHE_VERSION };
+            const entry = validEntry(cache, cache.channel);
+            return entry ? { version: CACHE_VERSION, [cache.channel]: entry } : { version: CACHE_VERSION };
+        }
+        if (cache.version !== CACHE_VERSION)
+            return { version: CACHE_VERSION };
+        const stable = validEntry(cache.stable, "stable");
+        const development = validEntry(cache.development, "development");
+        return { version: CACHE_VERSION, ...(stable ? { stable } : {}), ...(development ? { development } : {}) };
     }
     catch {
-        return null;
+        return { version: CACHE_VERSION };
     }
-    if (typeof parsed !== "object" || parsed === null)
-        return null;
-    const cache = parsed;
-    if (cache.version !== CACHE_VERSION || cache.channel !== channel)
-        return null;
-    if (typeof cache.latest !== "string" || validSemver(cache.latest) === null)
-        return null;
-    if (typeof cache.checkedAt !== "number" || !Number.isFinite(cache.checkedAt))
+}
+function freshVersion(entry, now, interval) {
+    if (!entry)
         return null;
-    // Invariant: a timestamp from the future (clock moved back) is stale rather than fresh forever.
-    const age = now - cache.checkedAt;
-    return age >= 0 && age < UPDATE_CHECK_INTERVAL_MS ? cache.latest : null;
+    // Invariant: a timestamp from the future is stale rather than fresh forever.
+    const age = now - entry.checkedAt;
+    return age >= 0 && age < interval ? entry : null;
+}
+async function withCacheLock(directory, operation) {
+    await mkdir(directory, { recursive: true });
+    const release = await lockfile.lock(join(directory, CACHE_FILENAME), {
+        realpath: false, stale: 30_000, update: 10_000,
+        retries: { retries: 20, factor: 1.2, minTimeout: 20, maxTimeout: 100, randomize: true },
+    });
+    try {
+        return await operation();
+    }
+    finally {
+        await release();
+    }
 }
 async function writeCache(directory, path, document) {
     await mkdir(directory, { recursive: true });

package/dist/integrations/pi/components/owned-editor-ux.js

@@ -67,7 +67,7 @@ class PromptSelectionInterceptor {
     #lastClick;
     #redoStack = [];
     #selectionRevision = 0;
-    #pasteGeneration = 0;
+    #pasteState = { generation: 0, preview: undefined };
     #terminalPaste;
     #wordDirection;
     #geometry;
@@ -81,6 +81,7 @@ class PromptSelectionInterceptor {
         installAtomicSegmentation(editor, options.atomicRanges, () => this.#wordDirection);
     }
     handleInput(data, next) {
+        this.#pasteState.preview = undefined;
         if (this.options.pasteEnabled === false ? discardTerminalPaste(this, data, value => this.handleInput(value, next)) : this.#handleTerminalPaste(data, next))
             return;
         if (this.keybindings.matches(data, "owned.editor.selectAll")) {
@@ -195,7 +196,26 @@ class PromptSelectionInterceptor {
             this.#redoStack = [];
     }
     render(width, next) {
+        const preview = this.#pasteState.preview;
         const state = editorState(this.editor);
+        if (preview !== undefined && this.editor.getText() === preview.reservedText
+            && this.#selectionRevision === preview.revision
+            && samePosition(this.#cursor(), preview.reservedCursor)
+            && this.#selection === undefined) {
+            // Invariant: painting does not commit the reserved edit.
+            const original = { lines: [...state.lines], cursor: this.#cursor(), selection: this.#selection };
+            this.#pasteState.preview = undefined;
+            try {
+                this.#setRenderState(preview.lines, preview.cursor);
+                this.#selection = preview.selection;
+                return this.render(width, next);
+            }
+            finally {
+                this.#setRenderState(original.lines, original.cursor);
+                this.#selection = original.selection;
+                this.#pasteState.preview = preview;
+            }
+        }
         const hidden = state.lines.map(line => this.options.hiddenRanges?.(line) ?? []);
         if (!hidden.some(ranges => ranges.length > 0))
             return this.#renderVisible(width, next);
@@ -277,6 +297,7 @@ class PromptSelectionInterceptor {
         return rows.map((row, index) => this.options.decorateRow(row, width, index));
     }
     reset() {
+        this.#pasteState.preview = undefined;
         this.#selection = undefined;
         this.#pointerSelecting = false;
         this.#lastClick = undefined;
@@ -285,7 +306,8 @@ class PromptSelectionInterceptor {
         this.#selectionRevision += 1;
     }
     cancelPendingPastes() {
-        this.#pasteGeneration += 1;
+        this.#pasteState.generation += 1;
+        this.#pasteState.preview = undefined;
         this.#terminalPaste = undefined;
         DISABLED_TERMINAL_PASTES.delete(this);
     }
@@ -309,6 +331,14 @@ class PromptSelectionInterceptor {
     handlePointer(event) {
         if (event.button !== 0)
             return false;
+        if (this.#pasteState.preview !== undefined) {
+            this.#pasteState.preview = undefined;
+            // Invariant: preview coordinates cannot address a hidden marker.
+            this.#geometry = undefined;
+            this.#pointerSelecting = event.kind === "press";
+            this.#requestRender();
+            return true;
+        }
         if (event.kind === "press")
             return this.#pointerPress(event.column, event.row);
         if (event.kind === "motion") {
@@ -539,17 +569,30 @@ class PromptSelectionInterceptor {
         const begin = source === undefined ? this.options.beginClipboardPaste
             : this.options.beginTextPaste === undefined ? undefined : () => this.options.beginTextPaste(source);
         if (begin !== undefined) {
-            const generation = this.#pasteGeneration;
+            const generation = this.#pasteState.generation;
             const restore = this.#orderedSelection() === undefined ? "" : this.#selectedText();
             const paste = begin();
             this.#redoStack = [];
-            if (this.#orderedSelection() !== undefined)
+            const selected = this.#orderedSelection();
+            if (selected !== undefined) {
+                const lines = [...editorState(this.editor).lines];
+                const cursor = this.#cursor();
+                const selection = this.#selection;
+                const current = this.editor.getText();
+                const from = positionOffset(lines, selected.start);
+                const to = positionOffset(lines, selected.end);
+                const reservedText = current.slice(0, from) + normalizeInsertedText(paste.marker) + current.slice(to);
                 this.#replaceSelection(paste.marker);
+                this.#pasteState.preview = { marker: paste.marker, reservedText, lines, cursor, selection,
+                    reservedCursor: this.#cursor(), revision: this.#selectionRevision };
+            }
             else
                 this.editor.insertTextAtCursor(paste.marker);
             this.#requestRender();
             const replace = (text) => {
-                if (generation === this.#pasteGeneration)
+                if (this.#pasteState.preview?.marker === paste.marker)
+                    this.#pasteState.preview = undefined;
+                if (generation === this.#pasteState.generation)
                     this.#replacePasteMarker(paste.marker, paste.isCurrent?.() === false ? restore : text || restore);
                 paste.complete?.();
             };

package/dist/integrations/pi/engine/workflow-runner.js

@@ -443,7 +443,7 @@ export class PiWorkflowRunner {
             case "copy": {
                 const text = requireCapability(session.getLastAssistantText, "getLastAssistantText").call(session);
                 if (typeof text !== "string" || text.length === 0)
-                    return workflowResult(request.command, "failed", "No agent messages to copy yet.");
+                    return workflowResult(request.command, "completed", "", undefined, "silent");
                 const acknowledged = await this.copyWorkflowText(text);
                 return workflowResult(request.command, "completed", acknowledged ? "Copied last agent message to clipboard" : "Submitted last agent message to clipboard");
             }

package/dist/native/darwin-arm64/manifest.json

@@ -7,7 +7,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-10-28T07:16:03.705Z",
+  "builtAt": "2026-10-29T14:00:11.225Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "a87eaaffcd986b624c8b044b756446cc1bdaf4334a1775b97820542fe34f9fb7",

package/dist/native/darwin-arm64/terminal-host.manifest.json

@@ -9,11 +9,11 @@
   "architecture": "arm64",
   "target": "aarch64-apple-darwin",
   "capability": "supported",
-  "builtAt": "2026-10-28T07:18:47.307Z",
+  "builtAt": "2026-10-29T14:03:13.305Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "2c9107be459d3cce4f154eb34fd839b34d784a82b280d9f56896908d1e7cb1bf",
-    "size": 6001744
+    "sha256": "5f1a93ca9a050c2769a4e322f4d765b00f2ccc9451bcde7ac978b573ee544bef",
+    "size": 6019328
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

package/dist/native/darwin-x64/manifest.json

@@ -7,7 +7,7 @@
   "platform": "darwin",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-28T07:16:10.391Z",
+  "builtAt": "2026-10-29T14:00:18.680Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "783a65f0de287a1c02cd5429dbe97bc8633f4cc8a7b92e3e961180b9bdcff814",