@timurproko/a1 0.2.7-dev.792 → 0.2.7-dev.806

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

@@ -39,7 +39,7 @@ export class ClipboardDiagnosticCapture {
         // Security: project only declared scalar fields. Never serialize the supplied event object or raw errors.
         this.#records.push({ source, phase: event.phase, atMs: scalar(event.atMs), request: event.request !== undefined && event.request < 0 ? -scalar(-event.request) : scalar(event.request), pending: scalar(event.pending), bytes: scalar(event.bytes), elapsedMs: scalar(event.elapsedMs),
             sourceUnits: scalar(event.sourceUnits), pendingBytes,
-            transport: ["native", "terminal", "provided", "injected"].includes(event.transport ?? "") ? event.transport : "none",
+            transport: ["native", "terminal", "platform", "provided", "injected"].includes(event.transport ?? "") ? event.transport : "none",
             outcome: ["ready", "failed", "canceled", "delivered", "submitted-unverified", "timed-out", "superseded"].includes(event.outcome ?? "") ? event.outcome : "none" });
         if (this.#records.length > 128)
             this.#records.shift();

package/dist/app/session-shell/response-copy-helper.js

@@ -1,5 +1,6 @@
 import { MAX_COPY_ROWS, MAX_COPY_SOURCE_UNITS, selectionCopyRowText } from "../../ui/components/index.js";
 import { COPY_CHUNK_UNITS, MAX_COPY_BYTES, MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
+const NATIVE_RETRY_DELAYS_MS = [20, 60];
 // Security: this isolated executor never inherits the UI terminal and never logs clipboard contents.
 let header;
 let fragments = [];
@@ -24,6 +25,14 @@ function nextOutput() {
     send({ kind: "data", text });
 }
 function send(message) { process.send?.(message); }
+function transientClipboardError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    const message = error instanceof Error ? error.message : String(error);
+    return /^(?:EAGAIN|EBUSY)$/iu.test(code) || /(?:busy|locked|contention|temporar|try again)/iu.test(message);
+}
+function delay(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
 function finish(result, control) {
     if (finished)
         return;
@@ -97,13 +106,19 @@ async function receive(message) {
             return;
         }
         send({ kind: "phase", phase: "submitting", bytes });
-        try {
-            await native.setText(text);
-            finish({ outcome: "delivered" });
-        }
-        catch {
-            finish({ outcome: "failed", failure: "denied" });
+        for (let attempt = 0; attempt <= NATIVE_RETRY_DELAYS_MS.length; attempt++) {
+            try {
+                await native.setText(text);
+                finish({ outcome: "delivered" });
+                return;
+            }
+            catch (error) {
+                if (!transientClipboardError(error) || attempt === NATIVE_RETRY_DELAYS_MS.length)
+                    break;
+                await delay(NATIVE_RETRY_DELAYS_MS[attempt]);
+            }
         }
+        finish({ outcome: "failed", failure: "denied" });
         return;
     }
     else

package/dist/app/session-shell/response-copy-protocol.d.ts

@@ -19,7 +19,7 @@ export interface ResponseCopyEvent {
     readonly pending: number;
     readonly sourceUnits: number;
     readonly bytes?: number;
-    readonly transport?: "native" | "terminal" | "injected";
+    readonly transport?: "native" | "terminal" | "platform" | "injected";
     readonly outcome?: CopyOutcome;
 }
 /** One request per helper lifetime. Each source fragment is acknowledged before the next is sent. */

package/dist/app/session-shell/response-copy-transport.d.ts

@@ -7,7 +7,7 @@ export interface ResponseCopyJob {
     readonly stopped: Promise<void>;
     cancel(): void;
 }
-export type CopyPhaseObserver = (phase: "extracted" | "encoded" | "submitting", bytes: number, transport: "native" | "terminal" | "injected") => void;
+export type CopyPhaseObserver = (phase: "extracted" | "encoded" | "submitting", bytes: number, transport: "native" | "terminal" | "platform" | "injected") => void;
 export type ResponseCopyExecutor = (snapshot: SelectionCopySnapshot, phase: CopyPhaseObserver) => ResponseCopyJob;
 /** The production executor also holds a spare helper; the owner warms it at start and disposes it at shutdown unless the pool is shared. */
 export interface OwnedResponseCopyExecutor extends ResponseCopyExecutor {
@@ -22,17 +22,14 @@ export interface ResponseCopyTerminal {
 }
 /** Never substitute a remote host's native clipboard for the terminal user's clipboard. */
 export declare function responseCopyDestination(env: NodeJS.ProcessEnv): "native" | "terminal";
-/** Node documents synchronous POSIX TTY and Windows pipe writes; do not put clipboard traffic there. */
-export declare function hasAsyncClipboardOutput(platform?: NodeJS.Platform, stdout?: {
-    readonly isTTY?: boolean | undefined;
-    readonly fd?: number | undefined;
-}): boolean;
 /** Isolates preparation and native clipboard access; only the owner may submit terminal controls. */
 export declare function createResponseCopyExecutor(options?: {
     readonly terminal?: ResponseCopyTerminal;
     readonly destination?: "native" | "terminal";
     /** Explicit host seam: must be non-blocking and honor cancellation, or its unresolved lifetime is quarantined. */
     readonly writeText?: (text: string, signal: AbortSignal) => Promise<void>;
+    /** Platform/fault-test seam; production writes through the supported operating-system command. */
+    readonly platformWriteText?: (text: string, signal: AbortSignal) => Promise<boolean>;
     /** Package/fault-test seam: the production helper is always an emitted sibling. */
     readonly helper?: URL;
     /** Idle bound for the spare helper; production keeps the default. */

package/dist/app/session-shell/response-copy-transport.js

@@ -1,25 +1,58 @@
-import { fork } from "node:child_process";
-import { fstatSync } from "node:fs";
+import { execFile, fork } from "node:child_process";
 import { HelperPool } from "./helper-pool.js";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { COPY_CHUNK_UNITS, COPY_CLEANUP_MS, MAX_COPY_BYTES, MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
+const PLATFORM_WRITE_TIMEOUT_MS = 1_500;
 /** Never substitute a remote host's native clipboard for the terminal user's clipboard. */
 export function responseCopyDestination(env) {
-    return env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY || env.TMUX || env.STY || env.WSL_DISTRO_NAME
+    return env[PRODUCT_IDENTITY.environment.tabId] || env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY || env.TMUX || env.STY || env.WSL_DISTRO_NAME
         ? "terminal" : "native";
 }
-/** Node documents synchronous POSIX TTY and Windows pipe writes; do not put clipboard traffic there. */
-export function hasAsyncClipboardOutput(platform = process.platform, stdout = process.stdout) {
-    if (stdout.isTTY)
-        return platform === "win32";
-    if (platform === "win32")
-        return false;
-    try {
-        const stat = fstatSync(stdout.fd ?? -1);
-        return stat.isFIFO() || stat.isSocket();
-    }
-    catch {
-        return false;
+function platformClipboardCommands() {
+    if (process.platform === "win32")
+        return [{
+                command: "powershell.exe",
+                args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", "$value=[Console]::In.ReadToEnd(); Set-Clipboard -Value $value"],
+            }];
+    if (process.platform === "darwin")
+        return [{ command: "pbcopy", args: [] }];
+    return [
+        { command: "wl-copy", args: ["--type", "text/plain;charset=utf-8"] },
+        { command: "xclip", args: ["-selection", "clipboard", "-in"] },
+    ];
+}
+async function writePlatformClipboardText(text, signal) {
+    for (const route of platformClipboardCommands()) {
+        if (signal.aborted)
+            return false;
+        const delivered = await new Promise(resolve => {
+            let settled = false;
+            const done = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(value);
+            };
+            const child = execFile(route.command, [...route.args], {
+                signal,
+                windowsHide: true,
+                timeout: PLATFORM_WRITE_TIMEOUT_MS,
+                killSignal: "SIGKILL",
+                maxBuffer: 1_024,
+            }, error => done(error === null));
+            child.once("error", () => done(false));
+            if (child.stdin === null) {
+                child.kill("SIGKILL");
+                done(false);
+                return;
+            }
+            child.stdin.once("error", () => { child.kill("SIGKILL"); done(false); });
+            child.stdin.end(text);
+        });
+        if (delivered)
+            return true;
     }
+    return false;
 }
 /** Isolates preparation and native clipboard access; only the owner may submit terminal controls. */
 export function createResponseCopyExecutor(options = {}) {
@@ -43,8 +76,18 @@ export function createResponseCopyExecutor(options = {}) {
             };
             let outcome = await execute(destination);
             // Concurrency: helper results settle only after exit; fallback cannot race an older native write.
-            if (!controller.signal.aborted && destination === "native" && outcome.result.failure === "unavailable" && options.terminal !== undefined) {
-                outcome = await execute("terminal");
+            if (!controller.signal.aborted && destination === "native" && outcome.result.outcome === "failed") {
+                const prepared = await execute("prepare");
+                if (prepared.result.outcome === "delivered" && prepared.text !== undefined) {
+                    phase("submitting", prepared.bytes ?? 0, "platform");
+                    const delivered = await (options.platformWriteText ?? writePlatformClipboardText)(prepared.text, controller.signal);
+                    outcome = { kind: "result", result: delivered ? { outcome: "delivered" } : { outcome: "failed", failure: "unavailable" } };
+                }
+                else
+                    outcome = { kind: "result", result: { outcome: "failed", failure: "transport" } };
+                if (!controller.signal.aborted && outcome.result.outcome === "failed" && options.terminal !== undefined) {
+                    outcome = await execute("terminal");
+                }
             }
             if (controller.signal.aborted)
                 return { outcome: "canceled" };

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

@@ -46,6 +46,7 @@ export interface OwnedUiShellEngineOptions {
     /** Resident tab quit routes detach the outer client without stopping this engine session. */
     readonly residentTab?: {
         requestDetach(): Promise<boolean>;
+        closeOwnedRoute?(route: string): void;
         reportStatus?(status: "working" | "idle" | "stalled"): void;
         readonly stallNoticeSeconds?: number;
         admit?(input: {
@@ -191,6 +192,7 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
         readonly requestHyperlinkCleanup?: (rows?: readonly number[]) => void;
         readonly enableDockInputReuse?: boolean;
         readonly persistentHistory?: boolean;
+        readonly hideSettingsCommand?: boolean;
         readonly historyEditor?: import("../../integrations/pi/components/index.js").HistoryEditorConstructor;
         readonly onSubmit: (text: string) => void;
         readonly onPasteRejected?: (error: unknown) => void;

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

@@ -438,6 +438,7 @@ export class OwnedUiSessionShellRoot {
             ? Math.max(0, dock.inputRows - 2)
             : 0;
         const copyableDockRows = [
+            ...dock.copyableMessageRows,
             ...Array.from({ length: promptCopyRows }, (_value, index) => ({
                 row: editorOffset + index + 1,
                 prompt: index === 0 ? "first" : "continuation",
@@ -620,7 +621,10 @@ export class OwnedUiSessionShellRoot {
     #renderDockLayout(width) {
         const queued = this.#customViewport ? [] : this.#renderQueued(width);
         const statusRows = this.#customViewport ? this.#status.renderDock(width) : this.#renderStatus(width);
-        const transientRows = [...queued, ...statusRows, ...this.#renderDockNotice(width)];
+        const noticeRows = this.#renderDockNotice(width);
+        const transientRows = [...queued, ...statusRows, ...noticeRows];
+        const messageStart = queued.length;
+        const copyableMessageRows = Array.from({ length: statusRows.length + noticeRows.length }, (_value, index) => ({ row: messageStart + index }));
         const aboveWidgets = this.#renderWidgets("aboveEditor", width);
         const input = this.#inputSurface.render(width);
         const body = this.usesDefaultInputSurface() ? this.editor.bodyGeometry?.() : undefined;
@@ -634,6 +638,7 @@ export class OwnedUiSessionShellRoot {
             editorOffset: inputOffset + (body?.rowOffset ?? 0),
             inputRows: body?.rowCount ?? input.length,
             footerRows: footer.length,
+            copyableMessageRows,
         };
     }
     #renderCopyAcknowledgement(width) {

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

@@ -72,6 +72,7 @@ export declare class OwnedUiSessionPresenter implements OwnedUiHostedPresenter {
         readonly mode: "regular" | "fullscreen";
         readonly columns: number;
     }): OwnedUiPresenterRelease;
+    openOwnedRoute(route: string): void;
     hotkeysPresentation(): PiShellHotkeysPresentation;
 }
 /**

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

@@ -1,5 +1,5 @@
 import { ResponseCopyCoordinator } from "./response-copy-coordinator.js";
-import { createResponseCopyExecutor, hasAsyncClipboardOutput, responseCopyDestination } from "./response-copy-transport.js";
+import { createResponseCopyExecutor, responseCopyDestination } from "./response-copy-transport.js";
 import { MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
 import { PromptHistoryController } from "./prompt-history-controller.js";
 import { PRODUCT_TEXT } from "../../product-identity.js";
@@ -129,31 +129,24 @@ export class OwnedUiSessionPresenter {
         // throw releases them in reverse, so a shell that never finished constructing holds nothing.
         const constructed = [() => host.disconnect(this)];
         try {
-            const terminalCopy = terminal !== undefined || hasAsyncClipboardOutput();
             this.#responseCopy = this.#customViewport ? new ResponseCopyCoordinator({
                 execute: responseCopy?.execute ?? (this.#copyExecutor = createResponseCopyExecutor({
                     ...(sharedClipboard === undefined ? {} : { pool: sharedClipboard.copy }),
                     ...(terminal === undefined && clipboard === undefined ? {} : { destination: "terminal" }),
                     ...(clipboard?.writeText === undefined ? {} : { writeText: (text, signal) => clipboard.writeText(text, signal) }),
-                    ...(terminalCopy ? { terminal: { submit: async (control, signal) => {
-                                if (signal.aborted || this.#disposed || !this.#terminal.running)
-                                    throw new Error("Copy canceled");
-                                // Performance: never grow the real terminal's pending buffer with another clipboard payload.
-                                if (terminal === undefined && process.stdout.writableLength + control.length > MAX_COPY_CONTROL_BYTES) {
-                                    throw new Error("Clipboard terminal is busy");
-                                }
-                                this.#terminal.writeControl(control);
-                            } } } : {}),
+                    // Invariant: the owned host is the route contract. Resident and pseudoterminal children must not infer
+                    // clipboard reachability from Node's view of stdout, and inactive presenters are fenced here.
+                    terminal: { submit: async (control, signal) => {
+                            if (signal.aborted || this.#disposed || !this.#terminal.running || !this.#terminal.attached)
+                                throw new Error("Copy canceled");
+                            // Performance: never grow the real terminal's pending buffer with another clipboard payload.
+                            if (terminal === undefined && process.stdout.writableLength + control.length > MAX_COPY_CONTROL_BYTES) {
+                                throw new Error("Clipboard terminal is busy");
+                            }
+                            this.#terminal.writeControl(control);
+                        } },
                 })),
                 ...(responseCopy?.onEvent === undefined ? {} : { onEvent: responseCopy.onEvent }),
-                onFailure: result => {
-                    if (this.#disposed || !this.#terminal.running)
-                        return;
-                    this.root.appendWorkflowStatus(result.outcome === "timed-out" ? "Copy timed out; the clipboard did not respond."
-                        : result.failure === "size" ? "Selection exceeds this clipboard route's size limit."
-                            : "Could not copy the selection; the clipboard is unavailable.");
-                    this.#terminal.requestRender();
-                },
             }) : null;
             constructed.push(() => { this.#responseCopy?.dispose(); this.#copyExecutor?.dispose(); });
             const readClipboard = async (signal) => {
@@ -189,6 +182,7 @@ export class OwnedUiSessionPresenter {
                 }),
                 enableDockInputReuse: inputPresentation?.viewportReuse !== false,
                 footerSessionName: this.#residentTabOptions === undefined,
+                hideSettingsCommand: this.#residentTabOptions !== undefined,
                 persistentHistory: this.#customViewport && promptHistory !== undefined,
                 ...(promptHistory === undefined ? {} : { historyEditor: promptHistory.editor }),
                 onSubmit: text => { void this.submit(text).catch(() => this.#reportSubmissionError()); },
@@ -1343,6 +1337,8 @@ export class OwnedUiSessionPresenter {
             return { outcome: "completed", diagnostic: null };
         }
         if (request.command === "settings" && request.selection === undefined && request.confirmed === undefined) {
+            if (this.#residentTabOptions !== undefined)
+                return rejected("Settings is available from the global Settings tab.");
             this.showSettingsSelector();
             return { outcome: "completed", diagnostic: null };
         }
@@ -1717,6 +1713,7 @@ export class OwnedUiSessionPresenter {
                         void onClosed?.()?.catch(() => undefined);
                     }
                     catch { /* Rationale: a failed acknowledgement stays pending. */ }
+                    this.#residentTabOptions?.closeOwnedRoute?.(route);
                 }
             },
         });
@@ -1764,6 +1761,9 @@ export class OwnedUiSessionPresenter {
         });
         this.#dialogId = dialog.id;
     }
+    openOwnedRoute(route) {
+        this.#openOwnedRoute(route);
+    }
     hotkeysPresentation() {
         const presentation = this.root.hotkeysPresentation();
         return this.#residentTabOptions === undefined ? presentation : { ...presentation, residentTabs: true };
@@ -1773,6 +1773,9 @@ export class OwnedUiSessionPresenter {
         const separator = body.search(/\s/);
         const name = separator < 0 ? body : body.slice(0, separator);
         const argument = separator < 0 ? "" : body.slice(separator + 1).trimStart();
+        if (name === "settings" && this.#residentTabOptions !== undefined) {
+            return rejected("Settings is available from the global Settings tab.");
+        }
         if (this.#routeHost?.claims(name))
             return this.#openOwnedRoute(name);
         if (this.#isWorkflowRoute(name))

package/dist/cli/tabs.js

@@ -30,7 +30,7 @@ export async function runTabsCommand(request, options = {}) {
             stateDir: report.stateDir,
             hostStatus: report,
             releaseRoots,
-            settings: { tabsMax: settings.tabsMax, tabsAutoName: settings.tabsAutoName },
+            settings: { tabsAutoName: settings.tabsAutoName },
         });
         if (request.json)
             stdout(`${JSON.stringify({ schema: "a1-tabs-doctor-v1", path: bundle.path, bytes: bundle.bytes, dropped: bundle.dropped })}\n`);

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

@@ -87,5 +87,6 @@ export declare function composeOwnedUiApplication(options?: OwnedUiCompositionOp
 export declare function composeOwnedUi(options?: OwnedUiCompositionOptions): Promise<OwnedUiComposition>;
 export declare function bindResidentTabBridge(tabBridge: TabBridgeClient, backend: Pick<ComposedSessionBackend, "identity" | "session" | "workflows" | "generateResidentTabName">, recovery?: Pick<ResidentTabRecovery, "settled"> | null, options?: {
     readonly autoName?: boolean;
+    readonly openRoute?: (route: "settings") => void;
 }): Promise<() => void>;
 export declare function correlateResidentTabSubmission(recovery: Pick<ResidentTabRecovery, "correlated" | "settled">, backend: Pick<ComposedSessionBackend, "identity" | "session">, submissionId: string, entryId: string): Promise<void>;

package/dist/composition/owned-ui.js

@@ -102,7 +102,7 @@ export async function composeOwnedUi(options = {}) {
             namespace: PRODUCT_IDENTITY.commandName,
             legacyConfigDir: productPaths.configDir,
             agentProvider: () => backend.settingsPort(),
-            ...(options.hideTabSettings ? { hiddenOwnedSettingIds: ["tabsMax", "tabsAutoName"] } : {}),
+            ...(options.hideTabSettings ? { hiddenOwnedSettingIds: ["tabsAutoName"] } : {}),
             hiddenAgentSettingIds: ["fullscreenWheelScrollLines"],
             agentSettingLabelOverrides: { fullscreenCopyOnSelect: "Copy on select" },
         });
@@ -167,7 +167,7 @@ export async function composeOwnedUi(options = {}) {
     if (tabBridge !== null && settings !== null && ownedSurfaces)
         tabBridge.accent(settings.value("accentColor"));
     let removeControllerBoundaryInput = () => { };
-    const unsubscribeTabBridge = tabBridge === null ? () => { } : await bindResidentTabBridge(tabBridge, backend, tabRecovery, { autoName: settings?.value("tabsAutoName") ?? true });
+    let unsubscribeTabBridge = () => { };
     let releaseNotes = null;
     let releaseNotesFailure;
     if (ownedSurfaces) {
@@ -293,6 +293,10 @@ export async function composeOwnedUi(options = {}) {
                 ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
                 ...(tabBridge === null || tabRecovery === null ? {} : { residentTab: {
                         requestDetach: () => tabBridge.requestDetach(),
+                        closeOwnedRoute: route => {
+                            if (tabBridge.tabId.startsWith("settings-") && route === "settings")
+                                void tabBridge.requestClose();
+                        },
                         reportStatus: status => tabBridge.status(status),
                         stallNoticeSeconds: 300,
                         admit: input => tabRecovery.admit({ ...input, incarnation: options.tab.incarnation }),
@@ -344,6 +348,12 @@ export async function composeOwnedUi(options = {}) {
         if (recoveryDegraded)
             presentRecoveryDegraded(true);
         terminalHost.attach(presenter);
+        if (tabBridge !== null) {
+            unsubscribeTabBridge = await bindResidentTabBridge(tabBridge, backend, tabRecovery, {
+                autoName: settings?.value("tabsAutoName") ?? true,
+                openRoute: route => presenter.openOwnedRoute(route),
+            });
+        }
     }
     catch (error) {
         await createdTerminalHost?.dispose().catch(() => undefined);
@@ -477,7 +487,10 @@ export async function bindResidentTabBridge(tabBridge, backend, recovery = null,
             void backend.workflows.executeWorkflow({ command: "name", argument: command.name }).catch(() => { });
         }
         else if (command.type === "route") {
-            void backend.workflows.executeWorkflow({ command: command.route, argument: "" }).catch(() => { });
+            if (options.openRoute !== undefined)
+                options.openRoute(command.route);
+            else
+                void backend.workflows.executeWorkflow({ command: command.route, argument: "" }).catch(() => { });
         }
         else if (command.type === "stop") {
             void backend.session.dispose().catch(() => { });

package/dist/features/resident-tab/shortcut-declarations.d.ts

@@ -1,4 +1,4 @@
-export type ResidentTabAction = "tabs.new" | "tabs.close" | "tabs.rename" | "tabs.retry" | "tabs.fresh" | "tabs.next" | "tabs.previous" | "tabs.moveRight" | "tabs.moveLeft" | `tabs.jump${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}`;
+export type ResidentTabAction = "tabs.new" | "tabs.close" | "tabs.rename" | "tabs.settings" | "tabs.retry" | "tabs.fresh" | "tabs.next" | "tabs.previous" | "tabs.moveRight" | "tabs.moveLeft" | `tabs.jump${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}`;
 export interface ResidentTabShortcut {
     readonly id: ResidentTabAction;
     readonly defaultKey: string | null;

package/dist/features/resident-tab/shortcut-declarations.js

@@ -13,6 +13,7 @@ export const RESIDENT_TAB_SHORTCUTS = Object.freeze([
     { id: "tabs.new", defaultKey: "alt+a", scope: "global", description: "New A1 tab" },
     { id: "tabs.close", defaultKey: "alt+w", scope: "global", description: "Close A1 tab" },
     { id: "tabs.rename", defaultKey: "f2", scope: "global", description: "Rename A1 tab" },
+    { id: "tabs.settings", defaultKey: "alt+.", scope: "global", description: "Open Settings tab" },
     ...jumps,
     { id: "tabs.next", defaultKey: null, scope: "global", description: "View next A1 tab" },
     { id: "tabs.previous", defaultKey: null, scope: "global", description: "View previous A1 tab" },

package/dist/foundation/launch-guardian/exit-watcher.d.ts

@@ -0,0 +1,14 @@
+import { type ProcessGuardianAddon } from "../process-containment/index.js";
+interface ExitWatcherOptions {
+    readonly guardianPid: number;
+    readonly noticePath: string;
+    readonly encodedModes: string;
+    readonly addonPath: string;
+    readonly runtimePid: number;
+    readonly processGroup: number | null;
+    readonly foregroundGroup: number | null;
+}
+/** Waits outside launch containment, then performs the cleanup its dead guardian could not. */
+export declare function runExitWatcher(arguments_: readonly string[], platform?: NodeJS.Platform, loadAddon?: (path: string) => ProcessGuardianAddon): Promise<number>;
+export declare function exitWatcherArguments(options: ExitWatcherOptions): string[];
+export {};

package/dist/foundation/launch-guardian/exit-watcher.js

@@ -0,0 +1,94 @@
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { loadProcessGuardianAddon } from "../process-containment/index.js";
+/** Waits outside launch containment, then performs the cleanup its dead guardian could not. */
+export async function runExitWatcher(arguments_, platform = process.platform, loadAddon = loadProcessGuardianAddon) {
+    const options = parseArguments(arguments_);
+    const addon = loadAddon(options.addonPath);
+    if (platform === "win32")
+        addon.ignoreConsoleControl();
+    else {
+        process.on("SIGINT", ignoreSignal);
+        process.on("SIGTTOU", ignoreSignal);
+    }
+    try {
+        await addon.waitForProcessExit(options.guardianPid);
+        if (platform === "win32") {
+            // Rationale: job termination is asynchronous; keep the runtime's final frame ahead of the notice.
+            await Promise.race([
+                addon.waitForProcessExit(options.runtimePid),
+                delay(2_000),
+            ]);
+        }
+        else if (options.processGroup !== null) {
+            addon.stopProcessGroup(options.processGroup);
+            if (options.foregroundGroup !== null)
+                addon.restoreForegroundGroup(options.foregroundGroup);
+        }
+        addon.deliverExitNotice(options.noticePath, options.encodedModes);
+        return 0;
+    }
+    finally {
+        if (platform !== "win32") {
+            process.off("SIGINT", ignoreSignal);
+            process.off("SIGTTOU", ignoreSignal);
+        }
+    }
+}
+export function exitWatcherArguments(options) {
+    return [
+        "--guardian-pid", String(options.guardianPid),
+        "--notice", options.noticePath,
+        "--modes", options.encodedModes,
+        "--addon", options.addonPath,
+        "--runtime-pid", String(options.runtimePid),
+        ...(options.processGroup === null ? [] : ["--process-group", String(options.processGroup)]),
+        ...(options.foregroundGroup === null ? [] : ["--foreground-group", String(options.foregroundGroup)]),
+    ];
+}
+function parseArguments(arguments_) {
+    const values = new Map();
+    for (let index = 0; index < arguments_.length; index += 2) {
+        const name = arguments_[index];
+        const value = arguments_[index + 1];
+        if (!name?.startsWith("--") || value === undefined || values.has(name))
+            throw new TypeError("exit watcher arguments are malformed");
+        values.set(name, value);
+    }
+    const guardianPid = positiveInteger(values.get("--guardian-pid"), "guardian PID");
+    const runtimePid = positiveInteger(values.get("--runtime-pid"), "runtime PID");
+    const noticePath = boundedValue(values.get("--notice"), "notice path");
+    const encodedModes = boundedValue(values.get("--modes"), "terminal modes", 32_768);
+    const addonPath = boundedValue(values.get("--addon"), "addon path");
+    const processGroup = optionalPositiveInteger(values.get("--process-group"), "process group");
+    const foregroundGroup = optionalPositiveInteger(values.get("--foreground-group"), "foreground group");
+    const expected = 5 + (processGroup === null ? 0 : 1) + (foregroundGroup === null ? 0 : 1);
+    if (values.size !== expected)
+        throw new TypeError("exit watcher received an unknown argument");
+    return { guardianPid, noticePath, encodedModes, addonPath, runtimePid, processGroup, foregroundGroup };
+}
+function positiveInteger(value, name) {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0)
+        throw new TypeError(`exit watcher ${name} must be a positive safe integer`);
+    return parsed;
+}
+function optionalPositiveInteger(value, name) {
+    return value === undefined ? null : positiveInteger(value, name);
+}
+function boundedValue(value, name, limit = 4_096) {
+    if (!value || value.length > limit || value.includes("\0"))
+        throw new TypeError(`exit watcher ${name} is invalid`);
+    return value;
+}
+function delay(milliseconds) {
+    return new Promise(resolvePromise => setTimeout(resolvePromise, milliseconds));
+}
+function ignoreSignal() { }
+const invokedPath = process.argv[1] ? resolve(process.argv[1]) : null;
+if (invokedPath === fileURLToPath(import.meta.url)) {
+    void runExitWatcher(process.argv.slice(2)).then(code => process.exit(code), error => {
+        process.stderr.write(`a1 exit watcher: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(2);
+    });
+}

package/dist/foundation/launch-guardian/main.d.ts

@@ -1,6 +1,6 @@
 import type { LaunchInstanceStopIntent, LaunchProfileId, SupervisorCommand } from "../lifecycle/index.js";
 import { type SessionSelection } from "../lifecycle/index.js";
-import { type NativeProcessInspector, type ProcessContainment } from "../process-containment/index.js";
+import { type NativeProcessInspector, type ProcessContainment, type ProcessGuardianAddon } from "../process-containment/index.js";
 interface GuardianControl {
     connect(endpoint: string, timeoutMs?: number): Promise<unknown>;
     command(command: SupervisorCommand): Promise<{
@@ -32,6 +32,7 @@ export interface LaunchGuardianOptions {
     readonly inspector?: NativeProcessInspector;
     readonly control?: GuardianControl;
     readonly containment?: ProcessContainment;
+    readonly addon?: ProcessGuardianAddon;
     readonly ensureHelper?: (path: string) => Promise<void>;
 }
 export declare function runLaunchGuardian(options: LaunchGuardianOptions): Promise<number>;