@timurproko/a1 0.2.7-dev.1222 → 0.2.7-dev.1226

package/README.md

@@ -63,6 +63,8 @@ Launch A1 in single agent mode:
 a1 solo
 ```
 
+When a solo session exits, its printed `a1 solo --session <id>` command resumes that same conversation in solo mode; a custom session store is included in the printed command. Resident tabs are different: they keep running after detach, and bare `a1` returns to them.
+
 Show all commands:
 
 ```text
@@ -92,7 +94,7 @@ a1 tabs
 a1 tabs stop <id>
 ```
 
-Stop every tab and the resident host, for example before going back to single agent mode with `a1 solo`:
+Stop every tab and the resident host when you are finished with them (not required to run `a1 solo`):
 
 ```text
 a1 tabs host stop
@@ -145,13 +147,13 @@ Stuck on `0.2.2` and `a1 update` fails? Run the installer once, then use `a1 upd
 npm x -y -- @timurproko/a1-install
 ```
 
-The **Update** setting controls the at-most-daily startup check:
+The **Update** setting controls release discovery:
 
-- **Auto** (default) silently installs a verified update for the running channel, then shows `Update installed · Restart to update`.
-- **Notify** keeps the `Update Available` notice and leaves installation manual.
-- **No** performs no startup update check; updates remain available through the commands above.
+- **Auto** (default) checks the running release's stable or development channel at startup and every 15 minutes while open. It silently installs a verified update, then shows `Update installed · Restart to update`; existing sessions keep running until restarted.
+- **Notify** checks at startup (at most daily), keeps the `Update Available` notice, and leaves installation manual.
+- **No** performs no update check; updates remain available through the commands above.
 
-`A1_SKIP_VERSION_CHECK=1` also disables the startup check. Manual stable, development, and exact-version update commands remain available in every mode.
+`A1_SKIP_VERSION_CHECK=1` disables both Auto and Notify discovery. Manual stable, development, and exact-version update commands remain available in every mode.
 
 <p align="center"><picture><source media="(prefers-color-scheme: dark)" srcset="docs/assets/readme/separator-dark.svg"><img src="docs/assets/readme/separator.svg" alt="" width="280"></picture></p>
 

package/bin/ui.js

@@ -103,6 +103,7 @@ if (utilityRoute !== null) {
           ownedSurfaces,
           notificationVersion: launchContext.updateVersion,
           ...(hidesTabSettings(launchContext) ? { hideTabSettings: true } : {}),
+          soloResumeHint: profile === "a1" && launchContext.launchMode === "solo",
           ...(processInspector === null ? {} : { inspectProcess: pid => processInspector.observe(pid) }),
           projectTrustPrompt: createConsoleProjectTrustPrompt({ presentation: profile === "a1" ? "bare" : "comparison" }),
           sessionForkPrompt: createConsoleSessionForkPrompt(),

package/dist/app/session-shell/exit-notice.d.ts

@@ -13,6 +13,6 @@ export interface ExitNoticeSource {
 export interface ArmedExitNotice {
     clear(): void;
 }
-export declare function uncleanExitNoticeLines(resume: SessionResumeCommandMetadata | null): string[];
+export declare function uncleanExitNoticeLines(resume: SessionResumeCommandMetadata | null, soloResumeHint?: boolean): string[];
 /** Arms the notice and keeps its resume command following the bound session until cleared. */
-export declare function armExitNotice(source: ExitNoticeSource, path: string): ArmedExitNotice;
+export declare function armExitNotice(source: ExitNoticeSource, path: string, soloResumeHint?: boolean): ArmedExitNotice;

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

@@ -7,14 +7,14 @@
 import { renameSync, rmSync, writeFileSync } from "node:fs";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { formatSessionResumeCommand } from "./session-lifecycle.js";
-export function uncleanExitNoticeLines(resume) {
+export function uncleanExitNoticeLines(resume, soloResumeHint = false) {
     return [
         `${PRODUCT_IDENTITY.displayName} was stopped unexpectedly.`,
-        ...(resume === null ? [] : [`To resume this session: ${formatSessionResumeCommand(resume)}`]),
+        ...(resume === null ? [] : [`To resume this session: ${formatSessionResumeCommand(resume, soloResumeHint)}`]),
     ];
 }
 /** Arms the notice and keeps its resume command following the bound session until cleared. */
-export function armExitNotice(source, path) {
+export function armExitNotice(source, path, soloResumeHint = false) {
     let current = null;
     let cleared = false;
     let generation = source.identity.sessionGeneration;
@@ -22,7 +22,7 @@ export function armExitNotice(source, path) {
         if (cleared)
             return;
         // Protocol: plain text only; the guardian strips control characters, so styling would be lost.
-        const text = `${uncleanExitNoticeLines(source.identity.currentSessionResumeMetadata()).join("\n")}\n`;
+        const text = `${uncleanExitNoticeLines(source.identity.currentSessionResumeMetadata(), soloResumeHint).join("\n")}\n`;
         if (text === current)
             return;
         try {

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

@@ -3,13 +3,14 @@ export interface SessionResumeCommandMetadata {
     readonly sessionDir: string;
     readonly usesDefaultSessionDir: boolean;
 }
-export declare function formatSessionResumeCommand(metadata: SessionResumeCommandMetadata): string;
+export declare function formatSessionResumeCommand(metadata: SessionResumeCommandMetadata, solo?: boolean): string;
 export declare function quoteCommandArgument(value: string): string;
 export interface ExitTextInput {
     readonly terminalMode: "regular" | "fullscreen";
     readonly customViewport: boolean;
     readonly exitMode: "transcript" | "resume-hint";
     readonly resume: SessionResumeCommandMetadata | null;
+    readonly soloResumeHint?: boolean;
     /** The styled transcript, rendered only when the pinned profile asks for it. */
     readonly transcript: () => string;
 }

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

@@ -1,6 +1,8 @@
 import { PRODUCT_TEXT } from "../../product-identity.js";
-export function formatSessionResumeCommand(metadata) {
+export function formatSessionResumeCommand(metadata, solo = false) {
     const args = [PRODUCT_TEXT.commandName];
+    if (solo)
+        args.push("solo");
     if (!metadata.usesDefaultSessionDir)
         args.push("--session-dir", quoteCommandArgument(metadata.sessionDir));
     args.push("--session", metadata.sessionId);
@@ -18,7 +20,7 @@ export function quoteCommandArgument(value) {
 export function composeExitText(input) {
     if (input.terminalMode !== "fullscreen")
         return "";
-    const resumeHint = input.resume === null ? "" : `${dim("To resume this session:")} ${formatSessionResumeCommand(input.resume)}`;
+    const resumeHint = input.resume === null ? "" : `${dim("To resume this session:")} ${formatSessionResumeCommand(input.resume, input.soloResumeHint)}`;
     // Invariant: bare A1 leaves only the hint behind; the pinned comparison profile still
     // honors fullscreenExitOutput, including the styled transcript.
     if (input.customViewport || input.exitMode === "resume-hint")

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

@@ -73,6 +73,8 @@ export interface OwnedUiShellEngineOptions {
 /** Terminal, startup, viewport, and presentation-cadence seams; production leaves most at their defaults. */
 export interface OwnedUiShellPresentationOptions {
     readonly terminal?: OwnedUiTerminalPort;
+    /** Explicit direct solo launch, not a resident fallback or comparison launch. */
+    readonly soloResumeHint?: boolean;
     readonly startup?: OwnedUiStartupOptions;
     /** Live profile-local settings, supplied only to the bare-A1 composition. */
     readonly viewportSettings?: OwnedUiViewportSettingsPort;

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

@@ -28,6 +28,8 @@ import { writeSystemClipboardText, } from "./system-clipboard.js";
 import { OwnedUiSessionShellRoot, shellResourceEntries, } from "./session-shell-root.js";
 // Invariant: a disposed shell leaves the engine a host that holds no reference back to it.
 const DETACHED_WORKFLOW_INTERACTION = { prompt: async () => null, notify() { } };
+// Invariant: the resume mode belongs to the presenter instance, not the persisted session or profile.
+const SOLO_RESUME_HINTS = new WeakSet();
 /** Resident Agents refuse the commands their tab bar serves instead, naming where they live. */
 const RESIDENT_UTILITY_TAB_REFUSALS = Object.freeze({
     settings: "Settings is available from the global Settings tab.",
@@ -109,6 +111,8 @@ export class OwnedUiSessionPresenter {
         this.#sessionBindingGeneration = this.backend.identity.sessionBindingGeneration;
         this.#suggestionModelKey = suggestionModelKey(this.backend.session.view());
         this.#customViewport = sessionLayout === "custom-viewport";
+        if (options.presentation?.soloResumeHint)
+            SOLO_RESUME_HINTS.add(this);
         this.#inputCoordination = inputPresentation?.coordination !== false;
         this.#host = host;
         this.#terminal = host.connect(this);
@@ -1084,6 +1088,7 @@ export class OwnedUiSessionPresenter {
                 customViewport: this.#customViewport,
                 exitMode: this.backend.identity.disposed ? this.#fullscreenExitOutput : this.backend.settings.snapshot().fullscreenExitOutput,
                 resume: this.backend.identity.currentSessionResumeMetadata(),
+                soloResumeHint: SOLO_RESUME_HINTS.has(this),
                 transcript: () => this.root.exitTranscript(terminal.columns),
             });
         });

package/dist/cli/dispatch.js

@@ -7,6 +7,8 @@ export function cliUsage(capabilities) {
         "--session <path|id>",
         "--session-dir <dir> --session <path|id>",
         "solo",
+        "solo --session <path|id>",
+        "solo --session-dir <dir> --session <path|id>",
         ...(capabilities.developmentComparison ? ["pi"] : []),
         "help",
         "version",
@@ -36,6 +38,8 @@ export function cliHelp(capabilities) {
         `  ${command} --session <path|id>`,
         `  ${command} --session-dir <dir> --session <path|id>`,
         `  ${command} solo`,
+        `  ${command} solo --session <path|id>`,
+        `  ${command} solo --session-dir <dir> --session <path|id>`,
         ...(capabilities.developmentComparison ? [`  ${command} pi`] : []),
         `  ${command} help`,
         `  ${command} version`,
@@ -145,8 +149,17 @@ export function parseCliCommand(arguments_, capabilities) {
             return parsePackageCommand(rest, "pi");
         return capabilities.developmentComparison ? { kind: "launch", profileId: "pi", launchMode: "solo" } : { kind: "noop" };
     }
-    if (command === "solo")
-        return withoutArguments(rest, { kind: "launch", profileId: "a1", launchMode: "solo" });
+    if (command === "solo") {
+        if (rest.length === 0)
+            return { kind: "launch", profileId: "a1", launchMode: "solo" };
+        try {
+            const sessionSelection = parseSessionSelection(rest);
+            return { kind: "launch", profileId: "a1", launchMode: "solo", ...(sessionSelection === undefined ? {} : { sessionSelection }) };
+        }
+        catch (error) {
+            return { kind: "error", message: PRODUCT_TEXT.diagnostic(`could not parse solo session launch: ${error instanceof Error ? error.message : String(error)}`) };
+        }
+    }
     if (command === "update")
         return parseUpdate(rest);
     if (command === "session")

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

@@ -24,6 +24,8 @@ export interface OwnedUiCompositionOptions {
     readonly profileId?: string;
     /** Hide resident-only tab controls for the explicit direct single-agent launch. */
     readonly hideTabSettings?: boolean;
+    /** The explicit solo launch owns a mode-specific resume hint; resident fallback keeps the tabbed form. */
+    readonly soloResumeHint?: boolean;
     /** `off` withholds A1-specific surfaces from comparison profiles. */
     readonly ownedSurfaces?: "on" | "off";
     readonly projectTrustPrompt?: PiProjectTrustPreflightPrompt;

package/dist/composition/owned-ui.js

@@ -210,7 +210,7 @@ export async function composeOwnedUi(options = {}) {
             },
             presentation: {
                 ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
-                ...residentStartupPresentation(tabBridge !== null, options.residentFallbackNotice),
+                ...residentStartupPresentation(tabBridge !== null, options.residentFallbackNotice), soloResumeHint: options.soloResumeHint === true && tabBridge === null,
                 ...(clipboardDiagnostics === null ? {} : { input: { onEvent: event => clipboardDiagnostics.runtime(event) } }),
                 ...(viewportSettings === null ? {} : { viewportSettings }),
                 ...(backgroundSettings === null ? {} : { backgroundSettings }),
@@ -286,7 +286,7 @@ export async function composeOwnedUi(options = {}) {
             // Performance: the guardian notice loads beside first paint, never on the startup path.
             if (exitNoticePath)
                 exitNotice = import("../app/session-shell/exit-notice.js")
-                    .then(module => module.armExitNotice(backend, exitNoticePath), () => null);
+                    .then(module => module.armExitNotice(backend, exitNoticePath, options.soloResumeHint === true && tabBridge === null), () => null);
             presenter.start();
             releaseUpdates.start();
         },
@@ -345,17 +345,34 @@ function createPromptHistoryConfiguration(settings, backend, ownedSurfaces) {
 }
 function createStartupReleaseUpdateObservation(input) {
     const controller = new AbortController();
+    let timer;
+    let announcedVersion = null;
+    let eligible = input.mode === "auto";
+    let cadence = null;
+    let nextDelay = null;
+    let started = false;
     const observe = async () => {
-        const check = input.checkForNewerRelease
-            ?? (await import("../foundation/release/latest-release.js")).checkForNewerRelease;
+        // Performance: registry code and its locks stay outside the first-frame startup graph.
+        const releases = await import("../foundation/release/latest-release.js");
+        cadence = releases.UPDATE_CHECK_INTERVAL_MS;
+        nextDelay = cadence;
+        const check = input.checkForNewerRelease ?? releases.checkForNewerRelease;
         const runningVersion = input.packageVersion ?? await readPackageVersion();
         const discoveryVersion = input.mode === "notify" ? input.notificationVersion ?? runningVersion : runningVersion;
-        const release = await check({
+        const options = {
             runningVersion: discoveryVersion,
             configDir: input.configDir,
             interactive: process.stdout.isTTY === true,
             settingMode: input.mode,
-        });
+            signal: controller.signal,
+            onNextCheckDelay: milliseconds => { nextDelay = milliseconds; },
+        };
+        // Invariant: opt-outs never arm a recurring timer, nor read the cache or probe the registry.
+        if (input.checkForNewerRelease === undefined && releases.startupReleaseCheckSkipReason(options) !== null) {
+            eligible = false;
+            return;
+        }
+        const release = await check(options);
         if (release === null || controller.signal.aborted)
             return;
         if (input.mode === "notify") {
@@ -365,14 +382,27 @@ function createStartupReleaseUpdateObservation(input) {
         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) {
+            if (installed !== null && installed !== announcedVersion && !controller.signal.aborted) {
+                announcedVersion = installed;
                 input.backend.extensions.announceReleaseUpdate({ status: "installed", version: installed });
             }
         }
     };
+    const run = async () => {
+        try {
+            await observe();
+        }
+        catch { /* Rationale: best effort; retry on the next interval. */ }
+        if (eligible && cadence !== null && !controller.signal.aborted) {
+            timer = setTimeout(() => { void run(); }, nextDelay ?? cadence);
+            timer.unref?.();
+        }
+    };
     return {
-        start() { void observe().catch(() => undefined); },
-        stop() { controller.abort(); },
+        start() { if (started || controller.signal.aborted)
+            return; started = true; void run(); },
+        stop() { controller.abort(); if (timer !== undefined)
+            clearTimeout(timer); },
     };
 }
 export { watchSharedSettings } from "./owned-settings.js";

package/dist/features/launch/intent.js

@@ -1,8 +1,8 @@
 import { sessionSelectionArguments } from "../../foundation/lifecycle/index.js";
 export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
 export function interactiveLaunchIntent(profileId, sessionSelection, launchMode = profileId === "a1" ? "tabs" : "solo") {
-    if (sessionSelection !== undefined && (profileId !== "a1" || launchMode === "solo")) {
-        throw new Error("session selection requires the normal tabbed A1 launch");
+    if (sessionSelection !== undefined && profileId !== "a1") {
+        throw new Error("session selection requires the A1 profile");
     }
     if (profileId === "pi" && launchMode !== "solo")
         throw new Error("the Pi comparison launch is always solo");

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);
@@ -67,7 +67,7 @@ async function runBootstrapAttempt(options, retriesRemaining) {
                     resident.executable.entry,
                     "attach", "--endpoint", resident.endpoint, "--cwd", process.cwd(), "--clear-exit-ms", String(RESIDENT_DETACH_INTERVAL_MS),
                     "--profile", environment[PRODUCT_IDENTITY.environment.profileHome] ?? paths.configDir,
-                    "--settings-file", resolve(agentProfileDir, "settings.json"),
+                    "--settings-file", resolve(agentProfileDir, "settings.json"), "--accent-color", (await residentLaunchSettings).accentColor,
                     "--data-dir", paths.dataDir, "--runtime-dir", paths.runtimeDir,
                     "--release-root", release.releaseRoot, "--node-executable", process.execPath,
                 ]),

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/foundation/release/update.js

@@ -239,7 +239,7 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
         },
     };
 }
-const PROGRESS_BAR_WIDTH = 40;
+const PROGRESS_BAR_WIDTH = 38;
 const PROGRESS_TICK_MS = 200;
 /**
  * Copying the release owns 78–92 and is reported file by file, so the bar crosses

package/dist/foundation/resident-tabs/settings.d.ts

@@ -1,8 +1,11 @@
+import { OWNED_SETTING_DECLARATIONS } from "../../ui/settings/index.js";
 export declare const RESIDENT_TABS_MAX_CONCURRENT_STARTS = 2;
 export declare const RESIDENT_TABS_MAX_CONCURRENT_STARTS_CAP = 8;
 export declare const RESIDENT_TABS_PREWARM_COUNT = 1;
 export declare const RESIDENT_TABS_PREWARM_CAP = 1;
+type ResidentAccentColor = (typeof OWNED_SETTING_DECLARATIONS.accentColor.allowedValues)[number];
 export interface ResidentTabLaunchSettings {
+    readonly accentColor: ResidentAccentColor;
     readonly tabsAutoName: boolean;
     readonly maxConcurrentStarts: number;
     readonly prewarmCount: number;
@@ -10,3 +13,4 @@ export interface ResidentTabLaunchSettings {
 }
 /** Read only resident-launch values before any UI or extension module is loaded. */
 export declare function readResidentTabLaunchSettings(profileDir: string, namespace?: string, legacyConfigDir?: string, profileId?: string): Promise<ResidentTabLaunchSettings>;
+export {};

package/dist/foundation/resident-tabs/settings.js

@@ -7,6 +7,7 @@ export const RESIDENT_TABS_MAX_CONCURRENT_STARTS_CAP = 8;
 export const RESIDENT_TABS_PREWARM_COUNT = 1;
 export const RESIDENT_TABS_PREWARM_CAP = 1;
 const DEFAULTS = Object.freeze({
+    accentColor: "blue",
     tabsAutoName: true,
     maxConcurrentStarts: RESIDENT_TABS_MAX_CONCURRENT_STARTS,
     prewarmCount: RESIDENT_TABS_PREWARM_COUNT,
@@ -44,12 +45,13 @@ export async function readResidentTabLaunchSettings(profileDir, namespace = "a1"
 }
 function resolveLaunchValues(document, migrations) {
     const resolution = resolveOwnedUiSettings({
-        declarations: [OWNED_SETTING_DECLARATIONS.tabsAutoName],
+        declarations: [OWNED_SETTING_DECLARATIONS.accentColor, OWNED_SETTING_DECLARATIONS.tabsAutoName],
         migrations,
         document,
         currentVersion: OWNED_UI_SETTINGS_VERSION,
     });
     return {
+        accentColor: settingValue(resolution, "accentColor"),
         tabsAutoName: settingValue(resolution, "tabsAutoName") === true,
         maxConcurrentStarts: RESIDENT_TABS_MAX_CONCURRENT_STARTS,
         prewarmCount: RESIDENT_TABS_PREWARM_COUNT,

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

@@ -7,7 +7,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-10-28T17:55:49.435Z",
+  "builtAt": "2026-10-29T18:55:24.681Z",
   "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-28T17:59:01.060Z",
+  "builtAt": "2026-10-29T18:58:27.392Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "5f1a93ca9a050c2769a4e322f4d765b00f2ccc9451bcde7ac978b573ee544bef",
-    "size": 6019328
+    "sha256": "4c5b6471dd48f1f571c226022b01038dbba09798880ead564bd174617e60fc00",
+    "size": 6019520
   },
   "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-28T17:55:56.614Z",
+  "builtAt": "2026-10-29T18:55:32.496Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "783a65f0de287a1c02cd5429dbe97bc8633f4cc8a7b92e3e961180b9bdcff814",

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

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-apple-darwin",
   "capability": "supported",
-  "builtAt": "2026-10-28T18:01:29.016Z",
+  "builtAt": "2026-10-29T19:00:47.347Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "5b2b2de17a50a371271c32546cc3c89bc6b16a96c39a534174fe5bb4ca1d60d6",
-    "size": 6562120
+    "sha256": "c9b2b998c06bb582db4b90639b8dbacdc698ef6c4b0361a2a0d19fbe9adfadbf",
+    "size": 6562328
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

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

@@ -7,7 +7,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-28T17:55:36.629Z",
+  "builtAt": "2026-10-29T18:55:03.862Z",
   "artifact": {
     "filename": "process-guardian.node",
     "sha256": "118e5954e3864672bd8482ab7edf419cb27dcdf2533720316979b7f5cc5a53a5",

package/dist/native/linux-x64/terminal-host.manifest.json

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-unknown-linux-gnu",
   "capability": "supported",
-  "builtAt": "2026-10-28T17:58:24.749Z",
+  "builtAt": "2026-10-29T18:58:26.007Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "d55bf113092dcb926a6fb10961f30207b3624c3727357de0913a01a40026f594",
-    "size": 7303320
+    "sha256": "5ab7264cbbd505e2455b05d11b2ca2a8378d007f20e0730e25cb84a6e98096cf",
+    "size": 7302056
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

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

@@ -7,10 +7,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-10-28T17:56:27.071Z",
+  "builtAt": "2026-10-29T18:55:37.021Z",
   "artifact": {
     "filename": "process-guardian.node",
-    "sha256": "f071fdb99dd7c653701160d127e6f5263bccc043fe8d28c133fdaac44e491cfa",
+    "sha256": "b11440d8ba81b69e18061dd2e73934ce4723ef3250c19a47a1563378d045268a",
     "size": 402432
   },
   "provenance": {

package/dist/native/win32-x64/terminal-host.manifest.json

@@ -9,11 +9,11 @@
   "architecture": "x64",
   "target": "x86_64-pc-windows-msvc",
   "capability": "supported",
-  "builtAt": "2026-10-28T17:58:56.213Z",
+  "builtAt": "2026-10-29T18:59:32.923Z",
   "artifact": {
     "filename": "terminal-host.node",
-    "sha256": "5f5b7bf855be2b8948fffc4de53a3456672ce7646d2c0dfc3c0ae9eb847980cf",
-    "size": 6392832
+    "sha256": "f6e448a810795d4d7db437d591e43fbf998e05b63f6cac37f56d3270e422c861",
+    "size": 6393344
   },
   "entry": {
     "filename": "dist/foundation/resident-tabs/host-entry.js",

package/dist/ui/settings/declarations.d.ts

@@ -30,7 +30,7 @@ export declare const OWNED_SETTING_DECLARATIONS: Readonly<{
             id: "generic";
             title: "Generic";
         }>;
-        description: "Auto installs verified channel updates silently, Notify shows the current update notice, and No leaves updates manual. Checks use the public npm registry; applies on next start.";
+        description: "Auto checks the running channel every 15 minutes while open and installs verified updates silently. Notify checks on startup and shows an update notice; No leaves updates manual. Applies on next start.";
         application: "restart";
         defaultValue: "auto";
         allowedValues: readonly ["auto", "notify", "no"];

package/dist/ui/settings/declarations.js

@@ -24,7 +24,7 @@ export const OWNED_SETTING_DECLARATIONS = Object.freeze({
         id: "updateCheck",
         label: "Update",
         section: GENERIC_SECTION,
-        description: "Auto installs verified channel updates silently, Notify shows the current update notice, and No leaves updates manual. Checks use the public npm registry; applies on next start.",
+        description: "Auto checks the running channel every 15 minutes while open and installs verified updates silently. Notify checks on startup and shows an update notice; No leaves updates manual. Applies on next start.",
         application: "restart",
         defaultValue: "auto",
         allowedValues: Object.freeze(["auto", "notify", "no"]),

package/docs/features/launch-profiles.md

@@ -6,10 +6,11 @@
 |---|---|---|
 | `a1` | A1 | `~/.a1/agent` |
 | `a1 --session <path\|id>` | Resume a persisted A1 session | `~/.a1/agent` (or explicitly selected storage) |
-| `a1 solo` | A1 direct single-agent mode | `~/.a1/agent` |
+| `a1 solo` | Fresh A1 direct single-agent mode | `~/.a1/agent` |
+| `a1 solo --session <path\|id>` | Resume a persisted A1 session in direct single-agent mode | `~/.a1/agent` (or explicitly selected storage) |
 | `a1 pi` | Pi-compatible direct comparison surface using the ordinary Pi profile | ordinary `~/.pi/agent` |
 
-`a1 solo` is available in release and prerelease builds. It starts A1 in single agent mode, is argument-free, and omits both the tab strip and the Tabs settings section.
+`a1 solo` is available in release and prerelease builds. Without arguments it starts a fresh single-agent session; with `--session` and optional `--session-dir` it resumes a saved session. Both forms omit the tab strip and the Tabs settings section.
 
 `a1 pi` is a development instrument for comparing A1 against pinned Pi. Prerelease builds — what `a1 update --develop` or `a1 update --develop <number>` installs — expose it. A release build does not recognize the launch form. Repository development can run the comparison directly with `npm start:pi`.
 
@@ -36,16 +37,18 @@ Run Pi’s normal `/login` independently in each profile that needs stored authe
 
 ## Resume a session
 
-After a conversation has been persisted, exit A1 and run the command it prints from the original project directory:
+After a conversation has been persisted, exit A1 and run the command it prints from the original project directory. Exited solo sessions print the solo form; tabbed A1 sessions keep the tabbed form:
 
 ```sh
 a1 --session <id>
 a1 --session-dir '/path/to/session store' --session <id>
+a1 solo --session <id>
+a1 solo --session-dir '/path/to/session store' --session <id>
 ```
 
 `--session` also accepts a `.jsonl` file path; `--session-dir` may come before or after it. Explicit storage overrides `PI_CODING_AGENT_SESSION_DIR`, which overrides default storage. IDs are searched in the current project before other projects within the A1 store. A cross-project ID match asks before creating a fork with a new identity; an explicit file resumes directly using its stored working directory. Missing or invalid targets fail rather than create an empty replacement.
 
-Resume uses the shipped Pi's public restoration behavior, including the compaction format it writes. It sends no model prompt by itself and does not recover, convert, or modify an unrelated conversation. The selected session opens in a new A1 tab or focuses the tab already holding it. Pi picker/continue CLI aliases, `a1 solo --session`, and `a1 pi --session` are not supported; in-UI `/resume` is unchanged.
+Resume uses the shipped Pi's public restoration behavior, including the compaction format it writes. It sends no model prompt by itself and does not recover, convert, or modify an unrelated conversation. A tabbed selection opens in a new A1 tab or focuses the tab already holding it; a solo selection opens in the direct strip-free UI without starting the resident host. A live session remains protected by its single-writer lease. Pi picker/continue CLI aliases and `a1 pi --session` are not supported; in-UI `/resume` is unchanged.
 
 Regression evidence creates disposable sessions through Pi 0.84.2, then executes the emitted command through the packed public entry, bootstrap, guardian, and owned UI. Default/custom storage, Windows Git Bash quoting, supervisor restart, failure cleanup, and simultaneous distinct selections are covered in `test/foundation/release/session-resume.integration.test.ts`. CI runs it in the resource-sensitive `package-smoke` scope, not the fast remainder. Unsupported synthetic retained-tail certification is separate deferred work.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.2.7-dev.1222",
+  "version": "0.2.7-dev.1226",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",
@@ -118,7 +118,7 @@
     "@mariozechner/clipboard": "^0.3.9"
   },
   "publication": {
-    "source": "0ec0a4fd915c5e452ca135159dcb58e810dea96f",
-    "pullRequest": 847
+    "source": "9fccb714f2912d0acdd9e7a4ed05d6d8423a82bd",
+    "pullRequest": 851
   }
 }