@timurproko/a1 0.2.7-dev.788 → 0.2.7-dev.794

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

@@ -15,16 +15,21 @@ export class TabBridgeClient {
     #latestStatus = null;
     #accent = null;
     #latestSession = null;
+    #latestShortcuts = null;
     #heartbeat = null;
     #pending = new Map();
     #startWaiter = null;
     #commandListeners = new Set();
+    #pendingCommands = [];
     #boundaryInputRemainder = "";
     constructor(options) { this.#options = options; }
+    get tabId() { return this.#options.credentials.tabId; }
     get available() { return this.#available && this.#connected; }
     captureAttachment() { return this.#attachment === null ? null : { ...this.#attachment }; }
     onCommand(listener) {
         this.#commandListeners.add(listener);
+        for (const command of this.#pendingCommands.splice(0))
+            listener(command);
         return () => this.#commandListeners.delete(listener);
     }
     async start(timeoutMs = 4_000) {
@@ -63,7 +68,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", "bridge-visibility", "bridge-rename", "bridge-stop", "controller-boundary", "recovery-journal"],
+                    features: ["bridge-status", "bridge-detach", "bridge-heartbeat", "bridge-restart", "bridge-visibility", "bridge-rename", "bridge-route", "bridge-stop", "bridge-shortcuts", "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);
@@ -102,12 +107,25 @@ export class TabBridgeClient {
     prompt(interrupted) {
         this.#send("bridge.prompt", { interrupted });
     }
+    /** Publishes the effective tab shortcut assignments so the host dispatches and labels the same keys. */
+    shortcuts(assignments) {
+        this.#latestShortcuts = Object.entries(assignments).map(([action, key]) => [action, key]);
+        this.#sendShortcuts();
+    }
+    #sendShortcuts() {
+        if (this.#latestShortcuts === null || !this.#supports("bridge-shortcuts"))
+            return;
+        this.#send("bridge.shortcuts", { assignments: this.#latestShortcuts.map(([action, key]) => [action, key]) });
+    }
     requestDetach(origin = this.captureAttachment(), timeoutMs = 1_000) {
         return this.#requestAction("detach", origin, timeoutMs);
     }
     requestRestart(origin = this.captureAttachment(), timeoutMs = 1_000) {
         return this.#requestAction("restart", origin, timeoutMs);
     }
+    requestClose(origin = this.captureAttachment(), timeoutMs = 1_000) {
+        return this.#requestAction("close", origin, timeoutMs);
+    }
     consumeControllerBoundaryInput(data) {
         const prefix = "\x1bP+a1;controller=";
         const suffix = "\x1b\\";
@@ -165,6 +183,12 @@ export class TabBridgeClient {
         this.#fail(false);
     }
     #emitCommand(command) {
+        if (this.#commandListeners.size === 0) {
+            if (this.#pendingCommands.length >= 16)
+                this.#pendingCommands.shift();
+            this.#pendingCommands.push(command);
+            return;
+        }
         for (const listener of this.#commandListeners)
             listener(command);
     }
@@ -191,6 +215,7 @@ export class TabBridgeClient {
                 this.status(this.#latestStatus.state, this.#latestStatus.degraded, this.#latestStatus.pendingRequests, this.#latestStatus.queuedInput);
             if (this.#latestSession !== null)
                 this.#send("bridge.session", this.#latestSession);
+            this.#sendShortcuts();
             return;
         }
         if (message.type === "incompatible-generation") {
@@ -206,6 +231,10 @@ export class TabBridgeClient {
             this.#emitCommand({ type: "rename", name: message.body["name"], nameSource: source === "auto" || source === "default" ? source : "user" });
             return;
         }
+        if (message.type === "bridge.route" && message.body["route"] === "settings") {
+            this.#emitCommand({ type: "route", route: "settings" });
+            return;
+        }
         if (message.type === "bridge.stop" && typeof message.body["deadlineMs"] === "number") {
             this.#emitCommand({ type: "stop", deadlineMs: message.body["deadlineMs"] });
             return;

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

@@ -6,7 +6,6 @@ export interface DoctorOptions {
     readonly hostStatus: MaintenanceReport;
     readonly releaseRoots: readonly string[];
     readonly settings: {
-        readonly tabsMax: number;
         readonly tabsAutoName: boolean;
     };
     readonly home?: string;

package/dist/foundation/resident-tabs/doctor.js

@@ -33,7 +33,7 @@ export async function writeDoctorBundle(options) {
             node: process.version,
             detachmentMode: options.hostStatus.result?.detachmentMode ?? null,
         }),
-        json("settings.json", { tabsMax: options.settings.tabsMax, tabsAutoName: options.settings.tabsAutoName }),
+        json("settings.json", { tabsAutoName: options.settings.tabsAutoName }),
     ];
     const crashes = [];
     for (const name of names.filter(name => CRASH_NAME.test(name)).sort()) {
@@ -153,11 +153,11 @@ async function redactedMarker(path, redact) {
 async function artifactFacts(roots, platform, architecture, redact) {
     const facts = [];
     for (const root of roots) {
-        const executable = resolveTerminalHostPath(root, {}, platform, architecture);
-        const manifest = await readFile(resolve(dirname(executable), TERMINAL_HOST_MANIFEST_FILENAME), "utf8")
+        const addon = resolveTerminalHostPath(root, {}, platform, architecture);
+        const manifest = await readFile(resolve(dirname(addon), TERMINAL_HOST_MANIFEST_FILENAME), "utf8")
             .then(text => JSON.parse(text))
             .catch(() => null);
-        const verification = await verifyTerminalHostArtifact(executable, platform, architecture)
+        const verification = await verifyTerminalHostArtifact(addon, platform, architecture)
             .then(() => "verified")
             .catch((error) => error instanceof Error && "code" in error ? String(error.code) : "failed");
         facts.push({ releaseRoot: redact(root), verification, manifest });

package/dist/foundation/resident-tabs/ensure-terminal-host.d.ts

@@ -1,7 +1,11 @@
 export type TerminalHostFallbackReason = "unsupported platform" | "no interactive terminal" | "terminal host not installed" | "terminal host not verified" | "host probe failed" | "incompatible generation" | "registry unreadable" | "recovery blocked" | "launch not verified" | "host startup timed out";
+export interface TerminalHostCommand {
+    readonly executable: string;
+    readonly entry: string;
+}
 export type EnsureTerminalHostResult = {
     readonly status: "ready";
-    readonly executable: string;
+    readonly executable: TerminalHostCommand;
     readonly endpoint: string;
 } | {
     readonly status: "fallback";
@@ -24,8 +28,9 @@ export interface EnsureTerminalHostOptions {
     readonly maxConcurrentStarts?: number;
     readonly unresponsiveRestartSeconds?: number;
     readonly run?: (executable: string, arguments_: readonly string[], environment: NodeJS.ProcessEnv, timeoutMs: number) => Promise<HostCommandResult>;
-    readonly verify?: (executable: string, platform: NodeJS.Platform, architecture: string) => Promise<unknown>;
+    readonly verify?: (addon: string, platform: NodeJS.Platform, architecture: string) => Promise<unknown>;
 }
 export declare function resolveTerminalHostPath(releaseRoot: string, environment?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, architecture?: string): string;
+export declare function resolveTerminalHostEntryPath(releaseRoot: string): string;
 export declare function ensureTerminalHost(options: EnsureTerminalHostOptions): Promise<EnsureTerminalHostResult>;
 export {};

package/dist/foundation/resident-tabs/ensure-terminal-host.js

@@ -8,8 +8,10 @@ export function resolveTerminalHostPath(releaseRoot, environment = process.env,
     const override = developmentOverride(environment);
     if (override)
         return resolve(override);
-    const executable = platform === "win32" ? `${PRODUCT_IDENTITY.artifacts.nativeExecutable}.exe` : PRODUCT_IDENTITY.artifacts.nativeExecutable;
-    return resolve(releaseRoot, "dist", "native", `${platform}-${architecture}`, executable);
+    return resolve(releaseRoot, "dist", "native", `${platform}-${architecture}`, `${PRODUCT_IDENTITY.artifacts.terminalHostAddon}.node`);
+}
+export function resolveTerminalHostEntryPath(releaseRoot) {
+    return resolve(releaseRoot, "dist", "foundation", "resident-tabs", `${PRODUCT_IDENTITY.artifacts.terminalHostEntry}.js`);
 }
 /** The terminal-host override is a development aid; installed releases always run their own verified artifact. */
 function developmentOverride(environment) {
@@ -22,10 +24,11 @@ export async function ensureTerminalHost(options) {
     const architecture = options.architecture ?? process.arch;
     if (!supported(platform, architecture))
         return { status: "fallback", reason: "unsupported platform" };
-    const executable = resolveTerminalHostPath(options.releaseRoot, options.environment, platform, architecture);
+    const addon = resolveTerminalHostPath(options.releaseRoot, options.environment, platform, architecture);
+    const command = { executable: process.execPath, entry: resolveTerminalHostEntryPath(options.releaseRoot) };
     if (developmentOverride(options.environment)) {
         try {
-            await access(executable, constants.R_OK | (platform === "win32" ? 0 : constants.X_OK));
+            await Promise.all([access(addon, constants.R_OK), access(command.entry, constants.R_OK)]);
         }
         catch {
             return { status: "fallback", reason: "terminal host not installed" };
@@ -33,7 +36,7 @@ export async function ensureTerminalHost(options) {
     }
     else {
         try {
-            await (options.verify ?? verifyTerminalHostArtifact)(executable, platform, architecture);
+            await (options.verify ?? verifyTerminalHostArtifact)(addon, platform, architecture);
         }
         catch (error) {
             return { status: "fallback", reason: verificationReason(error) };
@@ -43,12 +46,13 @@ export async function ensureTerminalHost(options) {
     const timeoutMs = options.timeoutMs ?? 8_000;
     const common = ["--profile", options.profileRoot, "--data-dir", options.dataDir, "--runtime-dir", options.runtimeDir];
     const environment = { ...options.environment };
+    const invoke = async (arguments_, commandTimeoutMs) => await run(command.executable, [command.entry, ...arguments_], environment, commandTimeoutMs);
     try {
-        const probe = await run(executable, ["probe", ...common], environment, Math.min(4_000, timeoutMs));
+        const probe = await invoke(["probe", ...common], Math.min(4_000, timeoutMs));
         const existing = parseResult(probe.stdout);
         if (probe.code === 0) {
             if (existing?.generation === 1 && typeof existing.endpoint === "string") {
-                return { status: "ready", executable, endpoint: existing.endpoint };
+                return { status: "ready", executable: command, endpoint: existing.endpoint };
             }
             return {
                 status: "fallback",
@@ -61,11 +65,11 @@ export async function ensureTerminalHost(options) {
             return { status: "fallback", reason: classifiedReason(existing?.reason, "host probe failed") };
         const maximum = Math.max(1, Math.min(8, Math.trunc(options.maxConcurrentStarts ?? 2)));
         const unresponsiveRestartSeconds = Math.max(30, Math.min(600, Math.trunc(options.unresponsiveRestartSeconds ?? 120)));
-        const start = await run(executable, [
+        const start = await invoke([
             "server", "--detach", ...common,
             "--max-concurrent-starts", String(maximum),
             "--unresponsive-restart-seconds", String(unresponsiveRestartSeconds),
-        ], environment, timeoutMs);
+        ], timeoutMs);
         const started = parseResult(start.stdout);
         if (start.code !== 0)
             return { status: "fallback", reason: classifiedReason(started?.reason, "launch not verified") };
@@ -73,11 +77,11 @@ export async function ensureTerminalHost(options) {
             return { status: "fallback", reason: "launch not verified" };
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
-            const result = await run(executable, ["probe", ...common], environment, Math.min(1_000, Math.max(1, deadline - Date.now())));
+            const result = await invoke(["probe", ...common], Math.min(1_000, Math.max(1, deadline - Date.now())));
             const ready = parseResult(result.stdout);
             if (result.code === 0) {
                 if (ready?.generation === 1 && typeof ready.endpoint === "string") {
-                    return { status: "ready", executable, endpoint: ready.endpoint };
+                    return { status: "ready", executable: command, endpoint: ready.endpoint };
                 }
                 return {
                     status: "fallback",

package/dist/foundation/resident-tabs/host-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/foundation/resident-tabs/host-entry.js

@@ -0,0 +1,17 @@
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+const filename = fileURLToPath(import.meta.url);
+const target = `${process.platform}-${process.arch}`;
+const development = process.env[PRODUCT_IDENTITY.environment.developmentInstanceId]?.trim();
+const override = development ? process.env[PRODUCT_IDENTITY.environment.terminalHostPath]?.trim() : undefined;
+const addonPath = resolve(override || resolve(dirname(filename), "../../native", target, `${PRODUCT_IDENTITY.artifacts.terminalHostAddon}.node`));
+const addon = createRequire(import.meta.url)(addonPath);
+if (typeof addon.runRole !== "function")
+    throw new Error("terminal host addon exports are incompatible");
+// Invariant: runRole blocks Node's main thread, so this entry must not register JavaScript signal
+// listeners whose callbacks cannot run until the native role has already returned. Default process
+// signal handling keeps attach clients and identity-verified resident roles externally stoppable.
+process.env[PRODUCT_IDENTITY.environment.terminalHostPath] = addonPath;
+process.exitCode = addon.runRole(process.argv.slice(2), { executable: process.execPath, entry: filename, artifact: addonPath });

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

@@ -1,5 +1,5 @@
-export { ensureTerminalHost, resolveTerminalHostPath } from "./ensure-terminal-host.js";
-export type { EnsureTerminalHostOptions, EnsureTerminalHostResult, TerminalHostFallbackReason } from "./ensure-terminal-host.js";
+export { ensureTerminalHost, resolveTerminalHostEntryPath, resolveTerminalHostPath } from "./ensure-terminal-host.js";
+export type { EnsureTerminalHostOptions, EnsureTerminalHostResult, TerminalHostCommand, TerminalHostFallbackReason } from "./ensure-terminal-host.js";
 export { readResidentTabLaunchSettings } from "./settings.js";
 export type { ResidentTabLaunchSettings } from "./settings.js";
 export { selectResidentHost } from "./routing.js";

package/dist/foundation/resident-tabs/index.js

@@ -1,4 +1,4 @@
-export { ensureTerminalHost, resolveTerminalHostPath } from "./ensure-terminal-host.js";
+export { ensureTerminalHost, resolveTerminalHostEntryPath, resolveTerminalHostPath } from "./ensure-terminal-host.js";
 export { readResidentTabLaunchSettings } from "./settings.js";
 export { selectResidentHost } from "./routing.js";
 export { readResidentReleaseHolds } from "./release-holds.js";

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

@@ -1,3 +1,4 @@
+import { type TerminalHostCommand } from "./ensure-terminal-host.js";
 export type MaintenanceAction = "list" | "stop" | "stop-all" | "host-status" | "host-stop";
 export type MaintenanceHostState = "none" | "running" | "stopped" | "unresponsive" | "incompatible" | "refused" | "unverifiable" | "unavailable";
 /** The versioned `a1 tabs` report: `a1-tabs-maintenance-v1`, as printed by the terminal host. */
@@ -26,16 +27,16 @@ export interface MaintenanceOptions {
     readonly platform?: NodeJS.Platform;
     readonly architecture?: string;
     readonly timeoutMs?: number;
-    readonly verify?: (executable: string, platform: NodeJS.Platform, architecture: string) => Promise<unknown>;
-    readonly run?: (executable: string, arguments_: readonly string[], timeoutMs: number) => Promise<{
+    readonly verify?: (addon: string, platform: NodeJS.Platform, architecture: string) => Promise<unknown>;
+    readonly run?: (command: TerminalHostCommand, arguments_: readonly string[], timeoutMs: number) => Promise<{
         readonly code: number;
         readonly stdout: string;
     }>;
 }
 /**
  * Runs one maintenance form through a verified terminal host. When the running host speaks
- * another protocol generation, it retries once with the binary from the release that host
- * recorded, after verifying that release's manifest; it never runs an unverified binary.
+ * another protocol generation, it retries once with the addon from the release that host
+ * recorded, after verifying that release's manifest; it never loads an unverified addon.
  */
 export declare function runTerminalHostMaintenance(options: MaintenanceOptions): Promise<MaintenanceReport>;
 /** The largest maintenance report accepted from the terminal host. */

package/dist/foundation/resident-tabs/maintenance.js

@@ -2,37 +2,38 @@ import { constants } from "node:fs";
 import { access } from "node:fs/promises";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { runBoundedHostCommand } from "./bounded-host-command.js";
-import { resolveTerminalHostPath } from "./ensure-terminal-host.js";
+import { resolveTerminalHostEntryPath, resolveTerminalHostPath } from "./ensure-terminal-host.js";
 import { verifyTerminalHostArtifact } from "./terminal-host-artifact.js";
 const INCOMPATIBLE_EXIT = 4;
 /**
  * Runs one maintenance form through a verified terminal host. When the running host speaks
- * another protocol generation, it retries once with the binary from the release that host
- * recorded, after verifying that release's manifest; it never runs an unverified binary.
+ * another protocol generation, it retries once with the addon from the release that host
+ * recorded, after verifying that release's manifest; it never loads an unverified addon.
  */
 export async function runTerminalHostMaintenance(options) {
     const platform = options.platform ?? process.platform;
     const architecture = options.architecture ?? process.arch;
-    const executable = await firstVerifiedHost(options, options.releaseRoots, platform, architecture);
-    if (executable === undefined)
+    const command = await firstVerifiedHost(options, options.releaseRoots, platform, architecture);
+    if (command === undefined)
         return unavailable(options.action, "no verified terminal host is installed");
-    const report = await invoke(options, executable);
+    const report = await invoke(options, command);
     if (report.exitCode !== INCOMPATIBLE_EXIT || typeof report.releaseRoot !== "string")
         return report;
     const cohort = await firstVerifiedHost({ ...options, environment: {} }, [report.releaseRoot], platform, architecture);
-    if (cohort === undefined || cohort === executable) {
+    if (cohort === undefined || cohort.entry === command.entry) {
         return { ...report, message: "the running tabs use another version whose terminal host cannot be verified" };
     }
-    return await invoke(options, cohort);
+    return await invoke({ ...options, environment: installedEnvironment(options.environment) }, cohort);
 }
 function arguments_(options) {
     const command = options.action === "stop" ? ["stop", options.tabId ?? ""] : [options.action];
     return ["tabs", ...command, "--profile", options.profileRoot, "--data-dir", options.dataDir, "--runtime-dir", options.runtimeDir];
 }
-async function invoke(options, executable) {
+async function invoke(options, command) {
     const timeoutMs = options.timeoutMs ?? 120_000;
     try {
-        const result = await (options.run ?? runHost)(executable, arguments_(options), timeoutMs);
+        const run = options.run ?? ((host, argumentsValue, limit) => runHost(host, argumentsValue, limit, options.environment));
+        const result = await run(command, arguments_(options), timeoutMs);
         const line = result.stdout.trim().split(/\r?\n/u).at(-1) ?? "";
         const parsed = JSON.parse(line);
         if (parsed.schema !== "a1-tabs-maintenance-v1" || typeof parsed.host !== "string")
@@ -48,19 +49,22 @@ async function firstVerifiedHost(options, roots, platform, architecture) {
         ? options.environment[PRODUCT_IDENTITY.environment.terminalHostPath]?.trim()
         : undefined;
     if (override) {
+        const entry = roots[0] === undefined ? undefined : resolveTerminalHostEntryPath(roots[0]);
+        if (entry === undefined)
+            return undefined;
         try {
-            await access(override, constants.R_OK | (platform === "win32" ? 0 : constants.X_OK));
-            return override;
+            await Promise.all([access(override, constants.R_OK), access(entry, constants.R_OK)]);
+            return { executable: process.execPath, entry };
         }
         catch {
             return undefined;
         }
     }
     for (const root of roots) {
-        const candidate = resolveTerminalHostPath(root, {}, platform, architecture);
+        const addon = resolveTerminalHostPath(root, {}, platform, architecture);
         try {
-            await (options.verify ?? verifyTerminalHostArtifact)(candidate, platform, architecture);
-            return candidate;
+            await (options.verify ?? verifyTerminalHostArtifact)(addon, platform, architecture);
+            return { executable: process.execPath, entry: resolveTerminalHostEntryPath(root) };
         }
         catch {
             // Rationale: an older retained release may predate the packaged host; try the next one.
@@ -68,11 +72,22 @@ async function firstVerifiedHost(options, roots, platform, architecture) {
     }
     return undefined;
 }
+function installedEnvironment(environment) {
+    const sanitized = { ...environment };
+    delete sanitized[PRODUCT_IDENTITY.environment.developmentInstanceId];
+    delete sanitized[PRODUCT_IDENTITY.environment.terminalHostPath];
+    return sanitized;
+}
 function unavailable(action, message) {
     return { schema: "a1-tabs-maintenance-v1", command: action, host: "unavailable", message, exitCode: 3 };
 }
 /** The largest maintenance report accepted from the terminal host. */
 export const MAX_MAINTENANCE_REPORT_BYTES = 4 * 1024 * 1024;
-async function runHost(executable, arguments_, timeoutMs) {
-    return await runBoundedHostCommand(executable, arguments_, { maxStdoutBytes: MAX_MAINTENANCE_REPORT_BYTES, timeoutMs, label: "terminal host maintenance" });
+async function runHost(command, arguments_, timeoutMs, environment) {
+    return await runBoundedHostCommand(command, arguments_, {
+        environment,
+        maxStdoutBytes: MAX_MAINTENANCE_REPORT_BYTES,
+        timeoutMs,
+        label: "terminal host maintenance",
+    });
 }

package/dist/foundation/resident-tabs/prompt-journal.d.ts

@@ -8,7 +8,6 @@ export interface SubmittedPromptRecord {
     readonly fileExisted: boolean;
     readonly kind: "prompt" | "steer" | "follow-up";
     readonly text: string;
-    readonly images?: readonly unknown[];
     readonly at: string;
 }
 export interface CorrelatedPromptRecord {
@@ -33,7 +32,6 @@ export interface PromptSubmission {
     readonly fileExisted: boolean;
     readonly kind: SubmittedPromptRecord["kind"];
     readonly text: string;
-    readonly images?: readonly unknown[];
 }
 export interface SessionJournalEntry {
     readonly entryId: string;

package/dist/foundation/resident-tabs/prompt-journal.js

@@ -30,7 +30,6 @@ export class PromptJournal {
             type: "submitted",
             id: randomUUID(),
             ...submission,
-            ...(submission.images === undefined ? {} : { images: submission.images }),
             at: new Date().toISOString(),
         };
         await this.#append(record, "journal-before-append", "journal-after-append", "journal-after-sync");

package/dist/foundation/resident-tabs/release-holds.d.ts

@@ -1,3 +1,4 @@
+import { type TerminalHostCommand } from "./ensure-terminal-host.js";
 export interface ResidentReleaseHoldReport {
     /** False when any resident record or identity could not be verified; callers then keep every release. */
     readonly complete: boolean;
@@ -11,8 +12,8 @@ export interface ResidentReleaseHoldOptions {
     readonly platform?: NodeJS.Platform;
     readonly architecture?: string;
     readonly timeoutMs?: number;
-    readonly verify?: (executable: string, platform: NodeJS.Platform, architecture: string) => Promise<unknown>;
-    readonly run?: (executable: string, arguments_: readonly string[], timeoutMs: number) => Promise<{
+    readonly verify?: (addon: string, platform: NodeJS.Platform, architecture: string) => Promise<unknown>;
+    readonly run?: (command: TerminalHostCommand, arguments_: readonly string[], timeoutMs: number) => Promise<{
         readonly code: number;
         readonly stdout: string;
     }>;

package/dist/foundation/resident-tabs/release-holds.js

@@ -1,7 +1,8 @@
 import { readdir, stat } from "node:fs/promises";
 import { resolve } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { runBoundedHostCommand } from "./bounded-host-command.js";
-import { resolveTerminalHostPath } from "./ensure-terminal-host.js";
+import { resolveTerminalHostEntryPath, resolveTerminalHostPath } from "./ensure-terminal-host.js";
 import { verifyTerminalHostArtifact } from "./terminal-host-artifact.js";
 const COMPLETE_EMPTY = Object.freeze({ complete: true, releaseRoots: Object.freeze([]), uncertain: Object.freeze([]) });
 /**
@@ -15,22 +16,22 @@ export async function readResidentReleaseHolds(options) {
     const platform = options.platform ?? process.platform;
     const architecture = options.architecture ?? process.arch;
     const verify = options.verify ?? verifyTerminalHostArtifact;
-    let executable;
+    let command;
     for (const root of options.releaseRoots) {
         const candidate = resolveTerminalHostPath(root, {}, platform, architecture);
         try {
             await verify(candidate, platform, architecture);
-            executable = candidate;
+            command = { executable: process.execPath, entry: resolveTerminalHostEntryPath(root) };
             break;
         }
         catch {
             // Rationale: an older release may predate the packaged host; another retained release may still carry it.
         }
     }
-    if (!executable)
+    if (!command)
         return incomplete("no verified terminal host is installed to inspect resident records");
     try {
-        const result = await (options.run ?? runHost)(executable, ["release-holds", "--data-dir", options.dataDir], options.timeoutMs ?? 5_000);
+        const result = await (options.run ?? runHost)(command, ["release-holds", "--data-dir", options.dataDir], options.timeoutMs ?? 5_000);
         const report = JSON.parse(result.stdout.trim().split(/\r?\n/u).at(-1) ?? "");
         if (result.code !== 0 || report.schema !== "a1-resident-release-holds-v1" || typeof report.complete !== "boolean"
             || !isStringArray(report.releaseRoots) || !isStringArray(report.uncertain)) {
@@ -72,6 +73,14 @@ function isStringArray(value) {
 }
 /** The largest release-hold report accepted from the terminal host. */
 export const MAX_RELEASE_HOLD_REPORT_BYTES = 1024 * 1024;
-async function runHost(executable, arguments_, timeoutMs) {
-    return await runBoundedHostCommand(executable, arguments_, { maxStdoutBytes: MAX_RELEASE_HOLD_REPORT_BYTES, timeoutMs, label: "terminal host release-hold inspection" });
+async function runHost(command, arguments_, timeoutMs) {
+    const environment = { ...process.env };
+    delete environment[PRODUCT_IDENTITY.environment.developmentInstanceId];
+    delete environment[PRODUCT_IDENTITY.environment.terminalHostPath];
+    return await runBoundedHostCommand(command, arguments_, {
+        environment,
+        maxStdoutBytes: MAX_RELEASE_HOLD_REPORT_BYTES,
+        timeoutMs,
+        label: "terminal host release-hold inspection",
+    });
 }

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

@@ -3,7 +3,6 @@ export declare const RESIDENT_TABS_MAX_CONCURRENT_STARTS_CAP = 8;
 export declare const RESIDENT_TABS_PREWARM_COUNT = 1;
 export declare const RESIDENT_TABS_PREWARM_CAP = 1;
 export interface ResidentTabLaunchSettings {
-    readonly tabsMax: number;
     readonly tabsAutoName: boolean;
     readonly maxConcurrentStarts: number;
     readonly prewarmCount: number;

package/dist/foundation/resident-tabs/settings.js

@@ -7,7 +7,6 @@ export const RESIDENT_TABS_MAX_CONCURRENT_STARTS_CAP = 8;
 export const RESIDENT_TABS_PREWARM_COUNT = 1;
 export const RESIDENT_TABS_PREWARM_CAP = 1;
 const DEFAULTS = Object.freeze({
-    tabsMax: 10,
     tabsAutoName: true,
     maxConcurrentStarts: RESIDENT_TABS_MAX_CONCURRENT_STARTS,
     prewarmCount: RESIDENT_TABS_PREWARM_COUNT,
@@ -46,17 +45,12 @@ export async function readResidentTabLaunchSettings(profileDir, namespace = "a1"
 }
 function resolveLaunchValues(document, migrations) {
     const resolution = resolveOwnedUiSettings({
-        declarations: [
-            OWNED_SETTING_DECLARATIONS.tabsMax,
-            OWNED_SETTING_DECLARATIONS.tabsAutoName,
-        ],
+        declarations: [OWNED_SETTING_DECLARATIONS.tabsAutoName],
         migrations,
         document,
         currentVersion: OWNED_UI_SETTINGS_VERSION,
     });
-    const tabsMax = document.values?.["tabsMax"] ?? settingValue(resolution, "tabsMax");
     return {
-        tabsMax: typeof tabsMax === "number" && Number.isFinite(tabsMax) ? Math.max(1, Math.min(50, Math.trunc(tabsMax))) : DEFAULTS.tabsMax,
         tabsAutoName: settingValue(resolution, "tabsAutoName") === true,
         maxConcurrentStarts: RESIDENT_TABS_MAX_CONCURRENT_STARTS,
         prewarmCount: RESIDENT_TABS_PREWARM_COUNT,

package/dist/foundation/resident-tabs/terminal-host-artifact.d.ts

@@ -1,18 +1,14 @@
 export declare const TERMINAL_HOST_MANIFEST_FILENAME = "terminal-host.manifest.json";
-export declare const TERMINAL_HOST_GENERATION = 1;
-export type TerminalHostArtifactCode = "TERMINAL_HOST_ARTIFACT_MISSING" | "TERMINAL_HOST_ARTIFACT_INCOMPATIBLE" | "TERMINAL_HOST_ARTIFACT_UNSUPPORTED" | "TERMINAL_HOST_ARTIFACT_TAMPERED";
-export interface VerifiedTerminalHostArtifact {
-    readonly executable: string;
-    readonly sessionLock: string;
-    readonly generation: number;
-}
+export type TerminalHostArtifactErrorCode = "TERMINAL_HOST_ARTIFACT_MISSING" | "TERMINAL_HOST_ARTIFACT_TAMPERED" | "TERMINAL_HOST_ARTIFACT_INCOMPATIBLE" | "TERMINAL_HOST_ARTIFACT_UNSUPPORTED";
 export declare class TerminalHostArtifactError extends Error {
-    readonly code: TerminalHostArtifactCode;
-    constructor(message: string, code: TerminalHostArtifactCode);
+    readonly code: TerminalHostArtifactErrorCode;
+    readonly manifestPath: string;
+    constructor(code: TerminalHostArtifactErrorCode, manifestPath: string, message: string);
+}
+export interface VerifiedTerminalHostArtifact {
+    readonly addon: string;
+    readonly entry: string;
+    readonly generation: 1;
 }
-/**
- * Verifies a release's terminal host and its session-writer lock against their manifest before
- * anything executes or loads them: schema, generation, platform, architecture, file names, sizes,
- * and SHA-256 digests.
- */
-export declare function verifyTerminalHostArtifact(executable: string, platform?: NodeJS.Platform, architecture?: string, generation?: number): Promise<VerifiedTerminalHostArtifact>;
+/** Verifies every runtime file certified by the terminal-host v2 manifest before Node loads it. */
+export declare function verifyTerminalHostArtifact(addonPath: string, platform?: NodeJS.Platform, architecture?: string): Promise<VerifiedTerminalHostArtifact>;