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

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,7 +18,13 @@ 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)
+        return { startup: { quiet: true } };
+    return fallbackNotice === undefined ? {} : { startup: { notices: [{ kind: "warning", message: fallbackNotice }] } };
+}
 export async function composeOwnedUiApplication(options = {}) {
     return (await composeOwnedUi(options)).application;
 }
@@ -82,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" },
@@ -120,6 +129,18 @@ export async function composeOwnedUi(options = {}) {
         await host.dispose();
         throw error;
     }
+    const tabBridge = options.tab?.bridge ?? null;
+    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) {
@@ -228,13 +249,26 @@ export async function composeOwnedUi(options = {}) {
                     },
                 }),
                 ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
+                ...(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) }),
+                ...residentStartupPresentation(tabBridge !== null, options.residentFallbackNotice),
                 ...(clipboardDiagnostics === null ? {} : { input: { onEvent: event => clipboardDiagnostics.runtime(event) } }),
                 ...(viewportSettings === null ? {} : { viewportSettings }),
                 ...(backgroundSettings === null ? {} : { backgroundSettings }),
-                ...(settings === null || !ownedSurfaces ? {} : {
+                ...(settings === null || !ownedSurfaces || tabBridge !== null ? {} : {
                     quitOutro: { snapshot: () => quitOutroSettingsSnapshot(settings), interactive: process.stdout.isTTY === true },
                 }),
             },
@@ -255,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) {
@@ -323,6 +365,8 @@ export async function composeOwnedUi(options = {}) {
                 await releaseNoteClaim?.release();
                 suggestionDiagnostics?.dispose();
                 clipboardDiagnostics?.dispose();
+                unsubscribeTabBridge();
+                tabBridge?.close();
                 // Invariant: the host outlives the application; disposing it cancels host-level probes last.
                 await host.dispose();
             }
@@ -330,6 +374,35 @@ export async function composeOwnedUi(options = {}) {
     };
     return { application, settings };
 }
+export async function bindResidentTabBridge(tabBridge, backend, recovery = null) {
+    await tabBridge.start().catch(() => false);
+    tabBridge.status("starting");
+    const currentSessionFile = () => currentBackendSessionFile(backend);
+    const announceSession = () => {
+        tabBridge.session(currentSessionFile(), backend.session.view().status.footer?.sessionName ?? null);
+    };
+    let working = false;
+    announceSession();
+    return backend.session.onEvent(event => {
+        if (event.type === "session-lifecycle") {
+            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/launch-context/index.d.ts

@@ -7,6 +7,9 @@ export declare const PRIVATE_ENVIRONMENT: Readonly<{
     releaseLayers: "LAUNCH_CONTEXT_RELEASE_LAYERS";
     launchProfile: "LAUNCH_CONTEXT_PROFILE";
     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
@@ -31,6 +34,9 @@ export interface LaunchContext {
     readonly releaseLayers?: string;
     readonly launchProfile?: "a1" | "pi";
     readonly immutableWarmup?: "1";
+    readonly residentRootExecutable?: string;
+    readonly residentRootArguments?: string;
+    readonly residentFallback?: string;
 }
 export type LaunchContextRequirement = "optional" | "profile" | "release" | "warmup";
 /** Read current keys, fall back to superseded keys per field, with bounded diagnostics. */

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

@@ -7,6 +7,9 @@ export const PRIVATE_ENVIRONMENT = Object.freeze({
     releaseLayers: "LAUNCH_CONTEXT_RELEASE_LAYERS",
     launchProfile: "LAUNCH_CONTEXT_PROFILE",
     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
@@ -63,6 +66,18 @@ export function readLaunchContext(environment, requirement = "optional", platfor
     }
     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,6 +2,7 @@ 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?: {
@@ -23,6 +24,9 @@ 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 seams for resident launch routing before the guardian starts. */
+    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>;
 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,9 +15,10 @@ 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);
@@ -34,7 +35,42 @@ async function runBootstrapAttempt(options, retriesRemaining) {
     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,
+            hasSessionSelection: sessionArgs.length > 0,
+            currentLaunchContract: isCurrentLaunchContract(release),
+            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) {
+            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),
+                    "--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 +363,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,
         });

package/dist/foundation/release/dependency-certification.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
-import { chmod, lstat, mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+import { chmod, lstat, mkdir, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { immutablePlatformPolicy } from "./immutable-platform.js";
 export const DEPENDENCY_CERTIFICATIONS_DIRECTORY = "dependency-certifications";
@@ -194,7 +194,8 @@ async function releasePublicationLock(path, token) {
     while (true) {
         try {
             if (!retired) {
-                await assertPublicationLockOwner(path, token);
+                if (!await assertPublicationLockOwner(path, token))
+                    return;
                 await rename(path, released);
                 retired = true;
             }
@@ -218,24 +219,58 @@ async function releasePublicationLock(path, token) {
 }
 /** Ownership uncertainty is never authority to retire a missing, linked, or replaced generation. */
 async function assertPublicationLockOwner(path, token) {
-    try {
-        const metadata = await lstat(path);
-        if (!metadata.isDirectory() || metadata.isSymbolicLink() || await realpath(path) !== path)
-            throw new Error("invalid lock directory");
-        const ownerPath = resolve(path, "owner.json");
-        const ownerMetadata = await lstat(ownerPath);
-        if (!ownerMetadata.isFile() || ownerMetadata.isSymbolicLink() || await realpath(ownerPath) !== ownerPath)
-            throw new Error("invalid owner file");
-        const owner = JSON.parse(await readFile(ownerPath, "utf8"));
-        if (!owner || typeof owner !== "object" || !("pid" in owner) || !("token" in owner)
-            || owner.pid !== process.pid || owner.token !== token)
-            throw new Error("owner generation differs");
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            const metadata = await lstat(path);
+            if (!metadata.isDirectory() || metadata.isSymbolicLink() || await realpath(path) !== path)
+                throw new Error("invalid lock directory");
+            const ownerPath = resolve(path, "owner.json");
+            const ownerMetadata = await lstat(ownerPath);
+            if (!ownerMetadata.isFile() || ownerMetadata.isSymbolicLink() || await realpath(ownerPath) !== ownerPath)
+                throw new Error("invalid owner file");
+            const owner = JSON.parse(await readFile(ownerPath, "utf8"));
+            if (!owner || typeof owner !== "object" || !("pid" in owner) || !("token" in owner)
+                || owner.pid !== process.pid || owner.token !== token)
+                throw new Error("owner generation differs");
+            return true;
+        }
+        catch (error) {
+            // Platform: Windows can briefly hide a directory immediately after a successful rename
+            // when independent publishers are contending. Re-read the complete identity; never treat
+            // absence as ownership and never retire a generation whose token differs.
+            if (hasCode(error, "ENOENT") && attempt < 3) {
+                await new Promise(resolvePromise => setTimeout(resolvePromise, 20 * attempt));
+                continue;
+            }
+            // Concurrency: a delayed abandoned-owner reclaimer can move a successor generation after
+            // reading the predecessor. If our exact token is now in a managed tombstone, no active
+            // generation belongs to this release call and returning without mutation is fail-safe.
+            if (hasCode(error, "ENOENT") && await publicationLockWasRetired(path, token))
+                return false;
+            if (isReleaseContention(error))
+                throw error;
+            throw new Error("publication lease release ownership could not be verified", { cause: error });
+        }
     }
-    catch (error) {
-        if (isReleaseContention(error))
-            throw error;
-        throw new Error("publication lease release ownership could not be verified", { cause: error });
+}
+async function publicationLockWasRetired(path, token) {
+    const directory = dirname(path);
+    const prefix = `${basename(path)}.`;
+    const entries = await readdir(directory, { withFileTypes: true });
+    if (entries.length > 256)
+        return false;
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith(prefix)
+            || (!entry.name.includes(".abandoned-") && !entry.name.includes(".released-")))
+            continue;
+        const ownerPath = resolve(directory, entry.name, "owner.json");
+        const owner = await readFile(ownerPath, "utf8")
+            .then(source => JSON.parse(source))
+            .catch(() => null);
+        if (owner?.pid === process.pid && owner.token === token)
+            return true;
     }
+    return false;
 }
 function isReleaseContention(error) {
     return ["EPERM", "EACCES", "EBUSY"].some(code => hasCode(error, code));

package/dist/foundation/release/progress-palette.generated.d.ts

@@ -1,5 +1,5 @@
 /**
- * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.1.0
- * (MIT), commit abe508e1b89912adde45528136c3221eb69acdd7. Do not edit directly.
+ * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.2.0
+ * (MIT), commit 06a466935536f8c9bcacb2d5efc0fc021be1bdff. Do not edit directly.
  */
 export declare const SHARED_PROGRESS_ACCENT_ANSI = "\u001B[38;2;167;152;215m";

package/dist/foundation/release/progress-palette.generated.js

@@ -1,5 +1,5 @@
 /**
- * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.1.0
- * (MIT), commit abe508e1b89912adde45528136c3221eb69acdd7. Do not edit directly.
+ * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.2.0
+ * (MIT), commit 06a466935536f8c9bcacb2d5efc0fc021be1bdff. Do not edit directly.
  */
 export const SHARED_PROGRESS_ACCENT_ANSI = "\u001b[38;2;167;152;215m";

package/dist/foundation/resident-tabs/bridge-client.d.ts

@@ -0,0 +1,41 @@
+export type ResidentTabStatus = "starting" | "working" | "idle" | "unresponsive" | "stalled" | "crashed" | "restarting" | "failed";
+export interface TabBridgeCredentials {
+    readonly tabId: string;
+    readonly token: string;
+    readonly endpoint: string;
+}
+export interface TabAttachment {
+    readonly clientId: string;
+    readonly controllerRevision: number;
+}
+interface BridgeTransport {
+    write(bytes: Uint8Array): boolean;
+    destroy(): void;
+    once(event: "connect" | "error" | "close", listener: (...args: unknown[]) => void): unknown;
+    on(event: "data", listener: (bytes: Buffer) => void): unknown;
+}
+export interface TabBridgeOptions {
+    readonly credentials: TabBridgeCredentials;
+    readonly pid?: number;
+    readonly startIdentity?: string;
+    readonly build?: string;
+    readonly connect?: (endpoint: string) => BridgeTransport;
+    readonly heartbeatIntervalMs?: number;
+    readonly setInterval?: (callback: () => void, milliseconds: number) => unknown;
+    readonly clearInterval?: (timer: unknown) => void;
+}
+/** Metadata-only advisory bridge. Terminal input and transcript bytes have no API here. */
+export declare class TabBridgeClient {
+    #private;
+    constructor(options: TabBridgeOptions);
+    get available(): boolean;
+    captureAttachment(): TabAttachment | null;
+    start(timeoutMs?: number): Promise<boolean>;
+    status(state: ResidentTabStatus, degraded?: boolean): void;
+    degraded(degraded: boolean): void;
+    session(file: string | null, name: string | null): void;
+    requestDetach(origin?: TabAttachment | null, timeoutMs?: number): Promise<boolean>;
+    requestRestart(origin?: TabAttachment | null, timeoutMs?: number): Promise<boolean>;
+    close(): void;
+}
+export {};