@timurproko/a1 0.2.7-dev.754 → 0.2.7-dev.772

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/features/resident-tab/auto-name.d.ts

@@ -0,0 +1,11 @@
+export declare const AUTO_NAME_MAX_LENGTH = 16;
+export declare const AUTO_NAME_TIMEOUT_MS = 10000;
+export declare const AUTO_NAME_MAX_TOKENS = 64;
+export declare function normalizeAutoName(value: string): string | null;
+export declare function fallbackAutoName(prompt: string): string;
+export interface AutoNameCompletion {
+    readonly prompt: string;
+    readonly maxTokens: number;
+    readonly signal: AbortSignal;
+}
+export declare function generateAutoName(firstPrompt: string, complete: (request: AutoNameCompletion) => Promise<string | null>, timeoutMs?: number): Promise<string>;

package/dist/features/resident-tab/auto-name.js

@@ -0,0 +1,42 @@
+export const AUTO_NAME_MAX_LENGTH = 16;
+export const AUTO_NAME_TIMEOUT_MS = 10_000;
+export const AUTO_NAME_MAX_TOKENS = 64;
+export function normalizeAutoName(value) {
+    const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+    if (!normalized)
+        return null;
+    if (normalized.length <= AUTO_NAME_MAX_LENGTH)
+        return normalized;
+    const clipped = normalized.slice(0, AUTO_NAME_MAX_LENGTH + 1);
+    const boundary = clipped.lastIndexOf("-");
+    const result = (boundary >= 4 ? clipped.slice(0, boundary) : normalized.slice(0, AUTO_NAME_MAX_LENGTH)).replace(/-+$/g, "");
+    return result || null;
+}
+export function fallbackAutoName(prompt) {
+    const words = prompt.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+    return normalizeAutoName(words.slice(0, 3).join("-")) ?? "new-task";
+}
+export async function generateAutoName(firstPrompt, complete, timeoutMs = AUTO_NAME_TIMEOUT_MS) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        timer.unref?.();
+        try {
+            const response = await complete({
+                prompt: `Name this coding task with a lowercase hyphenated title of at most ${AUTO_NAME_MAX_LENGTH} characters. Reply only with the title.\n\n${firstPrompt.slice(0, 500)}`,
+                maxTokens: AUTO_NAME_MAX_TOKENS,
+                signal: controller.signal,
+            });
+            const name = response === null ? null : normalizeAutoName(response);
+            if (name !== null)
+                return name;
+        }
+        catch {
+            // Rationale: naming is best effort; one retry precedes the deterministic fallback.
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    return fallbackAutoName(firstPrompt);
+}

package/dist/features/resident-tab/index.d.ts

@@ -0,0 +1,3 @@
+export { AUTO_NAME_MAX_LENGTH, AUTO_NAME_MAX_TOKENS, AUTO_NAME_TIMEOUT_MS, fallbackAutoName, generateAutoName, normalizeAutoName, type AutoNameCompletion, } from "./auto-name.js";
+export { RESIDENT_TAB_SHORTCUTS, residentTabShortcutRegistry, type ResidentTabAction, type ResidentTabShortcut, } from "./shortcuts.js";
+export { deriveResidentTabStatus, type ResidentTabDerivedStatus, type ResidentTabFacts, } from "./status-deriver.js";

package/dist/features/resident-tab/index.js

@@ -0,0 +1,3 @@
+export { AUTO_NAME_MAX_LENGTH, AUTO_NAME_MAX_TOKENS, AUTO_NAME_TIMEOUT_MS, fallbackAutoName, generateAutoName, normalizeAutoName, } from "./auto-name.js";
+export { RESIDENT_TAB_SHORTCUTS, residentTabShortcutRegistry, } from "./shortcuts.js";
+export { deriveResidentTabStatus, } from "./status-deriver.js";

package/dist/features/resident-tab/shortcuts.d.ts

@@ -0,0 +1,10 @@
+import { ShortcutRegistry } from "../../ui/components/index.js";
+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 interface ResidentTabShortcut {
+    readonly id: ResidentTabAction;
+    readonly defaultKey: string | null;
+    readonly scope: "global" | "failed-banner";
+    readonly description: string;
+}
+export declare const RESIDENT_TAB_SHORTCUTS: readonly ResidentTabShortcut[];
+export declare function residentTabShortcutRegistry(assignments?: Readonly<Partial<Record<ResidentTabAction, string | null>>>): ShortcutRegistry<ResidentTabAction>;

package/dist/features/resident-tab/shortcuts.js

@@ -0,0 +1,35 @@
+import { GLOBAL_SCOPE, ShortcutRegistry } from "../../ui/components/index.js";
+const jumps = Array.from({ length: 10 }, (_, index) => ({
+    id: `tabs.jump${index + 1}`,
+    defaultKey: `alt+${(index + 1) % 10}`,
+    scope: "global",
+    description: `View A1 tab ${index + 1}`,
+}));
+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" },
+    ...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" },
+    { id: "tabs.moveRight", defaultKey: null, scope: "global", description: "Move A1 tab right" },
+    { id: "tabs.moveLeft", defaultKey: null, scope: "global", description: "Move A1 tab left" },
+    { id: "tabs.retry", defaultKey: "r", scope: "failed-banner", description: "Retry failed A1 tab" },
+    { id: "tabs.fresh", defaultKey: "f", scope: "failed-banner", description: "Start failed A1 tab fresh" },
+]);
+export function residentTabShortcutRegistry(assignments = {}) {
+    const registry = new ShortcutRegistry();
+    for (const shortcut of RESIDENT_TAB_SHORTCUTS) {
+        const key = assignments[shortcut.id] === undefined ? shortcut.defaultKey : assignments[shortcut.id];
+        if (!key)
+            continue;
+        const declaration = {
+            key,
+            scope: shortcut.scope === "global" ? GLOBAL_SCOPE : shortcut.scope,
+            section: "Tabs",
+            description: shortcut.description,
+        };
+        registry.declare(declaration, shortcut.id);
+    }
+    return registry;
+}

package/dist/features/resident-tab/status-deriver.d.ts

@@ -0,0 +1,9 @@
+export type ResidentTabDerivedStatus = "starting" | "working" | "needs-input" | "done-unseen" | "idle" | "failed";
+export interface ResidentTabFacts {
+    readonly lifecycle: string;
+    readonly pendingRequests: number;
+    readonly queuedInput: number;
+    readonly stopReason?: string;
+    readonly settledUnseen?: boolean;
+}
+export declare function deriveResidentTabStatus(facts: ResidentTabFacts): ResidentTabDerivedStatus;

package/dist/features/resident-tab/status-deriver.js

@@ -0,0 +1,15 @@
+export function deriveResidentTabStatus(facts) {
+    if (facts.lifecycle === "failed")
+        return "failed";
+    if (facts.pendingRequests > 0)
+        return "needs-input";
+    if (facts.lifecycle === "busy" || facts.queuedInput > 0)
+        return "working";
+    if (facts.lifecycle === "starting")
+        return "starting";
+    if (facts.stopReason === "error")
+        return "failed";
+    if (facts.settledUnseen === true)
+        return "done-unseen";
+    return "idle";
+}

package/dist/foundation/launch-context/index.d.ts

@@ -6,7 +6,11 @@ export declare const PRIVATE_ENVIRONMENT: Readonly<{
     releaseDigest: "LAUNCH_CONTEXT_RELEASE_DIGEST";
     releaseLayers: "LAUNCH_CONTEXT_RELEASE_LAYERS";
     launchProfile: "LAUNCH_CONTEXT_PROFILE";
+    launchMode: "LAUNCH_CONTEXT_MODE";
     immutableWarmup: "LAUNCH_CONTEXT_WARMUP";
+    residentRootExecutable: "LAUNCH_CONTEXT_RESIDENT_ROOT_EXECUTABLE";
+    residentRootArguments: "LAUNCH_CONTEXT_RESIDENT_ROOT_ARGUMENTS";
+    residentFallback: "LAUNCH_CONTEXT_RESIDENT_FALLBACK";
 }>;
 /**
  * Keys published by releases that predate the neutral cutover. They are read when
@@ -30,8 +34,14 @@ export interface LaunchContext {
     readonly releaseDigest?: string;
     readonly releaseLayers?: string;
     readonly launchProfile?: "a1" | "pi";
+    readonly launchMode?: "tabs" | "solo";
     readonly immutableWarmup?: "1";
+    readonly residentRootExecutable?: string;
+    readonly residentRootArguments?: string;
+    readonly residentFallback?: string;
 }
+/** The Tabs settings configure resident tabs; a direct-route launch, by `a1 solo` or by a fallback, hides them. */
+export declare function hidesTabSettings(context: Pick<LaunchContext, "launchMode" | "residentFallback">): boolean;
 export type LaunchContextRequirement = "optional" | "profile" | "release" | "warmup";
 /** Read current keys, fall back to superseded keys per field, with bounded diagnostics. */
 export declare function readLaunchContext(environment: NodeJS.ProcessEnv, requirement?: LaunchContextRequirement, platform?: NodeJS.Platform): LaunchContext;

package/dist/foundation/launch-context/index.js

@@ -6,7 +6,11 @@ export const PRIVATE_ENVIRONMENT = Object.freeze({
     releaseDigest: "LAUNCH_CONTEXT_RELEASE_DIGEST",
     releaseLayers: "LAUNCH_CONTEXT_RELEASE_LAYERS",
     launchProfile: "LAUNCH_CONTEXT_PROFILE",
+    launchMode: "LAUNCH_CONTEXT_MODE",
     immutableWarmup: "LAUNCH_CONTEXT_WARMUP",
+    residentRootExecutable: "LAUNCH_CONTEXT_RESIDENT_ROOT_EXECUTABLE",
+    residentRootArguments: "LAUNCH_CONTEXT_RESIDENT_ROOT_ARGUMENTS",
+    residentFallback: "LAUNCH_CONTEXT_RESIDENT_FALLBACK",
 });
 /**
  * Keys published by releases that predate the neutral cutover. They are read when
@@ -27,6 +31,10 @@ const SUPERSEDED_ENTRIES = Object.entries(SUPERSEDED_ENVIRONMENT);
 const PRIVATE_KEYS = new Set([...Object.values(PRIVATE_ENVIRONMENT), ...Object.values(SUPERSEDED_ENVIRONMENT)]);
 const LOGICAL_KEYS = new Map(PRIVATE_ENTRIES.map(([logical, key]) => [key, logical]));
 const SUPERSEDED_LOGICAL_KEYS = new Map(SUPERSEDED_ENTRIES.map(([logical, key]) => [key, logical]));
+/** The Tabs settings configure resident tabs; a direct-route launch, by `a1 solo` or by a fallback, hides them. */
+export function hidesTabSettings(context) {
+    return context.launchMode === "solo" || context.residentFallback !== undefined;
+}
 /** Read current keys, fall back to superseded keys per field, with bounded diagnostics. */
 export function readLaunchContext(environment, requirement = "optional", platform = process.platform) {
     const values = {};
@@ -61,8 +69,25 @@ export function readLaunchContext(environment, requirement = "optional", platfor
     if (values.launchProfile !== undefined && values.launchProfile !== "a1" && values.launchProfile !== "pi") {
         throw invalidContext("launchProfile", "unsupported profile");
     }
+    if (values.launchMode !== undefined && values.launchMode !== "tabs" && values.launchMode !== "solo") {
+        throw invalidContext("launchMode", "unsupported launch mode");
+    }
+    if (values.launchProfile === "pi" && values.launchMode === "tabs")
+        throw invalidContext("launchMode", "Pi comparison cannot use tabs");
     if (values.immutableWarmup !== undefined && values.immutableWarmup !== "1")
         throw invalidContext("immutableWarmup", "invalid permission flag");
+    if ((values.residentRootExecutable === undefined) !== (values.residentRootArguments === undefined))
+        throw invalidContext("residentRootExecutable", "resident root command is incomplete");
+    if (values.residentRootArguments !== undefined) {
+        try {
+            const argumentsValue = JSON.parse(values.residentRootArguments);
+            if (!Array.isArray(argumentsValue) || argumentsValue.some(value => typeof value !== "string"))
+                throw new Error("not string arguments");
+        }
+        catch {
+            throw invalidContext("residentRootArguments", "invalid JSON argument list");
+        }
+    }
     if (values.releaseDigest !== undefined && !/^[a-f0-9]{64}$/.test(values.releaseDigest))
         throw invalidContext("releaseDigest", "invalid digest");
     if (requirement === "profile")

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

@@ -16,11 +16,16 @@ interface GuardianControl {
     off(event: "disconnect", listener: () => void): unknown;
     close(): void;
 }
+export interface LaunchGuardianRootCommand {
+    readonly executable: string;
+    readonly arguments: readonly string[];
+}
 export interface LaunchGuardianOptions {
     readonly profileId: LaunchProfileId;
     readonly releaseRoot: string;
     readonly uiEntry: string;
     readonly sessionSelection?: SessionSelection;
+    readonly rootCommand?: LaunchGuardianRootCommand;
     readonly environment?: NodeJS.ProcessEnv;
     readonly cwd?: string;
     readonly helperPath?: string;

package/dist/foundation/launch-guardian/main.js

@@ -44,7 +44,8 @@ export async function runLaunchGuardian(options) {
         });
         let handle;
         try {
-            handle = await containment.spawn(process.execPath, [options.uiEntry, ...sessionArgs], {
+            const rootCommand = options.rootCommand ?? { executable: process.execPath, arguments: [options.uiEntry, ...sessionArgs] };
+            handle = await containment.spawn(rootCommand.executable, [...rootCommand.arguments], {
                 cwd: options.cwd ?? process.cwd(),
                 environment: environmentEntries(environment),
                 ...(environment.TERM ? { terminalType: environment.TERM } : {}),

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

@@ -2,11 +2,13 @@ import { type SupervisorEndpointMetadata } from "./cohort-state.js";
 import { resolveProductPaths, type SessionSelection, type LaunchProfileId, type SupervisorStartupAttemptIdentity } from "../lifecycle/index.js";
 import { cleanupProvenIdleOwner } from "./process-cleanup.js";
 import { type MaterializedRelease, type VerifyMaterializedReleaseOptions } from "./release-store.js";
+import { type EnsureTerminalHostOptions, type EnsureTerminalHostResult } from "../resident-tabs/index.js";
 export interface BootstrapOptions {
     readonly packageRoot: string;
     readonly launchIntent?: {
         readonly kind: "interactive";
         readonly profileId: LaunchProfileId;
+        readonly launchMode: "tabs" | "solo";
         readonly sessionSelection?: SessionSelection;
     };
     readonly environment?: NodeJS.ProcessEnv;
@@ -23,6 +25,10 @@ export interface BootstrapOptions {
     readonly releaseIsLaunchable?: (releaseRoot: string) => boolean;
     /** Test seam for bounded maintenance scheduled after stale endpoint sweeping. */
     readonly scheduleMaintenance?: (dataDir: string, paths: ReturnType<typeof resolveProductPaths>) => Promise<void>;
+    /** Test seam for resident launch routing before the guardian starts. */
+    readonly ensureTerminalHost?: (options: EnsureTerminalHostOptions) => Promise<EnsureTerminalHostResult>;
+    /** Test seam for whether this process's standard input and output are terminals; absent reads them. */
+    readonly interactiveTerminal?: boolean;
 }
 export declare function runBootstrap(options: BootstrapOptions): Promise<number>;
 export declare function certifyMaterializedRelease(release: MaterializedRelease, dataDir: string, verification?: VerifyMaterializedReleaseOptions): Promise<string>;

package/dist/foundation/release/bootstrap.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { restoreAfterOwnedExit } from "../terminal-cleanup/index.js";
+import { CLEAR_EXIT_INTERVAL_MS, restoreAfterOwnedExit } from "../terminal-cleanup/index.js";
 import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { connect } from "node:net";
 import { resolve } from "node:path";
@@ -15,26 +15,63 @@ import { selectUpdateLaunchRelease } from "./update-launch.js";
 import { consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease } from "./release-store.js";
 import { scheduleReleaseCleanup } from "./release-gc.js";
 import { createRestartSeal, readRestartCertifiedRelease, releaseCertificationDocument } from "./restart-certification.js";
-import { PRODUCT_TEXT } from "../../product-identity.js";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 import { markStartupPhase } from "../startup/index.js";
-import { launchContractTarget, readLaunchContext, withLaunchContext } from "../launch-context/index.js";
+import { isCurrentLaunchContract, launchContractTarget, readLaunchContext, withLaunchContext } from "../launch-context/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);
 }
 async function runBootstrapAttempt(options, retriesRemaining) {
-    const environment = withLaunchContext(options.environment ?? process.env, { launchProfile: options.launchIntent?.profileId ?? "a1" });
-    await markStartupPhase(environment, "bootstrap-start");
     const launchProfileId = options.launchIntent?.profileId ?? "a1";
+    const launchMode = options.launchIntent?.launchMode ?? (launchProfileId === "a1" ? "tabs" : "solo");
+    const environment = withLaunchContext(options.environment ?? process.env, { launchProfile: launchProfileId, launchMode });
+    await markStartupPhase(environment, "bootstrap-start");
     assertLaunchProfileId(launchProfileId);
     const sessionArgs = sessionSelectionArguments(options.launchIntent?.sessionSelection);
-    if (sessionArgs.length > 0 && launchProfileId !== "a1")
-        throw new Error("session selection requires the normal A1 profile");
+    if (sessionArgs.length > 0 && (launchProfileId !== "a1" || launchMode === "solo")) {
+        throw new Error("session selection requires the normal tabbed A1 launch");
+    }
     const output = options.output ?? process.stderr;
     const paths = resolveProductPaths(environment);
     await mkdir(paths.runtimeDir, { recursive: true, mode: 0o700 });
     const launchSelected = async (release) => {
-        const result = await launchUi(release, environment, sessionArgs);
+        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,
+            currentLaunchContract: isCurrentLaunchContract(release),
+            solo: launchMode === "solo",
+            interactive: options.interactiveTerminal ?? (process.stdin.isTTY === true && process.stdout.isTTY === true),
+            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) {
+            residentContext = resident.status === "ready" ? {
+                residentRootExecutable: resident.executable,
+                residentRootArguments: JSON.stringify([
+                    "attach", "--endpoint", resident.endpoint, "--cwd", process.cwd(), "--clear-exit-ms", String(CLEAR_EXIT_INTERVAL_MS),
+                    "--tabs-max", String((await residentLaunchSettings).tabsMax),
+                    "--profile", environment[PRODUCT_IDENTITY.environment.profileHome] ?? paths.configDir,
+                    "--data-dir", paths.dataDir, "--runtime-dir", paths.runtimeDir,
+                    "--release-root", release.releaseRoot, "--node-executable", process.execPath,
+                ]),
+            } : { residentFallback: resident.reason };
+        }
+        const result = await launchUi(release, environment, sessionArgs, residentContext);
         if (!result.releaseSuperseded)
             return result.code;
         if (retriesRemaining > 0)
@@ -327,13 +364,15 @@ export async function startSupervisor(release, environment) {
     child.unref();
     return { ...attempt, childOutcome };
 }
-async function launchUi(release, environment, sessionArgs) {
+async function launchUi(release, environment, sessionArgs, residentContext = {}) {
     await markStartupPhase(environment, "bootstrap-selected");
     const entry = await resolveReleaseEntryPoint(release, "bin/guardian.js");
     return await new Promise((resolvePromise, rejectPromise) => {
         let releaseSuperseded = false;
+        const releaseEnv = releaseEnvironment(environment, release, readLaunchContext(environment, "profile").launchProfile);
+        const launchEnvironment = Object.keys(residentContext).length === 0 ? releaseEnv : withLaunchContext(releaseEnv, { ...readLaunchContext(releaseEnv), ...residentContext }, process.platform, launchContractTarget(release));
         const child = spawn(process.execPath, [entry, ...sessionArgs], {
-            env: releaseEnvironment(environment, release, readLaunchContext(environment, "profile").launchProfile),
+            env: launchEnvironment,
             stdio: ["inherit", "inherit", "inherit", "ipc"],
             windowsHide: false,
         });
@@ -357,12 +396,14 @@ async function launchUi(release, environment, sessionArgs) {
  * version instead of failing while an installation is being replaced.
  */
 export function releaseEnvironment(environment, release, profile) {
+    const launchMode = readLaunchContext(environment).launchMode;
     return withLaunchContext(environment, {
         releaseId: release.releaseId,
         releaseLayers: (release.dependencyLayers ?? []).map(layer => layer.layerId).join(","),
         releaseRoot: release.releaseRoot,
         releaseDigest: release.contentDigest,
         ...(profile === undefined ? {} : { launchProfile: profile }),
+        ...(launchMode === undefined ? {} : { launchMode }),
     }, process.platform, launchContractTarget(release));
 }
 export async function waitForVerifiedEndpoint(path, release, timeoutMs, startup) {

package/dist/foundation/release/cohort-state.d.ts

@@ -19,7 +19,7 @@ export interface ReleaseReferences {
     readonly rollback: string | null;
     readonly retention: readonly string[];
 }
-export type ExternalReleaseHoldAuthority = "agent" | "migration";
+export type ExternalReleaseHoldAuthority = "agent" | "migration" | "resident";
 /** A current hold supplied by an authority that must participate in every reconciliation. */
 export interface ExternalReleaseHold {
     readonly authority: ExternalReleaseHoldAuthority;

package/dist/foundation/release/cohort-state.js

@@ -12,7 +12,7 @@ const RELEASE_ID_PATTERN = /^[0-9A-Za-z.+_-]+-[a-f0-9]{20}$/;
 export function planProtectedReleases(state, inputs = {}) {
     const holds = inputs.externalHolds ?? [];
     for (const hold of holds) {
-        if (hold.authority !== "agent" && hold.authority !== "migration")
+        if (hold.authority !== "agent" && hold.authority !== "migration" && hold.authority !== "resident")
             throw new Error(`unknown release hold authority: ${String(hold.authority)}`);
         if (!state.releases[hold.releaseId] && !state.cleanup.pending[hold.releaseId]) {
             throw new Error(`external ${hold.authority} hold names unknown release ${hold.releaseId}`);