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

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

@@ -8,6 +8,7 @@ export interface BootstrapOptions {
     readonly launchIntent?: {
         readonly kind: "interactive";
         readonly profileId: LaunchProfileId;
+        readonly launchMode: "tabs" | "solo";
         readonly sessionSelection?: SessionSelection;
     };
     readonly environment?: NodeJS.ProcessEnv;
@@ -24,9 +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 seams for resident launch routing before the guardian starts. */
-    readonly readResidentTabs?: (profileDir: string, namespace: string, legacyConfigDir: string, profileId: string) => Promise<boolean>;
+    /** 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

@@ -24,13 +24,15 @@ 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 });
@@ -44,11 +46,9 @@ async function runBootstrapAttempt(options, retriesRemaining) {
             : 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),
+            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,
@@ -64,6 +64,7 @@ async function runBootstrapAttempt(options, retriesRemaining) {
                 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,
@@ -395,12 +396,14 @@ async function launchUi(release, environment, sessionArgs, residentContext = {})
  * 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}`);

package/dist/foundation/release/release-gc.d.ts

@@ -2,6 +2,7 @@ import { rename, rm } from "node:fs/promises";
 import { CohortStateStore, type ExternalReleaseHold, type OrphanReleaseDisposition } from "./cohort-state.js";
 import type { ProductPaths } from "../lifecycle/index.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
+import { type ResidentReleaseHoldReport } from "../resident-tabs/index.js";
 export interface ReleaseCleanupLimits {
     readonly maxItems: number;
     readonly maxDurationMs: number;
@@ -21,6 +22,8 @@ export interface ReleaseCleanupOptions {
     readonly operations?: ReleaseCleanupOperations;
     /** Process-start seam for scheduler and continuation tests. */
     readonly workerSpawner?: (entry: string, environment: NodeJS.ProcessEnv) => Promise<void>;
+    /** Resident-tab inspection seam; the default asks a verified installed terminal host. */
+    readonly residentHolds?: (dataDir: string, releaseRoots: readonly string[]) => Promise<ResidentReleaseHoldReport>;
 }
 export interface ReleaseCleanupWorkerOptions {
     readonly cleanup?: ReleaseCleanupOptions;

package/dist/foundation/release/release-gc.js

@@ -14,6 +14,7 @@ import { UpdateTransactionStore } from "./update-transaction.js";
 import { cleanupUpdateRecoveryCapsules } from "./update-recovery.js";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { collectCompileCaches, startupCompileCachePath } from "../startup/index.js";
+import { readResidentReleaseHolds } from "../resident-tabs/index.js";
 const DEFAULT_CANDIDATE_AGE_MS = 60 * 60 * 1_000;
 const DEFAULT_LIMITS = { maxItems: 8, maxDurationMs: 2_000, concurrency: 1 };
 const DEFAULT_WORKER_DURATION_MS = 10 * 60 * 1_000;
@@ -30,7 +31,7 @@ export async function prepareReleaseCleanup(dataDir, paths, options = {}) {
     const store = new CohortStateStore(dataDir);
     const discovered = await discoverCleanupInputs(dataDir, store, options);
     const transactionStore = options.transactionStore ?? new UpdateTransactionStore(dataDir);
-    await store.reconcileRetention(async () => await protectionInputs(paths, transactionStore, options.externalHolds ?? []), discovered.orphans);
+    await store.reconcileRetention(async () => await protectionInputs(dataDir, paths, transactionStore, options.externalHolds ?? [], options.residentHolds), discovered.orphans);
     for (const diagnostic of discovered.diagnostics.slice(0, 16)) {
         await store.recordCleanupFailure(diagnostic.releaseId, diagnostic.stage, diagnostic.error);
     }
@@ -77,7 +78,7 @@ export async function runBoundedReleaseCleanup(dataDir, paths, options = {}) {
             maximum -= 1;
             const certificationId = certificationReleaseId(artifact);
             if (certificationId !== null) {
-                const inputs = await protectionInputs(paths, transactionStore, options.externalHolds ?? []);
+                const inputs = await protectionInputs(dataDir, paths, transactionStore, options.externalHolds ?? [], options.residentHolds);
                 if (isProtectedDetachedRelease(await store.read(), inputs, certificationId))
                     continue;
             }
@@ -232,7 +233,7 @@ export async function collectRelease(store, dataDir, releaseId, externalReferenc
     const state = await store.read();
     if (!state.releases[releaseId])
         throw new Error(`unknown release ${releaseId}`);
-    await store.reconcileRetention(async () => ({ ...(await protectionInputs(paths, new UpdateTransactionStore(dataDir), holds)) }));
+    await store.reconcileRetention(async () => ({ ...(await protectionInputs(dataDir, paths, new UpdateTransactionStore(dataDir), holds)) }));
     const disposition = (await store.read()).cleanup.pending[releaseId];
     if (!disposition)
         throw new Error(`release ${releaseId} is still referenced and cannot be collected`);
@@ -243,7 +244,7 @@ export async function collectRelease(store, dataDir, releaseId, externalReferenc
 async function collectDisposition(store, dataDir, paths, disposition, options) {
     const releaseId = disposition.release.releaseId;
     try {
-        const inputs = await protectionInputs(paths, options.transactionStore ?? new UpdateTransactionStore(dataDir), options.externalHolds ?? []);
+        const inputs = await protectionInputs(dataDir, paths, options.transactionStore ?? new UpdateTransactionStore(dataDir), options.externalHolds ?? [], options.residentHolds);
         const current = await store.read();
         if (isProtectedDetachedRelease(current, inputs, releaseId))
             return false;
@@ -289,12 +290,47 @@ function isProtectedDetachedRelease(state, inputs, releaseId) {
         || (inputs.externalHolds ?? []).some(hold => hold.releaseId === releaseId)
         || (inputs.transaction?.status === "active" && inputs.transaction.priorActiveReleaseId === releaseId);
 }
-async function protectionInputs(paths, transactionStore, externalHolds) {
-    const [liveIds, transaction] = await Promise.all([
+async function protectionInputs(dataDir, paths, transactionStore, externalHolds, residentHolds) {
+    const [liveIds, transaction, resident] = await Promise.all([
         paths ? liveReleaseIds(paths) : Promise.resolve([]),
         transactionStore.read(),
+        residentReleaseHolds(dataDir, residentHolds),
     ]);
-    return { liveReleaseIds: liveIds, externalHolds, transaction: transactionReference(transaction) };
+    return { liveReleaseIds: liveIds, externalHolds: [...externalHolds, ...resident], transaction: transactionReference(transaction) };
+}
+/**
+ * Holds every release a live resident server, holder, or tab child runs from. Retention fails
+ * closed: an incomplete report, or a recorded root inside the release store that names no known
+ * release, holds every known release.
+ */
+async function residentReleaseHolds(dataDir, reader) {
+    const state = await new CohortStateStore(dataDir).read();
+    const records = [
+        ...Object.values(state.releases),
+        ...Object.values(state.cleanup.pending).map(disposition => disposition.release),
+    ];
+    const preferred = [state.references.active, state.references.rollback]
+        .flatMap(id => id && state.releases[id] ? [state.releases[id].releaseRoot] : []);
+    const roots = [...new Set([...preferred, ...Object.values(state.releases).map(record => record.releaseRoot)])];
+    const report = await (reader ?? ((directory, releaseRoots) => readResidentReleaseHolds({ dataDir: directory, releaseRoots })))(dataDir, roots);
+    const everything = () => [...new Set(records.map(record => record.releaseId))].map(releaseId => ({ authority: "resident", releaseId }));
+    if (!report.complete)
+        return everything();
+    const byRoot = new Map(records.map(record => [comparablePath(record.releaseRoot), record.releaseId]));
+    const store = comparablePath(resolve(dataDir, "releases"));
+    const holds = new Set();
+    for (const root of report.releaseRoots) {
+        const releaseId = byRoot.get(comparablePath(root));
+        if (releaseId)
+            holds.add(releaseId);
+        else if (comparablePath(root).startsWith(`${store}${sep}`))
+            return everything();
+    }
+    return [...holds].sort().map(releaseId => ({ authority: "resident", releaseId }));
+}
+function comparablePath(path) {
+    const absolute = resolve(path);
+    return process.platform === "win32" ? absolute.toLowerCase() : absolute;
 }
 function transactionReference(transaction) {
     return transaction === null ? null : { status: transaction.status, priorActiveReleaseId: transaction.priorActiveReleaseId };
@@ -745,7 +781,7 @@ function parseWorkerHolds(value) {
         if (!Array.isArray(parsed))
             return [];
         return parsed.filter((hold) => Boolean(hold) && typeof hold === "object"
-            && (hold.authority === "agent" || hold.authority === "migration")
+            && ["agent", "migration", "resident"].includes(hold.authority)
             && typeof hold.releaseId === "string");
     }
     catch {

package/dist/foundation/resident-tabs/bounded-host-command.d.ts

@@ -0,0 +1,16 @@
+export interface BoundedHostCommandResult {
+    readonly code: number;
+    readonly stdout: string;
+}
+export interface BoundedHostCommandLimits {
+    /** Output beyond this many bytes fails the exchange instead of being parsed. */
+    readonly maxStdoutBytes: number;
+    readonly timeoutMs: number;
+    /** Names the exchange in the timeout error. */
+    readonly label: string;
+}
+/**
+ * Runs one terminal-host command whose report is small. An oversized report kills the command and
+ * reports a failed exchange; a command that outlives its deadline is killed and rejected.
+ */
+export declare function runBoundedHostCommand(executable: string, arguments_: readonly string[], limits: BoundedHostCommandLimits): Promise<BoundedHostCommandResult>;

package/dist/foundation/resident-tabs/bounded-host-command.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+/**
+ * Runs one terminal-host command whose report is small. An oversized report kills the command and
+ * reports a failed exchange; a command that outlives its deadline is killed and rejected.
+ */
+export async function runBoundedHostCommand(executable, arguments_, limits) {
+    return await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(executable, [...arguments_], { windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
+        const stdout = [];
+        let size = 0;
+        let overflowed = false;
+        child.stdout.on("data", chunk => {
+            size += chunk.length;
+            // Security: an oversized answer is a failed exchange, never a truncated report to parse.
+            if (size > limits.maxStdoutBytes) {
+                overflowed = true;
+                child.kill("SIGKILL");
+            }
+            else
+                stdout.push(Buffer.from(chunk));
+        });
+        child.once("error", rejectPromise);
+        child.once("close", code => {
+            clearTimeout(timer);
+            resolvePromise(overflowed
+                ? { code: code === 0 || code === null ? 1 : code, stdout: "" }
+                : { code: code ?? 1, stdout: Buffer.concat(stdout).toString("utf8") });
+        });
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            rejectPromise(new Error(`${limits.label} timed out`));
+        }, limits.timeoutMs);
+        timer.unref();
+    });
+}

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

@@ -1,4 +1,4 @@
-export type ResidentTabStatus = "starting" | "working" | "idle" | "unresponsive" | "stalled" | "crashed" | "restarting" | "failed";
+export type ResidentTabStatus = "starting" | "working" | "needs-input" | "done-unseen" | "idle" | "unresponsive" | "stalled" | "crashed" | "restarting" | "failed";
 export interface TabBridgeCredentials {
     readonly tabId: string;
     readonly token: string;
@@ -8,6 +8,17 @@ export interface TabAttachment {
     readonly clientId: string;
     readonly controllerRevision: number;
 }
+export type TabBridgeCommand = {
+    readonly type: "visibility";
+    readonly visible: boolean;
+} | {
+    readonly type: "rename";
+    readonly name: string;
+    readonly nameSource: "default" | "user" | "auto";
+} | {
+    readonly type: "stop";
+    readonly deadlineMs: number;
+};
 interface BridgeTransport {
     write(bytes: Uint8Array): boolean;
     destroy(): void;
@@ -30,12 +41,16 @@ export declare class TabBridgeClient {
     constructor(options: TabBridgeOptions);
     get available(): boolean;
     captureAttachment(): TabAttachment | null;
+    onCommand(listener: (command: TabBridgeCommand) => void): () => void;
     start(timeoutMs?: number): Promise<boolean>;
-    status(state: ResidentTabStatus, degraded?: boolean): void;
+    status(state: ResidentTabStatus, degraded?: boolean, pendingRequests?: number, queuedInput?: number): void;
     degraded(degraded: boolean): void;
-    session(file: string | null, name: string | null): void;
+    accent(accent: string): void;
+    session(file: string | null, name: string | null, nameSource?: "default" | "user" | "auto"): void;
+    prompt(interrupted: boolean): void;
     requestDetach(origin?: TabAttachment | null, timeoutMs?: number): Promise<boolean>;
     requestRestart(origin?: TabAttachment | null, timeoutMs?: number): Promise<boolean>;
+    consumeControllerBoundaryInput(data: string): string;
     close(): void;
 }
 export {};

package/dist/foundation/resident-tabs/bridge-client.js

@@ -13,13 +13,20 @@ export class TabBridgeClient {
     #closed = false;
     #retry = null;
     #latestStatus = null;
+    #accent = null;
     #latestSession = null;
     #heartbeat = null;
     #pending = new Map();
     #startWaiter = null;
+    #commandListeners = new Set();
+    #boundaryInputRemainder = "";
     constructor(options) { this.#options = options; }
     get available() { return this.#available && this.#connected; }
     captureAttachment() { return this.#attachment === null ? null : { ...this.#attachment }; }
+    onCommand(listener) {
+        this.#commandListeners.add(listener);
+        return () => this.#commandListeners.delete(listener);
+    }
     async start(timeoutMs = 4_000) {
         if (this.#closed || this.#transport !== null)
             return this.available;
@@ -56,7 +63,7 @@ export class TabBridgeClient {
             transport.once("connect", () => {
                 this.#send("hello", {
                     role: "bridge", generation: 1, build: this.#options.build ?? "a1",
-                    features: ["bridge-status", "bridge-detach", "bridge-heartbeat", "bridge-restart", "recovery-journal"],
+                    features: ["bridge-status", "bridge-detach", "bridge-heartbeat", "bridge-restart", "bridge-visibility", "bridge-rename", "bridge-stop", "controller-boundary", "recovery-journal"],
                     token: [...Buffer.from(this.#options.credentials.token, "base64")], tabId: this.#options.credentials.tabId,
                     pid: this.#options.pid ?? process.pid, startIdentity: this.#options.startIdentity ?? `${process.pid}:node`,
                 }, ++this.#request);
@@ -66,23 +73,34 @@ export class TabBridgeClient {
             timer.unref();
         });
     }
-    status(state, degraded = false) {
-        this.#latestStatus = { state, degraded };
+    status(state, degraded = false, pendingRequests = 0, queuedInput = 0) {
+        this.#latestStatus = { state, degraded, accent: this.#accent, pendingRequests, queuedInput };
         const recoveryState = state === "unresponsive" || state === "stalled" || state === "crashed" || state === "restarting" || state === "failed";
         if (recoveryState && !this.#supports("recovery-status"))
             return;
         this.#send("bridge.status", {
             seq: ++this.#sequence,
             state,
+            pendingRequests: Math.max(0, Math.trunc(pendingRequests)),
+            queuedInput: Math.max(0, Math.trunc(queuedInput)),
+            ...(this.#accent === null ? {} : { accent: this.#accent }),
             ...(degraded && this.#supports("recovery-status") ? { degraded: true } : {}),
         });
     }
     degraded(degraded) {
         this.status(this.#latestStatus?.state ?? "idle", degraded);
     }
-    session(file, name) {
-        this.#latestSession = { file, name };
-        this.#send("bridge.session", { file, name });
+    accent(accent) {
+        this.#accent = accent;
+        if (this.#latestStatus !== null)
+            this.status(this.#latestStatus.state, this.#latestStatus.degraded, this.#latestStatus.pendingRequests, this.#latestStatus.queuedInput);
+    }
+    session(file, name, nameSource = "default") {
+        this.#latestSession = { file, name, nameSource };
+        this.#send("bridge.session", { file, name, nameSource });
+    }
+    prompt(interrupted) {
+        this.#send("bridge.prompt", { interrupted });
     }
     requestDetach(origin = this.captureAttachment(), timeoutMs = 1_000) {
         return this.#requestAction("detach", origin, timeoutMs);
@@ -90,6 +108,51 @@ export class TabBridgeClient {
     requestRestart(origin = this.captureAttachment(), timeoutMs = 1_000) {
         return this.#requestAction("restart", origin, timeoutMs);
     }
+    consumeControllerBoundaryInput(data) {
+        const prefix = "\x1bP+a1;controller=";
+        const suffix = "\x1b\\";
+        let pending = this.#boundaryInputRemainder + data;
+        this.#boundaryInputRemainder = "";
+        let output = "";
+        while (pending.length > 0) {
+            const start = pending.indexOf(prefix);
+            if (start === -1) {
+                let retained = 0;
+                const maximum = Math.min(prefix.length - 1, pending.length);
+                for (let length = maximum; length > 0; length--) {
+                    if (pending.endsWith(prefix.slice(0, length))) {
+                        retained = length;
+                        break;
+                    }
+                }
+                const split = pending.length - retained;
+                output += pending.slice(0, split);
+                this.#boundaryInputRemainder = pending.slice(split);
+                break;
+            }
+            output += pending.slice(0, start);
+            const end = pending.indexOf(suffix, start + prefix.length);
+            if (end === -1) {
+                this.#boundaryInputRemainder = pending.slice(start);
+                break;
+            }
+            const body = pending.slice(start + prefix.length, end);
+            const separator = body.indexOf(";");
+            const generation = Number(body.slice(0, separator));
+            const nonceHex = body.slice(separator + 1);
+            if (separator > 0 && Number.isSafeInteger(generation) && generation > 0 && /^[0-9a-f]{32}$/u.test(nonceHex)) {
+                this.#send("bridge.boundary", {
+                    generation,
+                    nonce: [...Buffer.from(nonceHex, "hex")],
+                });
+            }
+            else {
+                output += pending.slice(start, end + suffix.length);
+            }
+            pending = pending.slice(end + suffix.length);
+        }
+        return output;
+    }
     close() {
         this.#closed = true;
         if (this.#retry !== null)
@@ -101,6 +164,10 @@ export class TabBridgeClient {
         transport?.destroy();
         this.#fail(false);
     }
+    #emitCommand(command) {
+        for (const listener of this.#commandListeners)
+            listener(command);
+    }
     #send(type, body, requestId) {
         if (this.#transport === null || (!this.#connected && type !== "hello"))
             return;
@@ -121,7 +188,7 @@ export class TabBridgeClient {
             if (this.#supports("bridge-heartbeat"))
                 this.#startHeartbeat();
             if (this.#latestStatus !== null)
-                this.status(this.#latestStatus.state, this.#latestStatus.degraded);
+                this.status(this.#latestStatus.state, this.#latestStatus.degraded, this.#latestStatus.pendingRequests, this.#latestStatus.queuedInput);
             if (this.#latestSession !== null)
                 this.#send("bridge.session", this.#latestSession);
             return;
@@ -130,6 +197,19 @@ export class TabBridgeClient {
             this.#fail();
             return;
         }
+        if (message.type === "bridge.visibility" && typeof message.body["visible"] === "boolean") {
+            this.#emitCommand({ type: "visibility", visible: message.body["visible"] });
+            return;
+        }
+        if (message.type === "bridge.rename" && typeof message.body["name"] === "string") {
+            const source = message.body["nameSource"];
+            this.#emitCommand({ type: "rename", name: message.body["name"], nameSource: source === "auto" || source === "default" ? source : "user" });
+            return;
+        }
+        if (message.type === "bridge.stop" && typeof message.body["deadlineMs"] === "number") {
+            this.#emitCommand({ type: "stop", deadlineMs: message.body["deadlineMs"] });
+            return;
+        }
         if (message.type === "attachment") {
             const clientId = message.body["clientId"];
             const revision = message.body["controllerRevision"];

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

@@ -0,0 +1,29 @@
+import type { MaintenanceReport } from "./maintenance.js";
+export declare const DOCTOR_MAX_BYTES: number;
+export interface DoctorOptions {
+    /** The profile's resident state directory, as reported by the terminal host. */
+    readonly stateDir: string;
+    readonly hostStatus: MaintenanceReport;
+    readonly releaseRoots: readonly string[];
+    readonly settings: {
+        readonly tabsMax: number;
+        readonly tabsAutoName: boolean;
+    };
+    readonly home?: string;
+    readonly platform?: NodeJS.Platform;
+    readonly architecture?: string;
+    readonly now?: Date;
+    readonly maxBytes?: number;
+}
+export interface DoctorBundle {
+    readonly path: string;
+    readonly bytes: number;
+    readonly dropped: readonly string[];
+}
+/**
+ * Writes an owner-only diagnostic bundle by allowlist: structured logs, crash records, host
+ * status, a redacted registry, the owner marker without secrets, artifact verification, platform
+ * facts, and the Tabs settings. Secrets, tokens, environment values, prompt journals, drafts,
+ * last screens, the private child-stderr sink, and terminal content are never read.
+ */
+export declare function writeDoctorBundle(options: DoctorOptions): Promise<DoctorBundle>;