@timurproko/a1 0.2.7-dev.746 → 0.2.7-dev.767

package/bin/tab-launch-context.d.ts

@@ -15,4 +15,9 @@ export function assignFreshSessionRuntimeId(
 export function consumeTabLaunchContext(
   arguments_: readonly string[],
   environment: Record<string, string | undefined>,
-): { readonly uiArguments: string[]; readonly tabCredentials: TabLaunchCredentials | undefined };
+): {
+  readonly uiArguments: string[];
+  readonly tabCredentials: TabLaunchCredentials | undefined;
+  readonly tabDataDir?: string;
+  readonly tabIncarnation?: number;
+};

package/bin/tab-launch-context.js

@@ -28,9 +28,18 @@ export function consumeTabLaunchContext(arguments_, environment) {
   const tabArgument = uiArguments.indexOf("--tab");
   const tabMode = tabArgument !== -1;
   if (tabMode) uiArguments.splice(tabArgument, 1);
+  const dataArgument = uiArguments.indexOf("--tab-data-dir");
+  const tabDataDir = dataArgument === -1 ? undefined : uiArguments[dataArgument + 1];
+  if (dataArgument !== -1) uiArguments.splice(dataArgument, 2);
+  const incarnationArgument = uiArguments.indexOf("--tab-incarnation");
+  const tabIncarnation = incarnationArgument === -1 ? undefined : Number(uiArguments[incarnationArgument + 1]);
+  if (incarnationArgument !== -1) uiArguments.splice(incarnationArgument, 2);
   const [tabId, token, endpoint] = TAB_ENVIRONMENT_NAMES.map(name => environment[name]);
   for (const name of TAB_ENVIRONMENT_NAMES) delete environment[name];
   if (!tabMode) return { uiArguments, tabCredentials: undefined };
-  if (!tabId || !token || !endpoint) throw new Error("A1 tab mode requires bridge credentials");
-  return { uiArguments, tabCredentials: { tabId, token, endpoint } };
+  if (!tabId || !token || !endpoint || !tabDataDir || tabDataDir.includes("\0")
+    || typeof tabIncarnation !== "number" || !Number.isSafeInteger(tabIncarnation) || tabIncarnation < 1) {
+    throw new Error("A1 tab mode requires bridge credentials, recovery directory, and incarnation");
+  }
+  return { uiArguments, tabCredentials: { tabId, token, endpoint }, tabDataDir, tabIncarnation };
 }

package/bin/ui.js

@@ -2,7 +2,7 @@
 
 // Security: this helper has no A1, Pi, tool, or extension dependency and erases credentials before those modules load.
 const { assignFreshSessionRuntimeId, consumeTabLaunchContext, formatResidentFallbackNotice } = await import("./tab-launch-context.js");
-const { uiArguments, tabCredentials } = consumeTabLaunchContext(process.argv.slice(2), process.env);
+const { uiArguments, tabCredentials, tabDataDir, tabIncarnation } = consumeTabLaunchContext(process.argv.slice(2), process.env);
 
 // Invariant: one terminal module identity per process, decided before any A1 or Pi module loads.
 const { installPinnedPiTuiResolver } = await import("./module-resolver.js");
@@ -22,11 +22,13 @@ if (profile === "a1") {
 }
 const { installFatalExit } = await import("../dist/foundation/terminal-cleanup/fatal-exit.js");
 const { resolveProductPaths } = await import("../dist/foundation/lifecycle/paths.js");
-const { join } = await import("node:path");
+const { dirname, join } = await import("node:path");
 /** @type {{ dispose(): void | Promise<unknown> } | undefined} */
 let runningApplication;
 const fatal = profile === "a1" ? installFatalExit({
-  directory: join(resolveProductPaths().runtimeDir, "crashes"),
+  directory: tabDataDir === undefined
+    ? join(resolveProductPaths().runtimeDir, "crashes")
+    : join(dirname(tabDataDir), "diagnostics"),
   ...(launchContext.releaseId === undefined ? {} : { releaseId: launchContext.releaseId }),
   dispose: () => runningApplication?.dispose(),
 }) : undefined;
@@ -59,6 +61,8 @@ const sessionSelection = parseSessionSelection(uiArguments);
 Promise.resolve().then(async () => {
   const tab = tabCredentials === undefined ? undefined : {
     bridge: new (await import("../dist/foundation/resident-tabs/bridge-client.js")).TabBridgeClient({ credentials: tabCredentials }),
+    dataDir: /** @type {string} */ (tabDataDir),
+    incarnation: /** @type {number} */ (tabIncarnation),
   };
   if (sessionSelection && profile !== "a1") throw new Error("session selection requires the normal A1 profile");
   return runSelectedInteractiveRuntime(profile, {

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

@@ -46,6 +46,29 @@ export interface OwnedUiShellEngineOptions {
     /** Resident tab quit routes detach the outer client without stopping this engine session. */
     readonly residentTab?: {
         requestDetach(): Promise<boolean>;
+        requestRestart?(): Promise<boolean>;
+        reportStatus?(status: "working" | "idle" | "stalled"): void;
+        readonly stallNoticeSeconds?: number;
+        admit?(input: {
+            readonly sessionId: string;
+            readonly sessionFile: string | null;
+            readonly kind: "prompt" | "steer" | "follow-up";
+            readonly text: string;
+            readonly images?: readonly unknown[];
+        }): Promise<{
+            readonly id: string;
+        }>;
+        dispatched?(): void;
+        correlated?(submissionId: string, entryId: string): Promise<void>;
+        checkpoint?(text: string): void;
+        gracefulStop?(sessionFile: string | null): Promise<void>;
+        readonly recovered?: {
+            readonly prompts: readonly {
+                readonly id: string;
+                readonly text: string;
+            }[];
+            readonly draft: string | null;
+        };
         readonly unavailableNotice?: string;
     };
 }

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

@@ -54,6 +54,9 @@ export class OwnedUiSessionPresenter {
     #routeHost;
     #startupRoute;
     #startupRouteTimer;
+    #residentProgressTimer;
+    #residentWorking = false;
+    #residentStalled = false;
     #dialogHandle;
     #sequence = 0;
     #editorRevision = 0;
@@ -204,6 +207,7 @@ export class OwnedUiSessionPresenter {
                 onDequeue: () => this.restoreQueuedInput(),
                 onEditorChange: text => {
                     this.#editorRevision++;
+                    this.#residentTabOptions?.checkpoint?.(text);
                     promptSuggestionController?.abortPending();
                     if (text.length === 0) {
                         // Concurrency: the editor synchronizes deletion-owned autocomplete after onChange.
@@ -265,6 +269,7 @@ export class OwnedUiSessionPresenter {
             // Invariant: the presenter owns its root (theme subscription and helper clients) and disposes it once the
             // terminal no longer renders it.
             constructed.push(() => this.root.dispose());
+            this.#restoreResidentInput();
             const initialPiSettings = this.backend.settings.snapshot();
             this.#programStatus = new ProgramStatusReporter(status => this.#terminal.setProgramStatus(status), () => this.view().status.footer?.sessionName ?? undefined);
             this.#reloadPresentation = reloadPresentation;
@@ -476,6 +481,7 @@ export class OwnedUiSessionPresenter {
                         this.#settleStoppedLifecycle();
                     return;
                 }
+                this.#observeResidentProgress(event);
                 // Performance: a streamed chunk names one block, and touching only that block is what keeps the
                 // cost of a chunk the same in a long session as in a new one. Everything else
                 // resynchronizes the view, which is cheap next to re-reading the transcript.
@@ -781,15 +787,38 @@ export class OwnedUiSessionPresenter {
         const type = this.view().lifecycle === "busy" ? "steer" : "prompt";
         this.#rememberInput(this.root.omitUnsentPromptImages(displayInput).trim(), type);
         this.root.resumeViewportFollowing();
-        const finishSending = prepared.images.length === 0 ? () => { } : this.root.beginImageSubmissionStatus();
+        const command = {
+            type,
+            correlationId: this.#correlation(type),
+            sessionId: this.backend.identity.sessionId,
+            text: input,
+            ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
+        };
+        let submission;
         try {
-            return await this.#execute({
-                type,
-                correlationId: this.#correlation(type),
-                sessionId: this.backend.identity.sessionId,
+            submission = await this.#residentTabOptions?.admit?.({
+                sessionId: command.sessionId,
+                sessionFile: this.#currentSessionFile(),
+                kind: type,
                 text: input,
                 ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
-            }, displayInput);
+            });
+        }
+        catch {
+            if (this.root.editor.getText().length === 0)
+                this.root.editor.setText(displayInput);
+            const message = "Prompt was not sent because its recovery journal could not be synchronized.";
+            this.#reportSubmissionError(undefined, message);
+            return rejected(message);
+        }
+        const finishSending = prepared.images.length === 0 ? () => { } : this.root.beginImageSubmissionStatus();
+        try {
+            const result = await this.#execute(command, displayInput);
+            if (submission !== undefined && result.outcome !== "rejected") {
+                this.#residentTabOptions?.dispatched?.();
+                await this.#residentTabOptions?.correlated?.(submission.id, command.correlationId).catch(() => undefined);
+            }
+            return result;
         }
         finally {
             finishSending();
@@ -1183,9 +1212,75 @@ export class OwnedUiSessionPresenter {
             this.#resolveStoppedLifecycle();
         }
     }
+    #restoreResidentInput() {
+        const recovered = this.#residentTabOptions?.recovered;
+        if (recovered === undefined)
+            return;
+        const prompts = recovered.prompts.map(prompt => prompt.text).filter(Boolean);
+        if (prompts.length > 0) {
+            this.root.editor.setText(prompts[0]);
+            if (recovered.draft)
+                this.root.editor.addToHistory(recovered.draft);
+            for (const additional of prompts.slice(1))
+                this.root.editor.addToHistory(additional);
+            this.root.appendWorkflowStatus(recovered.draft
+                ? `Recovered an unfinished prompt; the prior draft and ${Math.max(0, prompts.length - 1)} additional prompt${prompts.length === 2 ? "" : "s"} are in editor history.`
+                : `Recovered an unfinished prompt${prompts.length > 1 ? `; ${prompts.length - 1} additional prompts are in editor history` : ""}.`);
+        }
+        else if (recovered.draft) {
+            this.root.editor.setText(recovered.draft);
+            this.root.appendWorkflowStatus("Recovered the editor draft from the previous tab process.");
+        }
+    }
+    #currentSessionFile() {
+        const direct = this.backend.identity.currentSessionFile?.();
+        if (direct !== undefined && direct !== null)
+            return direct;
+        const resume = this.backend.identity.currentSessionResumeMetadata();
+        return resume === null ? null : `${resume.sessionDir}/${resume.sessionId}`;
+    }
     #residentTab() {
         return this.#residentTabOptions;
     }
+    #observeResidentProgress(event) {
+        const resident = this.#residentTabOptions;
+        const seconds = resident?.stallNoticeSeconds;
+        if (resident === undefined || seconds === undefined)
+            return;
+        if (event.type === "session-lifecycle") {
+            this.#residentWorking = event.lifecycle === "busy";
+            if (!this.#residentWorking) {
+                if (this.#residentProgressTimer !== undefined)
+                    clearTimeout(this.#residentProgressTimer);
+                this.#residentProgressTimer = undefined;
+                this.#residentStalled = false;
+                resident.reportStatus?.("idle");
+                return;
+            }
+        }
+        else if (!this.#residentWorking || ![
+            "transcript-block", "session-view", "assistant-message-completed", "agent-run-started",
+        ].includes(event.type)) {
+            return;
+        }
+        if (this.#residentStalled) {
+            this.#residentStalled = false;
+            resident.reportStatus?.("working");
+        }
+        if (this.#residentProgressTimer !== undefined)
+            clearTimeout(this.#residentProgressTimer);
+        this.#residentProgressTimer = setTimeout(() => {
+            this.#residentProgressTimer = undefined;
+            if (this.#disposed || !this.#residentWorking)
+                return;
+            this.#residentStalled = true;
+            resident.reportStatus?.("stalled");
+            const minutes = Math.max(1, Math.round(seconds / 60));
+            this.root.appendWorkflowStatus(`No progress for ${minutes} min — Esc interrupts · /restart-tab restarts`);
+            this.#terminal.requestRender();
+        }, seconds * 1_000);
+        this.#residentProgressTimer.unref?.();
+    }
     async runWorkflow(request) {
         if (request.command === "quit")
             return this.shutdown();
@@ -1443,6 +1538,9 @@ export class OwnedUiSessionPresenter {
             if (this.#startupRouteTimer !== undefined)
                 clearTimeout(this.#startupRouteTimer);
             this.#startupRouteTimer = undefined;
+            if (this.#residentProgressTimer !== undefined)
+                clearTimeout(this.#residentProgressTimer);
+            this.#residentProgressTimer = undefined;
         });
         attempt(() => this.#promptSuggestions?.dispose());
         attempt(() => this.#unsubscribePromptSuggestions());
@@ -1479,6 +1577,8 @@ export class OwnedUiSessionPresenter {
             }
             await historyCleanup.catch(() => false); // Security: background durability outcomes never enter terminal output.
             await boundedCleanup(() => pasteCleanup).catch(error => settled.push(error));
+            await boundedCleanup(() => this.#residentTabOptions?.gracefulStop?.(this.#currentSessionFile()) ?? Promise.resolve())
+                .catch(error => settled.push(error));
             await boundedCleanup(() => this.backend.extensions.unbindExtensionUi()).catch(error => settled.push(error));
             return settled;
         };
@@ -1668,6 +1768,12 @@ export class OwnedUiSessionPresenter {
         const argument = separator < 0 ? "" : body.slice(separator + 1).trimStart();
         if (this.#routeHost?.claims(name))
             return this.#openOwnedRoute(name);
+        if (name === "restart-tab" && this.#residentTabOptions?.requestRestart !== undefined) {
+            const accepted = await this.#residentTabOptions.requestRestart().catch(() => false);
+            this.root.appendWorkflowStatus(accepted ? "Restarting resident tab…" : "Resident tab restart is unavailable.");
+            this.#terminal.requestRender();
+            return accepted ? { outcome: "completed", diagnostic: null } : rejected("resident tab restart is unavailable");
+        }
         if (this.#isWorkflowRoute(name))
             return this.runWorkflow({ command: name, argument });
         if (this.#skillsCollapsed()) {

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

@@ -11,6 +11,7 @@ import type { AgentSettingsPort } from "../contracts/agent-engine/index.js";
 import type { OwnedUiPromptSuggestionGeneratorPort, UiAccentColor } from "../contracts/owned-ui/index.js";
 import type { ReleaseNoteCatalog } from "../features/owned-ui/release-notes.js";
 import type { TabBridgeClient } from "../foundation/resident-tabs/bridge-client.js";
+import { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.js";
 /**
  * The session backend composition wires: the owned-UI port, the prompt-suggestion generator, and
  * the agent settings port. `settingsPort` stays outside the owned-UI contract because its type
@@ -59,6 +60,8 @@ export interface OwnedUiCompositionOptions {
     /** Private credentials were consumed by the entry before composition or extensions loaded. */
     readonly tab?: {
         readonly bridge: TabBridgeClient;
+        readonly dataDir: string;
+        readonly incarnation: number;
     };
     /** One prompt-adjacent notice explaining why an opted-in resident launch fell back. */
     readonly residentFallbackNotice?: string;
@@ -79,4 +82,4 @@ export declare function residentStartupPresentation(resident: boolean, fallbackN
 };
 export declare function composeOwnedUiApplication(options?: OwnedUiCompositionOptions): Promise<OwnedUiApplicationPort>;
 export declare function composeOwnedUi(options?: OwnedUiCompositionOptions): Promise<OwnedUiComposition>;
-export declare function bindResidentTabBridge(tabBridge: TabBridgeClient, backend: Pick<ComposedSessionBackend, "identity" | "session">): Promise<() => void>;
+export declare function bindResidentTabBridge(tabBridge: TabBridgeClient, backend: Pick<ComposedSessionBackend, "identity" | "session">, recovery?: Pick<ResidentTabRecovery, "settled"> | null): Promise<() => void>;

package/dist/composition/owned-ui.js

@@ -4,7 +4,7 @@ import { PRODUCT_IDENTITY } from "../product-identity.js";
 import { PromptHistoryService } from "../features/prompt-history/service.js";
 import { PromptImageSidecar } from "../features/prompt-history/image-sidecar.js";
 import { resolvePromptHistoryPath } from "../features/prompt-history/paths.js";
-import { resolvePromptHistoryDataDir } from "../features/launch/profile-paths.js";
+import { resolveLaunchProfilePaths, resolvePromptHistoryDataDir } from "../features/launch/profile-paths.js";
 import { resolveProductPaths } from "../foundation/lifecycle/paths.js";
 import { applyConfiguredPiTheme, getAvailablePiThemes, setPiAccentColor, setPiPackageBorderProjectionEnabled } from "../integrations/pi/components/upstream/theme/theme.js";
 import { createPiEngineHost } from "../integrations/pi/engine/host.js";
@@ -18,6 +18,7 @@ import { createPiTerminalBridge } from "../integrations/pi/tui-runtime/presentat
 import { createOwnedRouteHost } from "./settings-route-host.js";
 import { renderPiShellChangelogLines } from "../integrations/pi/components/shell-presenters-info.js";
 import { nativeHyperlinkStyle } from "../ui/components/spans.js";
+import { ResidentTabRecovery } from "../foundation/resident-tabs/recovery.js";
 const SESSION_RUNTIME_REFRESH_MS = 30_000;
 export function residentStartupPresentation(resident, fallbackNotice) {
     if (resident)
@@ -87,13 +88,16 @@ export async function composeOwnedUi(options = {}) {
         sessionRuntimeRefreshTimer.unref();
     };
     const productPaths = resolveProductPaths();
+    const profilePaths = resolveLaunchProfilePaths();
     // Rationale: the manager reads the engine's settings port lazily, after the session exists.
     let backend;
     const settings = options.profileId === undefined
         ? null
         : new OwnedSettingsManager({
-            configDir: resolveProductPaths().configDir,
+            profileDir: profilePaths.agentProfile,
             profileId: options.profileId,
+            namespace: PRODUCT_IDENTITY.commandName,
+            legacyConfigDir: productPaths.configDir,
             agentProvider: () => backend.settingsPort(),
             hiddenAgentSettingIds: ["fullscreenWheelScrollLines"],
             agentSettingLabelOverrides: { fullscreenCopyOnSelect: "Copy on select" },
@@ -126,7 +130,17 @@ export async function composeOwnedUi(options = {}) {
         throw error;
     }
     const tabBridge = options.tab?.bridge ?? null;
-    const unsubscribeTabBridge = tabBridge === null ? () => { } : await bindResidentTabBridge(tabBridge, backend);
+    let recoveryDegraded = false;
+    let presentRecoveryDegraded = (_degraded) => { };
+    const tabRecovery = options.tab === undefined ? null : new ResidentTabRecovery(options.tab.dataDir, {
+        onDegraded: degraded => {
+            recoveryDegraded = degraded;
+            options.tab.bridge.degraded(degraded);
+            presentRecoveryDegraded(degraded);
+        },
+    });
+    const recoveredTabInput = await tabRecovery?.initialize(currentBackendSessionFile(backend), backend.identity.sessionId);
+    const unsubscribeTabBridge = tabBridge === null ? () => { } : await bindResidentTabBridge(tabBridge, backend, tabRecovery);
     let releaseNotes = null;
     let releaseNotesFailure;
     if (ownedSurfaces) {
@@ -235,7 +249,18 @@ export async function composeOwnedUi(options = {}) {
                     },
                 }),
                 ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
-                ...(tabBridge === null ? {} : { residentTab: { requestDetach: () => tabBridge.requestDetach() } }),
+                ...(tabBridge === null || tabRecovery === null ? {} : { residentTab: {
+                        requestDetach: () => tabBridge.requestDetach(),
+                        requestRestart: () => tabBridge.requestRestart(),
+                        reportStatus: status => tabBridge.status(status),
+                        stallNoticeSeconds: settings?.value("tabsStallNoticeSeconds") ?? 300,
+                        admit: input => tabRecovery.admit({ ...input, incarnation: options.tab.incarnation }),
+                        dispatched: () => tabRecovery.dispatched(),
+                        correlated: (submissionId, entryId) => tabRecovery.correlated(submissionId, entryId),
+                        checkpoint: text => tabRecovery.checkpoint(text),
+                        gracefulStop: sessionFile => tabRecovery.gracefulStop(sessionFile),
+                        ...(recoveredTabInput === undefined ? {} : { recovered: recoveredTabInput }),
+                    } }),
             },
             presentation: {
                 ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
@@ -264,6 +289,14 @@ export async function composeOwnedUi(options = {}) {
         // the host and paints once attached.
         terminalHost = createdTerminalHost = new OwnedUiTerminalHost(sessionTerminalHostOptions(presenterOptions));
         presenter = new OwnedUiSessionPresenter(terminalHost, presenterOptions);
+        presentRecoveryDegraded = degraded => {
+            if (!degraded)
+                return;
+            presenter.root.appendWorkflowStatus("draft recovery degraded");
+            terminalHost.runtime.requestRender();
+        };
+        if (recoveryDegraded)
+            presentRecoveryDegraded(true);
         terminalHost.attach(presenter);
     }
     catch (error) {
@@ -341,22 +374,35 @@ export async function composeOwnedUi(options = {}) {
     };
     return { application, settings };
 }
-export async function bindResidentTabBridge(tabBridge, backend) {
+export async function bindResidentTabBridge(tabBridge, backend, recovery = null) {
     await tabBridge.start().catch(() => false);
     tabBridge.status("starting");
+    const currentSessionFile = () => currentBackendSessionFile(backend);
     const announceSession = () => {
-        const resume = backend.identity.currentSessionResumeMetadata();
-        tabBridge.session(resume === null ? null : `${resume.sessionDir}/${resume.sessionId}`, backend.session.view().status.footer?.sessionName ?? null);
+        tabBridge.session(currentSessionFile(), backend.session.view().status.footer?.sessionName ?? null);
     };
+    let working = false;
     announceSession();
     return backend.session.onEvent(event => {
         if (event.type === "session-lifecycle") {
-            tabBridge.status(event.lifecycle === "busy" ? "working" : event.lifecycle === "starting" ? "starting" : "idle");
+            const wasWorking = working;
+            working = event.lifecycle === "busy";
+            tabBridge.status(working ? "working" : event.lifecycle === "starting" ? "starting" : "idle");
+            if (wasWorking && !working && recovery !== null) {
+                void recovery.settled(currentSessionFile()).catch(() => tabBridge.degraded(true));
+            }
         }
         if (event.type === "session-view")
             announceSession();
     });
 }
+function currentBackendSessionFile(backend) {
+    const direct = backend.identity.currentSessionFile?.();
+    if (direct !== undefined && direct !== null)
+        return direct;
+    const resume = backend.identity.currentSessionResumeMetadata();
+    return resume === null ? null : `${resume.sessionDir}/${resume.sessionId}`;
+}
 async function readPackageVersion() {
     const manifest = JSON.parse(await readFile(new URL("../../package.json", import.meta.url), "utf8"));
     const version = manifest?.version;

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

@@ -36,6 +36,7 @@ export interface OwnedUiSessionIdentityPort {
     /** Actual session replacements, excluding delivery-only invalidation of callbacks. */
     readonly sessionBindingGeneration: number;
     readonly disposed: boolean;
+    currentSessionFile(): string | null;
     currentSessionResumeMetadata(): OwnedUiSessionResumeMetadata | null;
 }
 /** The session lifecycle, its view, its event stream, and command admission. */

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

@@ -94,12 +94,10 @@ export class SettingsApp {
     // Invariant: keyboard navigation requests visibility once; pointer scrolling then stays free.
     #selectionNeedsReveal = true;
     #reveal;
-    #notice = null;
     #filter = null;
     #scrollBeforeFilter = null;
     #menu = null;
     #structured = null;
-    #interruptArmed = false;
     // Invariant: pending values remain visible until the source reflects them.
     #pending = new Map();
     #undoHistory = [];
@@ -138,7 +136,6 @@ export class SettingsApp {
     }
     render(rect, host) {
         const theme = host.theme ?? PLAIN_THEME;
-        this.#interruptArmed = host.interruptArmed;
         const rows = this.#rows();
         const selected = indexOfKey(rows, this.#selectedKey);
         const footer = this.#footerLines(rect.width, theme);
@@ -259,7 +256,6 @@ export class SettingsApp {
             case "open-filter":
                 this.#scrollBeforeFilter = this.#scroll;
                 this.#filter = new LineInput("");
-                this.#notice = null;
                 return { consumed: true };
             case "activate": {
                 const row = rows[selected];
@@ -385,7 +381,6 @@ export class SettingsApp {
             const index = rows.findIndex(candidate => rowKey(candidate) === row.key);
             if (index >= 0) {
                 // Rationale: the pointer acts where it points; the arrow belongs to the keyboard.
-                this.#notice = null;
                 if (this.#hoverRegion === "minus")
                     this.#cycle(rows, index, -1);
                 else if (this.#hoverRegion === "plus")
@@ -458,10 +453,8 @@ export class SettingsApp {
         // and pointing at it is not a request for anything else.
         if (typeof shown === "number")
             return;
-        if (!entry.editable || entry.choices === null || entry.choices.length === 0) {
-            this.#notice = `${labelOf(entry)} cannot be changed here`;
+        if (!entry.editable || entry.choices === null || entry.choices.length === 0)
             return;
-        }
         const current = shown === null ? 0 : Math.max(0, entry.choices.indexOf(shown));
         const anchorKey = `${entry.backend}:${entry.id}`;
         // Compatibility: pointer opening already brightens the source value. Enter borrows that
@@ -492,10 +485,8 @@ export class SettingsApp {
     #openStructured(entry) {
         // 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) {
-            this.#notice = `${labelOf(entry)} has nothing to configure`;
+        if (entry.flags.length === 0)
             return;
-        }
         const stored = typeof entry.rawValue === "object" && entry.rawValue !== null && !Array.isArray(entry.rawValue)
             ? entry.rawValue
             : {};
@@ -648,13 +639,11 @@ export class SettingsApp {
             const failure = changeFailure(outcome);
             if (failure === null) {
                 this.#recordUndo({ kind: "structured", sequence, entry: open.entry, previous, forward });
-                this.#notice = null;
                 return;
             }
             // Concurrency: only roll back the dialog if no later press has moved the record on.
             if (this.#structured === open && sameRecord(open.record, forward))
                 replaceRecord(open.record, previous);
-            this.#notice = `Could not save ${labelOf(open.entry)}: ${failure}`;
         });
     }
     #menuKey(data) {
@@ -744,10 +733,8 @@ export class SettingsApp {
         if (row === undefined || row.kind !== "element")
             return;
         const entry = row.value;
-        if (!entry.editable) {
-            this.#notice = `${labelOf(entry)} cannot be changed here`;
+        if (!entry.editable)
             return;
-        }
         const shown = this.#shownValue(entry);
         if (typeof shown === "number") {
             // Rationale: at the end of the range there is nothing to say: the arrow already reads
@@ -758,10 +745,8 @@ export class SettingsApp {
             return;
         }
         const choices = entry.choices;
-        if (choices === null || choices.length === 0) {
-            this.#notice = `${labelOf(entry)} cannot be changed here`;
+        if (choices === null || choices.length === 0)
             return;
-        }
         const current = shown === null ? -1 : choices.indexOf(shown);
         const next = choices[current < 0
             ? (delta > 0 ? 0 : choices.length - 1)
@@ -781,7 +766,6 @@ export class SettingsApp {
             if (failure !== null) {
                 if (this.#pending.get(key) === value)
                     this.#pending.delete(key);
-                this.#notice = `Could not save ${labelOf(entry)}: ${failure}`;
                 return;
             }
             if (previous !== null && previous !== value)
@@ -789,7 +773,6 @@ export class SettingsApp {
             // Concurrency: a later press may have moved on; only the last request clears itself.
             if (this.#pending.get(key) === value)
                 this.#pending.delete(key);
-            this.#notice = null;
         });
     }
     #shownValue(entry) {
@@ -841,13 +824,8 @@ export class SettingsApp {
     }
     #finishUndo(record, outcome) {
         const failure = changeFailure(outcome);
-        if (failure !== null) {
+        if (failure !== null)
             this.#recordUndo(record);
-            this.#notice = `Could not restore ${labelOf(record.entry)}: ${failure}`;
-        }
-        else {
-            this.#notice = null;
-        }
         this.#undoActive = false;
         this.#drainUndo();
     }
@@ -878,7 +856,6 @@ export class SettingsApp {
             return;
         this.#selectedKey = rowKey(rows[index]);
         this.#selectionNeedsReveal = true;
-        this.#notice = null;
     }
     #rows() {
         const needle = this.#filter?.value.trim().toLowerCase() ?? "";
@@ -1037,13 +1014,9 @@ export class SettingsApp {
         const open = this.#structured;
         if (open !== null)
             return this.#dialogLines(open, width, theme);
-        const notice = this.#notice;
-        const plainStatus = notice !== null && notice.length > 0
-            ? notice
-            : this.#interruptArmed ? "press ctrl+c again to exit a1" : null;
-        const status = plainStatus === null
-            ? renderShortcutHintsWithClose(SETTINGS_SHORTCUTS.hintEntries(SCOPE), theme, width, width > 0 ? 1 : 0)
-            : truncateToWidth(`${width > 0 ? " " : ""}${theme.fg("dim", plainStatus)}`, width);
+        // Rationale: standing guidance is more useful than transient feedback; failures still
+        // roll back without displacing the Settings interaction contract.
+        const status = renderShortcutHintsWithClose(SETTINGS_SHORTCUTS.hintEntries(SCOPE), theme, width, width > 0 ? 1 : 0);
         const input = this.#filter;
         if (input === null)
             return [status];

package/dist/foundation/release/bootstrap.d.ts

@@ -25,7 +25,7 @@ export interface BootstrapOptions {
     /** Test seam for bounded maintenance scheduled after stale endpoint sweeping. */
     readonly scheduleMaintenance?: (dataDir: string, paths: ReturnType<typeof resolveProductPaths>) => Promise<void>;
     /** Test seams for resident launch routing before the guardian starts. */
-    readonly readResidentTabs?: (configDir: string, profileId: string) => Promise<boolean>;
+    readonly readResidentTabs?: (profileDir: string, namespace: string, legacyConfigDir: string, profileId: string) => Promise<boolean>;
     readonly ensureTerminalHost?: (options: EnsureTerminalHostOptions) => Promise<EnsureTerminalHostResult>;
 }
 export declare function runBootstrap(options: BootstrapOptions): Promise<number>;

package/dist/foundation/release/bootstrap.js

@@ -18,7 +18,7 @@ import { createRestartSeal, readRestartCertifiedRelease, releaseCertificationDoc
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 import { markStartupPhase } from "../startup/index.js";
 import { isCurrentLaunchContract, launchContractTarget, readLaunchContext, withLaunchContext } from "../launch-context/index.js";
-import { ensureTerminalHost, readResidentTabsSetting, selectResidentHost } from "../resident-tabs/index.js";
+import { ensureTerminalHost, readResidentTabLaunchSettings, selectResidentHost } from "../resident-tabs/index.js";
 const RELEASE_RESELECTION_MESSAGE = "a1-release-reselection";
 export async function runBootstrap(options) {
     return await runBootstrapAttempt(options, 1);
@@ -36,17 +36,27 @@ async function runBootstrapAttempt(options, retriesRemaining) {
     await mkdir(paths.runtimeDir, { recursive: true, mode: 0o700 });
     const launchSelected = async (release) => {
         let residentContext = {};
+        // Compatibility: public launch preparation supplies PI_CODING_AGENT_DIR; the fallback keeps
+        // direct SDK/bootstrap callers hermetic while retaining their former config-root read.
+        const agentProfileDir = environment.PI_CODING_AGENT_DIR ?? paths.configDir;
+        const residentLaunchSettings = launchProfileId === "a1"
+            ? readResidentTabLaunchSettings(agentProfileDir, PRODUCT_IDENTITY.commandName, paths.configDir, launchProfileId)
+            : null;
         const resident = await selectResidentHost({
             profileId: launchProfileId,
             hasSessionSelection: sessionArgs.length > 0,
             currentLaunchContract: isCurrentLaunchContract(release),
-            readSetting: () => (options.readResidentTabs ?? readResidentTabsSetting)(paths.configDir, launchProfileId),
-            ensureHost: () => (options.ensureTerminalHost ?? ensureTerminalHost)({
+            readSetting: options.readResidentTabs === undefined
+                ? async () => (await residentLaunchSettings).residentTabs
+                : () => options.readResidentTabs(agentProfileDir, PRODUCT_IDENTITY.commandName, paths.configDir, launchProfileId),
+            ensureHost: async () => (options.ensureTerminalHost ?? ensureTerminalHost)({
                 releaseRoot: release.releaseRoot,
                 profileRoot: environment[PRODUCT_IDENTITY.environment.profileHome] ?? paths.configDir,
                 dataDir: paths.dataDir,
                 runtimeDir: paths.runtimeDir,
                 environment,
+                maxConcurrentStarts: (await residentLaunchSettings).maxConcurrentStarts,
+                unresponsiveRestartSeconds: (await residentLaunchSettings).unresponsiveRestartSeconds,
             }),
         });
         if (resident !== null) {
@@ -55,7 +65,8 @@ async function runBootstrapAttempt(options, retriesRemaining) {
                 residentRootArguments: JSON.stringify([
                     "attach", "--endpoint", resident.endpoint, "--cwd", process.cwd(), "--clear-exit-ms", String(CLEAR_EXIT_INTERVAL_MS),
                     "--profile", environment[PRODUCT_IDENTITY.environment.profileHome] ?? paths.configDir,
-                    "--data-dir", paths.dataDir, "--release-root", release.releaseRoot, "--node-executable", process.execPath,
+                    "--data-dir", paths.dataDir, "--runtime-dir", paths.runtimeDir,
+                    "--release-root", release.releaseRoot, "--node-executable", process.execPath,
                 ]),
             } : { residentFallback: resident.reason };
         }