@staix/agent-hub 0.12.37 → 0.12.39

package/src/adapters/acp.ts

@@ -79,6 +79,8 @@ export interface AcpOptions {
   /** Optional launch environment; recovery authority is always removed before spawn. */
   env?: NodeJS.ProcessEnv;
   watchdogMs?: number;
+  /** #542 D4: how long an open tool call keeps a silent turn alive; defaults to 30 minutes, never below the watchdog. */
+  toolCeilingMs?: number;
   /** Bound for a journal-less watchdog cancellation to report its prompt; defaults to the 30 s ACP handshake cap. */
   cancelWaitMs?: number;
   /** ACP stdio MCP servers for the session (the hub's task tools). */
@@ -108,6 +110,7 @@ export interface AcpOptions {
 const HANDSHAKE_MS = 30_000;
 /** Tool calls whose arguments are remembered until their permission request arrives. */
 const TOOL_INPUT_CAP = 64;
+const TOOL_CEILING_MS = 30 * 60_000;
 
 /**
  * The canonical tool binding (#138): an announced `<tool> (<server> MCP Server)` title resolves to
@@ -148,6 +151,8 @@ export class AcpPeer extends BasePeer {
   private readonly toolInputs = new Map<string, unknown>();
   private readonly toolText = new Map<string, string>(); // streamed argument text, per call, until it finishes
   private readonly toolTitles = new Map<string, string>(); // the title a call was announced with, per call id (#138)
+  private readonly openTools = new Map<string, string>(); // this turn's started, unfinished tool calls (#542 D4)
+  private lastSignAt = 0;
   private primed = false;
   private turn = 0; // generation: a prompt cancelled by the watchdog must not touch the turn that followed it
   private stopping = false;
@@ -339,6 +344,7 @@ export class AcpPeer extends BasePeer {
     this.deliveryAccepted = false;
     this.promptActivity = false;
     this.chunks = [];
+    this.openTools.clear();
     this.activityOpen = true;
     this.activityPrivate = envs.some(env => env.private === true);
     try { this.activityPrivate ||= this.opts.isPrivateTurn?.() === true; } catch { this.activityPrivate = true; }
@@ -415,6 +421,16 @@ export class AcpPeer extends BasePeer {
   protected override onWatchdog(): void {
     if (this.state !== "busy") return;
     if (this.cancelWait) { this.clearWatchdog(); return; }
+    // #542 D4: a tool call that started and has not finished is running, not silent, up to its own ceiling.
+    if (this.openTools.size) {
+      const ceiling = Math.max(this.watchdogMs, this.opts.toolCeilingMs ?? TOOL_CEILING_MS);
+      const remaining = ceiling - (Date.now() - this.lastSignAt);
+      if (remaining > 0) { this.touch(Math.min(this.watchdogMs, remaining)); return; }
+      // Privacy latches for the turn and fails closed, as in emitActivity; the title is agent-written, so one quoted line.
+      try { this.activityPrivate ||= this.opts.isPrivateTurn?.() === true; } catch { this.activityPrivate = true; }
+      const tools = this.activityPrivate ? "a tool call" : [...new Set(this.openTools.values())].map(title => JSON.stringify(activityText(title).replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, " ").slice(0, 80))).join(", ");
+      this.opts.log?.(`[${this.id}] open tool call (${tools}) silent past the ${Math.round(ceiling / 60_000)} min tool ceiling; cancelling the turn`);
+    }
     this.endActivity("watchdog cancelled", true);
     const cancelledTurn = this.turn;
     this.cancelPermissions();
@@ -482,7 +498,7 @@ export class AcpPeer extends BasePeer {
     } catch {
       return; // not protocol output
     }
-    if (this.state === "busy" && !this.cancelWait) this.touch();
+    if (this.state === "busy" && !this.cancelWait) { this.lastSignAt = Date.now(); this.touch(); }
 
     if (msg.method === "session/update") {
       if (msg.params?.sessionId && msg.params.sessionId !== this.sessionId) return;
@@ -517,7 +533,9 @@ export class AcpPeer extends BasePeer {
         if (u.sessionUpdate === "tool_call" && typeof u.title === "string") this.toolTitles.set(u.toolCallId, u.title);
         const text = Array.isArray(u.content) ? u.content.map((c: any) => (c?.type === "content" && c.content?.type === "text" ? String(c.content.text) : "")).join("") : "";
         if (text) this.toolText.set(u.toolCallId, text);
-        if (u.status === "completed" || u.status === "failed") (this.toolInputs.delete(u.toolCallId), this.toolText.delete(u.toolCallId), this.toolTitles.delete(u.toolCallId));
+        if (u.status === "completed" || u.status === "failed") (this.toolInputs.delete(u.toolCallId), this.toolText.delete(u.toolCallId), this.toolTitles.delete(u.toolCallId), this.openTools.delete(u.toolCallId));
+        else if (u.sessionUpdate === "tool_call" || this.openTools.has(u.toolCallId)) this.openTools.set(u.toolCallId, this.toolTitles.get(u.toolCallId) ?? "tool");
+        while (this.openTools.size > TOOL_INPUT_CAP) this.openTools.delete(this.openTools.keys().next().value as string);
         for (const map of [this.toolInputs, this.toolText, this.toolTitles]) while (map.size > TOOL_INPUT_CAP) map.delete(map.keys().next().value as string);
       }
       else if (u?.sessionUpdate === "usage_update") this.observeUsage(u, "usage_update");

package/src/adapters/agy/definition.ts

@@ -0,0 +1,61 @@
+import type { AdapterDefinition, LaunchContext, LaunchPlan } from "../registry-types.ts";
+import { AGY_REVIEWER_VARIANT } from "../definitions/reviewer-variants.ts";
+import { AGY_FACTS_HOOK } from "./hooks.ts";
+
+const DISPLAY = { palette: { fg: "#6558a6", bg: "#f1effa" } };
+const shellQuote = (value: string): string => `'${value.replace(/'/g, `'\\''`)}'`;
+
+function agyLaunch(ctx: LaunchContext): LaunchPlan {
+  const argv = ["agy", ...ctx.userArgs], command = argv.map(shellQuote).join(" ");
+  const metadata = { packageEntrypoint: ctx.entrypoint, command, argv, env: {}, kind: "agy", peer: ctx.instance } as LaunchPlan["metadata"] & { kind: "agy"; peer: string };
+  return { cmd: "agy", args: ctx.userArgs, metadata };
+}
+
+/** Antigravity is an unmanaged, pull-only peer attached from its native project plugin. */
+export const AGY_DEFINITION: AdapterDefinition = {
+  api: 1,
+  kind: "agy",
+  displayName: "Antigravity",
+  family: "agy",
+  transport: "ws-pull",
+  roles: ["implementer", "verifier"],
+  optional: true,
+  defaultOnRoster: false,
+  trust: { onPrem: false, hubSandboxed: false },
+  start: {
+    forms: ["tui"],
+    defaultForm: "tui",
+    ownsTerminal: form => form === "tui",
+    launch: agyLaunch,
+    conductorStartable: false,
+    hubSwitches: [],
+    ownedFlags: ["--new", "--continue", "--conversation", "--resume"],
+    conductorStartArgs: args => args.length ? new Error("conductor starts accept no launch overrides; use ahub agy") : {},
+  },
+  identity: { mcp: "channel-plugin" },
+  attach: {
+    pullOnlyForms: ["tui"],
+    recoveryLaunch: instance => ({ kind: "agy", peer: instance }),
+    pullOnlyNotice: "pull-only: messages wait for hub_inbox; permission modes and session recovery are not managed",
+  },
+  permission: {
+    modes: {},
+    unmanaged: "Antigravity selects its own permission mode in its TUI; no hub permission mode",
+    unmanagedForms: ["tui"],
+    unmanagedNote: "Antigravity approves tools in its own TUI; no hub permission mode",
+    unmanagedStatusNote: "unmanaged native permission policy",
+  },
+  session: {
+    idField: "sessionId",
+    currentId: () => undefined,
+    freshOnRestore: true,
+    recoveryRefusal: () => "Antigravity session continuity and resume are unavailable until native behavior is verified",
+  },
+  turnEnd: "native-hook",
+  cli: { command: "agy", authority: "person", startWords: () => ["agy"] },
+  display: DISPLAY,
+  routing: { allowedRoles: ["implementer", "verifier"] },
+  reviewer: { defaultPool: false, declaration: "automatic", unavailable: "agy is an implementer peer (#485)" },
+  reviewerVariant: AGY_REVIEWER_VARIANT,
+  hooks: { factsHook: AGY_FACTS_HOOK },
+};

package/src/adapters/agy/entry.ts

@@ -0,0 +1,76 @@
+import { publicArg } from "../definitions/native-cli-preview-common.ts";
+import { spawn, spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+import type { NativeCliEntryContext } from "../definitions/native-cli-entry-types.ts";
+import { bundleInStatus, rosterInStatus } from "../../hub/status-roster.ts";
+import { ensureAgyMcp, cleanupAgyMcp, type AgyMcpOptions } from "../../cli/agy-mcp.ts";
+import { peerChildEnv } from "../../hub/child-process.ts";
+
+export function agyTuiSpawnOptions(cwd: string, env: NodeJS.ProcessEnv) {
+  return { cwd, env, stdio: "inherit" as const };
+}
+
+function runAgyTui(argv: string[], cwd: string, env: NodeJS.ProcessEnv): Promise<number> {
+  const child = spawn("agy", argv, agyTuiSpawnOptions(cwd, env));
+  return new Promise((resolveExit, reject) => {
+    const forward = (signal: NodeJS.Signals) => {
+      if (child.exitCode !== null || child.signalCode !== null) return;
+      try { child.kill(signal); } catch { /* The native child may exit as the signal arrives. */ }
+    };
+    const onInterrupt = () => forward("SIGINT");
+    const onTerminate = () => forward("SIGTERM");
+    const onHangup = () => forward("SIGHUP");
+    const cleanup = () => {
+      process.off("SIGINT", onInterrupt);
+      process.off("SIGTERM", onTerminate);
+      process.off("SIGHUP", onHangup);
+    };
+    process.on("SIGINT", onInterrupt);
+    process.on("SIGTERM", onTerminate);
+    process.on("SIGHUP", onHangup);
+    child.once("error", error => { cleanup(); reject(error); });
+    child.once("close", code => { cleanup(); resolveExit(code ?? 1); });
+  });
+}
+
+export async function runAgyEntry(ctx: NativeCliEntryContext): Promise<void> {
+  const { args, cwd, stateDir, cliDir, connect, fail } = ctx;
+  if (ctx.instance) fail("extra Antigravity TUI instances are not verified in P1");
+  const preview = args.includes("--print-command") || args.includes("--dry-run");
+  const unattended = ctx.unattendedEnv || args.includes("--unattended");
+  const nativeArgs = args.filter(arg => !["--print-command", "--dry-run", "--unattended"].includes(arg));
+  // Headless, resume and native approval overrides are not silently passed through an unverified hub mapping.
+  if (nativeArgs.some(arg => ["--print", "-p", "--prompt", "--input-format", "--output-format", "--conversation", "--continue", "-c", "--new", "--mode", "--dangerously-skip-permissions"].some(flag => arg === flag || arg.startsWith(`${flag}=`)))) fail("agy P1 supports a fresh TUI only; headless, resume and permission flags need a verified mapping");
+  if (unattended) fail("agy P1 native permissions are unmanaged; unattended mode has no verified prompt mapping");
+  const argv = nativeArgs;
+  if (preview) { console.log(JSON.stringify({ command: "agy", args: argv.map(publicArg), mode: "tui", permission: "unmanaged", mcp: ".agents/plugins/agent-hub/", writes: false })); return; }
+  const version = spawnSync("agy", ["--version"], { encoding: "utf8", timeout: 5000, maxBuffer: 4096, env: peerChildEnv("agy") });
+  if (version.status !== 0 || version.stdout.trim() !== "1.4.2") fail("agy P1 requires the verified Antigravity CLI 1.4.2");
+  const hub = await connect();
+  let options: AgyMcpOptions | undefined;
+  let pluginWritten = false;
+  try {
+    if (!hub.features.includes("native_hook_launch")) fail("running hub lacks the verified native hook launcher; upgrade or restart it before launching agy");
+    const status = (await hub.request({ t: "status" })).status;
+    if (rosterInStatus(status, "agy") !== true) fail("agy is off roster; add it with ahub roster add agy");
+    const admitted = await hub.request({ t: "native_hook_launch", op: "begin", peer: "agy" });
+    if (!admitted.ok || typeof admitted.launchId !== "string" || typeof admitted.instanceId !== "string") fail(admitted.error ?? "native hook launch was not admitted");
+    options = { projectRoot: cwd, stateDir, serverJs: bundleInStatus(status) ?? resolve(cliDir, "../../plugins/agent-hub/server.js"),
+      hookScript: resolve(cliDir, "facts-hook.ts"), peer: "agy", launchId: admitted.launchId, instanceId: admitted.instanceId };
+    const written = ensureAgyMcp(options);
+    pluginWritten = written.changed;
+    if (written.tracked) console.error("The managed agy plugin is tracked; review its local machine paths before committing");
+    console.error("Antigravity: pull-only TUI; native permissions unmanaged, no hub sandbox");
+    const env: NodeJS.ProcessEnv = { ...ctx.helpers.nativeLaunchEnv("agy", ctx.helpers.childEnv()), AGENTHUB_STATE_DIR: stateDir, AGENTHUB_PROJECT_DIR: cwd };
+    delete env.AGENTHUB_CHANNEL;
+    const code = await runAgyTui(argv, cwd, env);
+    if (code !== 0) process.exitCode = code;
+  } finally {
+    if (options) {
+      // Revoke launcher authority before cleanup; stale cleanup never removes a newer managed launch.
+      await hub.request({ t: "native_hook_launch", op: "end", peer: "agy", launchId: options.launchId }).catch(() => {});
+      if (pluginWritten) try { cleanupAgyMcp(options); } catch { console.error("Managed agy plugin cleanup refused: files changed or ownership could not be verified"); }
+    }
+    hub.close();
+  }
+}

package/src/adapters/agy/hooks.ts

@@ -0,0 +1,81 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, relative } from "node:path";
+import { createHash } from "node:crypto";
+import type { NativeFactsInput, NativeFactsPort, NativeFactsTranscript } from "../registry-types.ts";
+
+const EVENTS = ["SessionStart", "PreInvocation", "PostInvocation", "PreToolUse", "PostToolUse", "Stop"] as const;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const record = (value: unknown): value is Record<string, unknown> => !!value && typeof value === "object" && !Array.isArray(value);
+
+/** The pinned 1.4.2 envelope has no event name: the managed command supplies it separately. */
+export function decodeAgyHook(event: string, value: unknown): NativeFactsInput | undefined {
+  if (!(EVENTS as readonly string[]).includes(event) || !record(value) || typeof value.conversationId !== "string" || !UUID.test(value.conversationId)
+    || typeof value.transcriptPath !== "string" || !isAbsolute(value.transcriptPath) || value.transcriptPath.length > 4096
+    || !Array.isArray(value.workspacePaths) || !value.workspacePaths.length || value.workspacePaths.length > 32
+    || !value.workspacePaths.every(path => typeof path === "string" && path.length <= 4096 && isAbsolute(path))) return;
+  if (event === "Stop" && typeof value.fullyIdle !== "boolean") return;
+  const call = record(value.toolCall) ? value.toolCall : undefined;
+  if ((event === "PreToolUse" || event === "PostToolUse") && (!call || typeof call.name !== "string" || call.name.length > 128 || !record(call.args))) return;
+  const native = call?.args as Record<string, unknown> | undefined;
+  // Only the observed native read is classified. Unobserved edits never receive a scoped grant or effect attribution.
+  const observedRead = call?.name === "view_file" && typeof native?.AbsolutePath === "string";
+  const phase = ({ SessionStart: "session", PreInvocation: "start", PostInvocation: "post", PreToolUse: "pre", PostToolUse: "post", Stop: "stop" } as const)[event as typeof EVENTS[number]];
+  return { event: event as NativeFactsInput["event"], phase, sessionId: value.conversationId, transcriptPath: value.transcriptPath,
+    workspacePaths: value.workspacePaths as string[], tool: observedRead ? "Read" : typeof call?.name === "string" ? call.name : "", input: observedRead ? { file_path: native!.AbsolutePath } : native ?? {},
+    ...(Number.isSafeInteger(value.stepIdx) && (value.stepIdx as number) >= 0 ? { toolUseId: `${value.conversationId}:${value.stepIdx}` } : {}),
+    ...(Number.isSafeInteger(value.invocationNum) && (value.invocationNum as number) >= 0 ? { invocation: value.invocationNum as number } : {}),
+    ...(event === "Stop" ? { fullyIdle: value.fullyIdle as boolean, terminationReason: typeof value.terminationReason === "string" ? value.terminationReason : "" } : {}) };
+}
+
+export function encodeAgyHook(event: string, text?: string): Record<string, unknown> | undefined {
+  // `allow` does not override native approval. Until a prompt mapping is proven, leave all native permissions alone.
+  if (text && (event === "SessionStart" || event === "PreInvocation")) return { injectSteps: [{ ephemeralMessage: text }] };
+  return undefined;
+}
+
+/** Only native-generated rows under the exact session cache path count as readback/completion evidence. */
+export function readAgyTranscript(session: string, transcript: string): NativeFactsTranscript {
+  const empty: NativeFactsTranscript = { factIds: [] };
+  if (!UUID.test(session)) return empty;
+  const home = process.env.HOME ?? homedir();
+  const candidates = ["antigravity-cli", "antigravity", "antigravity-ide"].map(surface => join(home, ".gemini", surface, "brain", session, ".system_generated/logs/transcript_full.jsonl"));
+  if (!candidates.includes(transcript)) return empty;
+  let fd: number | undefined;
+  try {
+    let cursor = home;
+    for (const name of relative(home, transcript).split("/")) { cursor = join(cursor, name); if (lstatSync(cursor).isSymbolicLink()) return empty; }
+    fd = openSync(transcript, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.nlink !== 1) return empty;
+    // ponytail: completion lookback is capped at 4 MiB (as for Claude). A larger final row is unverified;
+    // upgrade to a native completion cursor if that ceiling becomes insufficient.
+    const cap = 4 * 1024 * 1024;
+    for (let window = 64 * 1024; ; window = Math.min(cap, window * 2)) {
+      const start = Math.max(0, stat.size - window), from = start > 0 ? start - 1 : 0;
+      const buffer = Buffer.alloc(stat.size - from);
+      let bytes = 0;
+      while (bytes < buffer.length) {
+        const count = readSync(fd, buffer, bytes, buffer.length - bytes, from + bytes);
+        if (!count) break;
+        bytes += count;
+      }
+      const lines = buffer.subarray(0, bytes).toString("utf8").split("\n");
+      // The preceding byte distinguishes a cut inside a row from a row beginning exactly at the window.
+      if (start) lines.shift();
+      const out: NativeFactsTranscript = { factIds: [] };
+      for (const line of lines) {
+        let row: unknown; try { row = JSON.parse(line); } catch { continue; }
+        if (!record(row) || row.status !== "DONE") continue;
+        if (row.source === "SYSTEM_SDK" && row.type === "EPHEMERAL_MESSAGE" && typeof row.content === "string") {
+          for (const match of row.content.matchAll(/agent-hub facts \[([a-zA-Z0-9-]{1,128})\]/g)) out.factIds.push(match[1]!);
+        }
+        if (row.source === "MODEL" && row.type === "PLANNER_RESPONSE" && Number.isSafeInteger(row.step_index)
+          && typeof row.content === "string" && row.content.trim().length > 0 && (!Array.isArray(row.tool_calls) || row.tool_calls.length === 0)) out.completion = { id: createHash("sha256").update(`${session}:${row.step_index}:${line}`).digest("hex"), index: row.step_index as number };
+      }
+      if (out.completion || start === 0 || window === cap) return out;
+    }
+  } catch { return empty; } finally { if (fd !== undefined) closeSync(fd); }
+}
+
+export const AGY_FACTS_HOOK: NativeFactsPort = { decode: decodeAgyHook, encode: encodeAgyHook, read: readAgyTranscript };

package/src/adapters/claude-channel.ts

@@ -368,6 +368,7 @@ async function callTool(req: { params: { name: string; arguments?: Record<string
     const res = await hub.request({ t: "send", body, to, reply_to });
     if (!res.ok) return text(`not sent: ${res.error}`);
     if (res.recorded) return text("recorded only ([FYI]): it is on the hub console and log, and no peer spent a turn on it");
+    if (res.dropped === "hop") return text(res.notice);
     const sent = `sent to: ${res.targets.join(", ") || "(no other peers attached)"}`;
     return text(typeof res.notice === "string" ? `${sent}; ${res.notice}` : sent);
   }

package/src/adapters/codex-review-isolation.ts

@@ -67,18 +67,28 @@ function configFiles(cwd: string, env: NodeJS.ProcessEnv): string[] {
 // Bounded host credential roots, not a universal private-home classifier. Never inspect their file contents.
 const HOST_CREDENTIAL_PATHS = [".config", ".ssh", ".aws", ".azure", ".kube", ".docker", ".gnupg", ".codex", ".claude", ".kimi", ".kimi-code", ".gemini", ".git-credentials", ".vault-token", "Library/Keychains", ".local/share/keyrings", ".password-store"] as const;
 const HOST_CREDENTIAL_ENV = ["XDG_CONFIG_HOME", "CODEX_HOME", "CLAUDE_CONFIG_DIR", "KIMI_CODE_HOME", "KIMI_HOME", "GEMINI_CLI_HOME", "GNUPGHOME", "AWS_SHARED_CREDENTIALS_FILE", "AWS_CONFIG_FILE", "AZURE_CONFIG_DIR", "DOCKER_CONFIG", "GOOGLE_APPLICATION_CREDENTIALS"] as const;
-function hostCredentialRoots(env: NodeJS.ProcessEnv, cwd: string): string[] {
+/** A credential root that cannot be resolved. `label` is a path class (a standard name or an env var name), never a path or contents. */
+class CredentialRootError extends Error {
+  constructor(readonly label: string, readonly kind: "dangling" | "unreadable" | "unsupported") { super("credential root refused"); }
+}
+interface CredentialRoot { path: string; label: string }
+function hostCredentialRoots(env: NodeJS.ProcessEnv, cwd: string): CredentialRoot[] {
   const home = resolve(cwd, env.HOME || homedir());
-  const homes = [...new Set([home, credentialCanonicalPath(home)])];
-  const roots: string[] = homes.flatMap(base => HOST_CREDENTIAL_PATHS.map(entry => join(base, entry)));
-  const configured = HOST_CREDENTIAL_ENV.flatMap(key => env[key] ? [env[key]!] : []);
-  if (env.KUBECONFIG) configured.push(...env.KUBECONFIG.split(delimiter).filter(Boolean));
+  const homes = [...new Set([home, canonicalLabelled(home, "HOME")])];
+  const roots: CredentialRoot[] = homes.flatMap(base => HOST_CREDENTIAL_PATHS.map(entry => ({ path: join(base, entry), label: `~/${entry}` })));
+  const configured: CredentialRoot[] = HOST_CREDENTIAL_ENV.flatMap(key => env[key] ? [{ path: env[key]!, label: `$${key}` }] : []);
+  if (env.KUBECONFIG) configured.push(...env.KUBECONFIG.split(delimiter).filter(Boolean).map(path => ({ path, label: "$KUBECONFIG" })));
   if (configured.length > 64) throw new Error("credential root bound exceeded");
-  for (const entry of configured) {
-    if (Buffer.byteLength(entry) > 4096 || /\p{Cc}/u.test(entry)) throw new Error("invalid credential root");
-    roots.push(entry.startsWith("~/") ? resolve(home, entry.slice(2)) : resolve(cwd, entry));
+  for (const { path: entry, label } of configured) {
+    if (Buffer.byteLength(entry) > 4096 || /\p{Cc}/u.test(entry)) throw new CredentialRootError(label, "unsupported");
+    roots.push({ path: entry.startsWith("~/") ? resolve(home, entry.slice(2)) : resolve(cwd, entry), label });
   }
-  return [...new Set(roots)];
+  const seen = new Set<string>();
+  return roots.filter(root => !seen.has(root.path) && seen.add(root.path));
+}
+function canonicalLabelled(lexical: string, label: string): string {
+  try { return credentialCanonicalPath(lexical); }
+  catch (error) { throw new CredentialRootError(label, (error as NodeJS.ErrnoException).code === "ENOENT" ? "dangling" : "unreadable"); }
 }
 /** Resolve absent descendants through the deepest existing ancestor; dangling links refuse admission. */
 function credentialCanonicalPath(lexical: string): string {
@@ -93,14 +103,13 @@ function credentialCanonicalPath(lexical: string): string {
   }
   return join(realPath(ancestor), relative(ancestor, lexical));
 }
-function denyCredentialRoots(filesystem: Record<string, string>, roots: readonly string[], cwd: string): void {
-  for (const lexical of roots) {
+function denyCredentialRoots(filesystem: Record<string, string>, roots: readonly CredentialRoot[], cwd: string): void {
+  for (const { path: lexical, label } of roots) {
     // Native profile keys with glob metacharacters cannot represent these literal host locations safely.
-    if (/[?*\[\]{}]/.test(lexical)) throw new Error("unverified credential root syntax");
-    const targets = new Set([lexical, credentialCanonicalPath(lexical)]);
+    if (/[?*\[\]{}]/.test(lexical)) throw new CredentialRootError(label, "unsupported");
+    const targets = new Set([lexical, canonicalLabelled(lexical, label)]);
     for (const target of targets) {
-      if (/[?*\[\]{}]/.test(target)) throw new Error("unverified credential root syntax");
-      if (inside(cwd, target)) throw new Error("credential root overlaps checkout");
+      if (/[?*\[\]{}]/.test(target) || inside(cwd, target)) throw new CredentialRootError(label, "unsupported");
       filesystem[target] = "deny"; filesystem[`${target.replace(/\/$/, "")}/**`] = "deny";
     }
   }
@@ -261,8 +270,13 @@ async function prepare(ctx: ReviewerPrepareContext): Promise<ReviewerLaunch | {
       cleanup: () => rmSync(cleanupRoot, { recursive: true, force: true }),
       isolation: { backend: "codex", version: VERSION, binary: `sha256:${binaryHash}`, profile: `sha256:${launchProfile}`, readOnly: true, strictMcp: true, ephemeral: true,
         evidence: ["model-free-mcp-inventory-disabled-ambient", "hub-tools-exact-allowlist", "plugins-and-hooks-disabled", "apps-disabled-effective-feature-readback", "web-search-disabled", "project-untrusted", "native-public-read-private-deny-write-deny", "native-glob-and-symlink-private-deny", "portable-core-name-and-state-deny", "standard-host-credential-roots-denied", "binary-config-stable", "binary-hash-once-metadata-fence", "session-ephemeral"] } };
-  } catch {
+  } catch (error) {
     if (root) { try { rmSync(root, { recursive: true, force: true }); } catch { /* unavailable remains refused */ } }
+    // Name only the path class of an unusable credential root so a stale ~/.docker link is fixable; never a path or contents.
+    if (error instanceof CredentialRootError) {
+      const why = { dangling: "a dangling link", unreadable: "an unreadable path", unsupported: "unsupported syntax or overlapping the checkout" }[error.kind];
+      return { unavailable: `Codex reviewer isolation receipt unavailable (credential root ${error.label} is ${why}; remove or repair it)` };
+    }
     return { unavailable: "Codex reviewer isolation receipt unavailable (version, MCP inventory, sandbox, configuration or process proof)" };
   }
 }

package/src/adapters/definitions/builtin-metadata.ts

@@ -22,8 +22,8 @@ type CompatibilityKind = "claude" | "codex" | "kimi" | "pi" | "local" | "jcode";
  * Preserve CLI-wrapper argv plans for definitions that still declare them and the frozen A1 compatibility export.
  * Native startup and daemon factories are supplied separately by the runtime definitions.
  */
-function compatibilityLaunch(kind: CompatibilityKind, ctx: LaunchContext): LaunchPlan {
-  const mode = kind === "kimi" || kind === "pi" ? ["--mode", ctx.form] : [];
+function compatibilityLaunch(kind: CompatibilityKind, ctx: LaunchContext, explicitMode = false): LaunchPlan {
+  const mode = explicitMode || kind === "kimi" || kind === "pi" ? ["--mode", ctx.form] : [];
   const unattended = ctx.unattended && (kind === "claude" || kind === "codex") ? ["--unattended"] : [];
   const args = [ctx.entrypoint, "--project", ctx.projectRoot, kind, ...mode, ...unattended,
     ...(ctx.model && !ctx.userArgs.includes("--model") ? ["--model", ctx.model] : []), ...ctx.userArgs];
@@ -100,7 +100,7 @@ export const NATIVE_BUILTIN_DEFINITIONS_WITHOUT_QWEN: readonly AdapterDefinition
       grants: { ask: "the session's own approval policy applies again", "ask-when-needed": "approval policy on-request on every turn", "never-ask": "approval policy never on every turn: nothing asks" } },
     session: { nativeRevert: true, idField: "threadId", currentId: sessionId("threadId"), configDirEnv: "CODEX_HOME", zeroTurnFresh: true, launchKind: "codex", launchRecord: true, ...CODEX_RECOVERY_SESSION, crashPlan: codexCrashPlan, unrecordedTerminal: "always" },
     turnEnd: "adapter", budget: { account: "codex", checkpoint: true, reader: { source: "codex rateLimits", read: codexWindows }, context: { source: "codex_token_usage", read: codexContext } },
-    cli: { command: "codex", retainedTerminalNotice: codexRetainedTerminalNotice, rosterReturnNotice: codexRosterReturnNotice, stopNotice: () => "this peer belongs to a native terminal; end it in its terminal", startWords: () => ["codex"] }, display: CODEX_DISPLAY, hooks: { recallPlatform: "codex", recallSource: "codex", recallInjected: true, pluginInventory: codexPluginInventory, classifyTool: codexToolSemantic },
+    cli: { command: "codex", launchConfigKeys: ["codex_bin"], retainedTerminalNotice: codexRetainedTerminalNotice, rosterReturnNotice: codexRosterReturnNotice, stopNotice: () => "this peer belongs to a native terminal; end it in its terminal", startWords: () => ["codex"] }, display: CODEX_DISPLAY, hooks: { recallPlatform: "codex", recallSource: "codex", recallInjected: true, pluginInventory: codexPluginInventory, classifyTool: codexToolSemantic },
   },
   {
     reviewerVariant: KIMI_REVIEWER_VARIANT,
@@ -116,7 +116,7 @@ export const NATIVE_BUILTIN_DEFINITIONS_WITHOUT_QWEN: readonly AdapterDefinition
       unmanagedForms: Object.freeze(["tui"] as const), unmanagedStatusNote: "Kimi approves tools in its own TUI; no hub permission mode", unmanagedNote: "Kimi approves tools and selects its permission mode in its own TUI; no hub permission mode" },
     session: { idField: "sessionId", currentId: sessionId("sessionId"), freshOnRestore: true, launchKind: "acp", ...KIMI_RECOVERY_SESSION, crashPlan: kimiCrashPlan },
     turnEnd: "adapter", budget: { account: "kimi", resetSoftTokensOnResume: true, context: { source: "acp_usage_update", read: acpContextValue } }, capabilities: { watch: true }, init: { mcpFile: ".kimi-code/mcp.json" }, hooks: { recallPlatform: "kimi", recallSource: "kimi" },
-    cli: { command: "kimi", stopNotice: form => form === "tui" ? "Kimi belongs to its own TUI terminal; end it in that terminal" : "", startWords: form => ["kimi", "--mode", form] }, display: KIMI_DISPLAY,
+    cli: { command: "kimi", launchConfigKeys: ["kimi_cmd", "peers.kimi.start_mode"], stopNotice: form => form === "tui" ? "Kimi belongs to its own TUI terminal; end it in that terminal" : "", startWords: form => ["kimi", "--mode", form] }, display: KIMI_DISPLAY,
   },
   {
     api: 1, kind: "pi", enabledSwitchStartOnly: true, displayName: "Pi", family: "pi", transport: "hub-native",
@@ -128,7 +128,7 @@ export const NATIVE_BUILTIN_DEFINITIONS_WITHOUT_QWEN: readonly AdapterDefinition
     session: { idField: "sessionId", currentId: sessionId("sessionId"), restoreOnStart: true, launchKind: "pi", launchRecord: true, ...PI_RECOVERY_SESSION, crashPlan: piCrashPlan, unrecordedTerminal: "tui", continuityBookmark: piRecoveryContinuity, continuity: { key: "pi", parse: parsePiContinuity } },
     turnEnd: "adapter", budget: { account: "pi", instrumented: true }, reporting: { tokensNotReported: true }, configuration: { schema: piConfigSchema, routingSchema: piRoutingSchema, settings: PI_SETTINGS, restartReasons: PI_RESTART_REASONS, validateEffective: piEffectiveConfig },
     routing: { localAllowedRefusal: "local_allowed = false also excludes pi for this class", longContext: "backend-limit", preferredTier: true, handoffPriority: 0, trace: "backend", backendLabel: "pi" },
-    cli: { command: "pi", previewArgs: ["--mode", "tui"], retainedTerminalNotice: piRetainedTerminalNotice, personOnlyFlags: ["--replace-session"], startWords: form => ["pi", "--mode", form] }, display: PI_DISPLAY,
+    cli: { command: "pi", launchConfigKeys: ["pi.cmd", "pi.backend", "pi.dgx_coding", "pi.dgx_fast", "pi.max_steps", "routing.pi", "peers.pi.start_mode"], previewArgs: ["--mode", "tui"], retainedTerminalNotice: piRetainedTerminalNotice, personOnlyFlags: ["--replace-session"], startWords: form => ["pi", "--mode", form] }, display: PI_DISPLAY,
   },
   {
     api: 1, kind: "local", displayName: "Local worker", family: "local", transport: "hub-native",
@@ -140,18 +140,18 @@ export const NATIVE_BUILTIN_DEFINITIONS_WITHOUT_QWEN: readonly AdapterDefinition
     session: { idField: "sessionId", currentId: sessionId("sessionId"), freshOnRestore: true, launchKind: "local", ...LOCAL_RECOVERY_SESSION, crashPlan: localCrashPlan },
     turnEnd: "adapter", budget: { account: "local", quotaExempt: true, instrumented: true }, configuration: { schema: localConfigSchema, routingSchema: localRoutingSchema, restartReasons: LOCAL_RESTART_REASONS },
     routing: { localAllowedRefusal: "local_allowed = false for this class", longContext: "skip-owner", preferredTier: true, handoffPriority: 1, trace: "route" },
-    cli: { command: "local", startWords: () => ["local"] }, display: LOCAL_DISPLAY,
+    cli: { command: "local", launchConfigKeys: ["local.deny", "local.bash_network", "local.network_allow", "local.max_steps", "local.read_allow", "routing.local"], startWords: () => ["local"] }, display: LOCAL_DISPLAY,
   },
   {
     api: 1, kind: "jcode", displayName: "Jcode", family: "jcode", transport: "acp",
     roles: implementerRoles, optional: true, defaultOnRoster: false, trust: { onPrem: false, hubSandboxed: false },
-    start: { create: createJcode, preflight: jcodeStartPreflight, daemonPort: "owned-acp", forms: headlessForms, defaultForm: "headless", ownsTerminal: headless, launch: ctx => compatibilityLaunch("jcode", ctx), conductorStartable: true, hubSwitches: [], ownedFlags: [] },
+    start: { create: createJcode, preflight: jcodeStartPreflight, daemonPort: "owned-acp", forms: dualForms, defaultForm: "tui", ownsTerminal: terminal, explicitHeadlessMode: true, launch: ctx => compatibilityLaunch("jcode", ctx, true), conductorStartable: true, hubSwitches: [], ownedFlags: [] },
     identity: { mcp: "project-file" },
     permission: { modes: {}, unmanaged: "Jcode native policy is unmanaged; no hub mode mapping", grants: {
       ask: "no verified hub mode mapping; native policy only", "ask-when-needed": "no verified hub mode mapping; native policy only", "never-ask": "no verified hub mode mapping; native policy only" } },
     session: { idField: "sessionId", currentId: sessionId("sessionId"), launchKind: "jcode", ...JCODE_RECOVERY_SESSION, crashPlan: jcodeCrashPlan }, turnEnd: "adapter", budget: { account: "jcode" },
     // Jcode has no dedicated CSS swatch today: retain peer-palette.ts's existing 'other' fallback.
-    cli: { command: "jcode", authority: "person", startWords: () => ["jcode"] }, display: JCODE_DISPLAY, hooks: { recallPlatform: "jcode" },
+    cli: { command: "jcode", authority: "person", launchConfigKeys: ["jcode_cmd", "jcode_home", "jcode_provider_profile"], startWords: mode => ["jcode", "--mode", mode] }, display: JCODE_DISPLAY, hooks: { recallPlatform: "jcode" },
   },
 ] satisfies AdapterDefinition[]);
 

package/src/adapters/definitions/native-cli-entry-claude.ts

@@ -1,3 +1,4 @@
+import { retainedLaunchWarning } from "./native-cli-retained.ts";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -14,6 +15,8 @@ export async function runClaudeEntry(ctx: NativeCliEntryContext): Promise<void>
     if (args.includes("--print-command") || args.includes("--dry-run")) return console.log(JSON.stringify({ peer, start: "hub", note: "a headless reviewer the hub runs per review" }, null, 2));
     const hub = await ctx.connect();
     try {
+      const snapshot = (await hub.request({ t: "status" })).status;
+      const warning = retainedLaunchWarning(snapshot, peer, ctx.definition); if (warning) console.error(warning);
       const res = await hub.request({ t: "start", peer, operationId: process.env.AGENTHUB_RECOVERY_OPERATION });
       if (res.ok !== true) fail(String(res.error ?? `${peer} was not started`));
     } finally { hub.close(); }

package/src/adapters/definitions/native-cli-entry-codex.ts

@@ -1,3 +1,4 @@
+import { retainedLaunchWarning } from "./native-cli-retained.ts";
 import type { NativeCliEntryContext } from "./native-cli-entry-types.ts";
 
 export async function runCodexEntry(ctx: NativeCliEntryContext): Promise<void> {
@@ -19,6 +20,8 @@ export async function runCodexEntry(ctx: NativeCliEntryContext): Promise<void> {
   // only when a future recovery receipt supplies independently verified exact-instance execution-root evidence.
   if (recovering && !ctx.instance && before?.instanceId) await recordTerminalLaunch(peer, cwd, stateDir, before.instanceId);
   const hub = await connect();
+  const snapshot = (await hub.request({ t: "status" })).status;
+  const warning = retainedLaunchWarning(snapshot, peer, ctx.definition); if (warning) console.error(warning);
   const res = await hub.request({ t: "start", peer, args: { unattended: launch0.unattended === true }, operationId: process.env.AGENTHUB_RECOVERY_OPERATION });
   hub.close();
   if (!res.ok) fail(res.error);
@@ -28,7 +31,8 @@ export async function runCodexEntry(ctx: NativeCliEntryContext): Promise<void> {
   }
   const control = readControl(stateDir);
   if ((!recovering || ctx.instance) && control?.instanceId) await recordTerminalLaunch(peer, cwd, stateDir, control.instanceId, ctx.instance ? { executionCwd: ctx.executionCwd } : undefined);
-  const launch = buildLaunch("codex", args, { unattended: unattendedEnv, instance: peer, proxyUrl: res.proxyUrl, codexBin: projectConfig().codex_bin });
+  const runningCodexBin = res.retainedLaunchConfig?.codex_bin;
+  const launch = buildLaunch("codex", args, { unattended: unattendedEnv, instance: peer, proxyUrl: res.proxyUrl, codexBin: typeof runningCodexBin === "string" ? runningCodexBin : projectConfig().codex_bin });
   if (launch0.warning) console.error(launch0.warning);
   exec(launch.cmd, launch.args, "codex");
 }

package/src/adapters/definitions/native-cli-entry-jcode.ts

@@ -1,28 +1,99 @@
+import { retainedLaunchWarning } from "./native-cli-retained.ts";
 import { resolve } from "node:path";
 import type { NativeCliEntryContext } from "./native-cli-entry-types.ts";
+import type { ControlClient } from "../../hub/control-client.ts";
+import type { JcodeTuiBinding, JcodeTuiState } from "../jcode.ts";
 import { bundleInStatus, rosterInStatus } from "../../hub/status-roster.ts";
 
+const WAITING = "jcode's TUI opens after its first hub turn; send it work, or Ctrl-C";
+
+export async function waitForJcodeTui(hub: ControlClient, fail: NativeCliEntryContext["fail"], signal: AbortSignal,
+  options: Record<string, string | undefined>, first?: JcodeTuiState): Promise<Extract<JcodeTuiState, { state: "ready" }> | undefined> {
+  let binding: JcodeTuiBinding | undefined = first?.binding, announced = false, current = first;
+  while (!signal.aborted) {
+    if (!current) {
+      const reply = await hub.request({ t: "native_tui_launch", peer: "jcode", binding, args: options });
+      if (signal.aborted) return;
+      if (!reply.ok || !reply.binding || !["waiting", "ready"].includes(reply.state)) fail("Jcode launch changed or its native saved session is unavailable; retry from a terminal");
+      current = reply as JcodeTuiState;
+    }
+    if (binding && (binding.launchId !== current.binding.launchId || binding.sessionId !== current.binding.sessionId)) fail("Jcode launch changed while waiting");
+    binding = current.binding;
+    if (current.state === "ready") return current;
+    if (!announced) { console.log(WAITING); announced = true; }
+    await new Promise<void>(resolve => {
+      const finish = () => { clearTimeout(timer); signal.removeEventListener("abort", finish); resolve(); };
+      const timer = setTimeout(finish, 200); signal.addEventListener("abort", finish, { once: true });
+      if (signal.aborted) finish();
+    });
+    current = undefined;
+  }
+}
+
 export async function runJcodeEntry(ctx: NativeCliEntryContext): Promise<void> {
   const { args, cwd, stateDir, cliDir, unattendedEnv, connect, fail, takeFlags } = ctx;
-  const { launcherPreview, qwenSessionId, configureJcodeMcp } = ctx.helpers;
-  if (args.includes("--print-command") || args.includes("--dry-run")) {
-    try { return console.log(JSON.stringify(launcherPreview("jcode", args, cwd, stateDir, unattendedEnv), null, 2)); }
-    catch { fail("cannot preview Jcode launch: invalid arguments or configuration (details withheld)"); }
+  const { launcherPreview, qwenSessionId, configureJcodeMcp, readControl, startModeOf } = ctx.helpers;
+  const print = args.includes("--print-command");
+  if (args.includes("--dry-run") || print) {
+    // Pure previews never create a native store or start a session. Only a person may resolve an existing private tuple.
+    if (!print || args.includes("--dry-run") || !ctx.person) {
+      try { return console.log(JSON.stringify(launcherPreview("jcode", args, cwd, stateDir, unattendedEnv), null, 2)); }
+      catch { fail("cannot preview Jcode launch: invalid arguments or configuration (details withheld)"); }
+    }
   }
-  const { one, rest } = takeFlags(args, ["--mode", "--model", "--provider-profile", "--session-id"], []);
-  if (rest.length || (one["--mode"] !== undefined && one["--mode"] !== "headless")) fail("usage: ahub jcode [--mode headless] [--model <alias>] [--provider-profile <name>] [--session-id <id>]");
+  const { one, rest } = takeFlags(args.filter(arg => arg !== "--print-command"), ["--mode", "--model", "--provider-profile", "--session-id"], []);
+  if (rest.length || (one["--mode"] !== undefined && !["headless", "tui"].includes(one["--mode"]))) fail("usage: ahub jcode [--mode tui|headless] [--model <alias>] [--provider-profile <name>] [--session-id <id>]");
   if (one["--session-id"] !== undefined && !qwenSessionId(one["--session-id"])) fail("invalid Jcode session identity");
-  const hub = await connect();
+  const control = readControl(stateDir);
+  const mode = one["--mode"] ?? (ctx.instance ? "headless" : control?.startModes?.jcode ?? startModeOf(ctx.projectConfig().peers, "jcode"));
+  if (print && (mode === "headless" || !control?.features?.includes("native_tui_launch"))) {
+    try { return console.log(JSON.stringify(launcherPreview("jcode", args, cwd, stateDir, unattendedEnv), null, 2)); }
+    catch { return fail("cannot preview Jcode launch: invalid arguments or configuration (details withheld)"); }
+  }
+  if (mode === "tui" && !ctx.person) fail("Jcode's private TUI is person-only; run ahub jcode in your terminal");
+  const hub = await connect(), abort = new AbortController();
+  let interrupted = false;
+  const interruptedWait = () => { if (abort.signal.aborted && !interrupted) fail("hub connection closed while waiting for Jcode; retry from a terminal"); return abort.signal.aborted; };
+  const interrupt = () => { interrupted = true; abort.abort(); hub.close(); process.exitCode = 130; };
+  process.once("SIGINT", interrupt);
+  const oldClose = hub.onClose;
+  hub.onClose = (code, reason) => { if (!abort.signal.aborted) abort.abort(); oldClose?.(code, reason); };
   try {
     const snapshot = (await hub.request({ t: "status" })).status;
     const rostered = rosterInStatus(snapshot, "jcode");
     if (rostered === undefined) fail("cannot read jcode's roster membership from the running hub; upgrade or restart it, then retry (nothing was started)");
     if (!rostered) fail("jcode is off roster; add it with ahub roster add jcode");
-    // The daemon verifies the entry against its own bundle; fall back to this CLI's copy only for a hub that reports none.
+    const warning = retainedLaunchWarning(snapshot, "jcode", ctx.definition); if (warning) console.error(warning);
+    const options = { model: one["--model"], providerProfile: one["--provider-profile"], sessionId: one["--session-id"] };
+    if (print) {
+      if (!hub.features.includes("native_tui_launch") || mode !== "tui") return console.log(JSON.stringify(launcherPreview("jcode", args, cwd, stateDir, unattendedEnv), null, 2));
+      const reply = await hub.request({ t: "native_tui_launch", peer: "jcode", args: options });
+      if (!reply.ok || reply.state !== "ready") fail("Jcode's selected native session is not saved and ready; run ahub jcode to wait for its first hub turn");
+      return console.log(JSON.stringify(reply.launch, null, 2));
+    }
+    if (mode === "tui") {
+      if (!hub.features.includes("native_tui_launch")) fail("the running hub does not support Jcode TUI launch; upgrade it before retrying");
+      if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        if (one["--mode"] || Object.values(options).some(value => value !== undefined)) fail("run ahub jcode with these options in a terminal");
+        const reply = await hub.request({ t: "peer_start", peer: "jcode" });
+        if (!reply.ok) fail(reply.error);
+        console.log(reply.command ?? "Jcode terminal requested"); return;
+      }
+    }
     const written = configureJcodeMcp(cwd, stateDir, bundleInStatus(snapshot) ?? resolve(cliDir, "../../plugins/agent-hub/server.js"));
     if (written.tracked) console.error(".jcode/mcp.json is tracked; review this local machine-path change before committing it");
-    const reply = await hub.request({ t: "start", peer: "jcode", args: { mode: "headless", model: one["--model"], providerProfile: one["--provider-profile"], sessionId: one["--session-id"] }, operationId: process.env.AGENTHUB_RECOVERY_OPERATION }, 65_000);
+    const reply = await hub.request({ t: "start", peer: "jcode", args: { mode, ...options }, operationId: process.env.AGENTHUB_RECOVERY_OPERATION }, 65_000);
+    if (interruptedWait()) return;
     if (!reply.ok) fail(reply.error);
-    console.log(reply.already ? "jcode is already attached" : "jcode attached (headless); native policy unmanaged, NO hub sandbox");
-  } finally { hub.close(); }
+    if (mode === "headless") { console.log(reply.already ? "jcode is already attached" : "jcode attached (headless); native policy unmanaged, NO hub sandbox"); return; }
+    const ready = await waitForJcodeTui(hub, fail, abort.signal, options);
+    if (interruptedWait() || !ready) return;
+    const instanceId = typeof snapshot?.instanceId === "string" ? snapshot.instanceId : undefined;
+    if (!instanceId) return fail("cannot bind Jcode's terminal to the running hub");
+    await ctx.helpers.recordTerminalLaunch("jcode", cwd, stateDir, instanceId);
+    const confirmed = await hub.request({ t: "native_tui_launch", peer: "jcode", binding: ready.binding, args: options });
+    if (interruptedWait()) return;
+    if (!confirmed.ok || confirmed.state !== "ready") fail("Jcode launch changed before its terminal opened");
+    ctx.execWithEnv(confirmed.launch.cmd, confirmed.launch.args, { ...ctx.helpers.childEnv(), ...confirmed.launch.env });
+  } finally { process.removeListener("SIGINT", interrupt); hub.onClose = oldClose; hub.close(); }
 }