@pi-archimedes/core 2.7.3 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/core",
-  "version": "2.7.3",
+  "version": "2.8.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/danielcherubini/pi-archimedes.git"
@@ -16,6 +16,7 @@
   "main": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts",
+    "./bridge": "./src/bridge/index.ts",
     "./bus": "./src/bus.ts",
     "./chrome": "./src/chrome.ts",
     "./text": "./src/text.ts",

package/src/bridge/channel.ts

@@ -0,0 +1,243 @@
+// ── Bridge channel (connection layer — herdr + subagent precedents) ──────
+//
+// The Client (desktop) is the server (a 0600 Unix socket / Windows named
+// pipe); the suite is the client (an ephemeral net.createConnection per
+// message, herdr-style). This module owns the socket lifecycle:
+//   - sendEvent: best-effort push (initial + 2 retries at 500/1500 ms, then
+//     drop; coalesced to at most one in-flight connection per event type).
+//   - request: interactive (a single request/response over one connection;
+//     5-minute timeout (unref'd) → immediate reject + socket destroy;
+//     connection close = immediate cancel; unreachable channel → fail fast).
+//     Returns a cancellable handle ({ promise, cancel }).
+//
+// The `active` flag does NOT depend on a successful connection (lazy,
+// per-message connect). A failed connect is a no-op.
+
+import * as net from "node:net";
+import { randomUUID } from "node:crypto";
+
+let active = false;
+let socketPath: string | undefined;
+let seq = 0; // starts at 0; the first frame is seq: 1
+
+// Generation guard: bumped by __resetForTests so a stale retry chain (a retry
+// setTimeout scheduled on a detached entry after a reset) dies at the reset
+// boundary. Without it, the per-attempt ackTimer is never tracked in the entry
+// and the socket's close → finish(false) fires AFTER the reset, scheduling a
+// fresh retry timer on the now-detached entry — a timer nothing will ever
+// clear (it would also cross-wire into a fresh same-event entry from the next
+// test). A stale chain is a no-op when the timer fires (g !== generation).
+let generation = 0;
+
+// Coalescing guard: at most one in-flight connection per event type. While one
+// is in flight, a newer sendEvent for the same event queues its payload
+// (latest wins) and it is sent when the current one settles.
+const inFlight = new Map<string, { queued: unknown; timer?: ReturnType<typeof setTimeout> }>();
+
+// Track open sockets so __resetForTests can reap them (prevents test hangs).
+const openSockets = new Set<net.Socket>();
+
+export function configure(opts: { active: boolean; socketPath: string | undefined }): void {
+  active = opts.active;
+  socketPath = opts.socketPath;
+}
+
+export function isActive(): boolean {
+  return active;
+}
+
+function socketTarget(): string | undefined {
+  // env value is the bare pipe name on Windows (the Client contract — unlike
+  // PI_SUBAGENT_SOCKET, which is a full pipe path).
+  if (!socketPath) return undefined;
+  return process.platform === "win32" ? `\\\\.\\pipe\\${socketPath}` : socketPath;
+}
+
+function trackSocket(socket: net.Socket): void {
+  openSockets.add(socket);
+  socket.on("close", () => openSockets.delete(socket));
+}
+
+/** Test seam: reset the module singletons and reap any open sockets. */
+export function __resetForTests(): void {
+  active = false;
+  socketPath = undefined;
+  seq = 0;
+  generation++; // kill any stale retry chain scheduled on a detached entry
+  for (const entry of inFlight.values()) {
+    if (entry.timer) clearTimeout(entry.timer);
+  }
+  inFlight.clear();
+  for (const socket of openSockets) {
+    try { socket.destroy(); } catch { /* already closed */ }
+  }
+  openSockets.clear();
+}
+
+// ── Best-effort push ─────────────────────────────────────────────────────
+
+export function sendEvent(event: string, payload: unknown): void {
+  const existing = inFlight.get(event);
+  if (existing) {
+    existing.queued = payload; // latest wins
+    return;
+  }
+  inFlight.set(event, { queued: undefined });
+  runAttempt(event, 0, payload);
+}
+
+function runAttempt(event: string, attempt: number, payload: unknown): void {
+  const entry = inFlight.get(event);
+  if (!entry) return;
+  // Consume the latest queued payload (latest wins).
+  const framePayload = entry.queued !== undefined ? entry.queued : payload;
+  entry.queued = undefined;
+
+  const target = socketTarget();
+  if (!target) {
+    settle(event); // unreachable channel → no-op
+    return;
+  }
+
+  const frame = { v: 1, type: "push", seq: ++seq, event, payload: framePayload };
+  const socket = net.createConnection(target);
+  trackSocket(socket);
+
+  let done = false;
+  const finish = (ok: boolean) => {
+    if (done) return;
+    done = true;
+    clearTimeout(ackTimer);
+    try { socket.destroy(); } catch { /* already closed */ }
+    if (ok) {
+      settle(event);
+    } else if (attempt < 2) {
+      // Retry: initial → 500 ms → 1500 ms → drop.
+      const delay = attempt === 0 ? 500 : 1500;
+      const g = generation; // generation guard: a stale chain (a reset happened
+      // between scheduling and firing) is a no-op when it fires — the timer
+      // dies at the reset boundary instead of leaking a retry on a detached
+      // entry (the close → finish(false) that schedules it fires AFTER reset).
+      const timer = setTimeout(() => {
+        if (g !== generation) return;
+        runAttempt(event, attempt + 1, framePayload);
+      }, delay);
+      timer.unref?.();
+      entry.timer = timer;
+    } else {
+      settle(event);
+    }
+  };
+
+  // No-ack window: if the connection is alive but never acks, treat it as a
+  // failure and retry. (The Client acks promptly after receiving a push.)
+  const ackTimer = setTimeout(() => finish(false), 1000);
+  ackTimer.unref?.();
+
+  socket.on("connect", () => {
+    try { socket.write(JSON.stringify(frame) + "\n"); } catch { finish(false); }
+  });
+  socket.on("data", () => finish(true)); // first data = the ack line
+  socket.on("error", () => finish(false));
+  socket.on("close", () => finish(false));
+}
+
+function settle(event: string): void {
+  const entry = inFlight.get(event);
+  if (!entry) return;
+  if (entry.timer) { clearTimeout(entry.timer); delete entry.timer; }
+  if (entry.queued !== undefined) {
+    // A newer payload accumulated while in flight — send it (latest wins).
+    const queued = entry.queued;
+    entry.queued = undefined;
+    runAttempt(event, 0, queued);
+  } else {
+    inFlight.delete(event);
+  }
+}
+
+// ── Interactive request ───────────────────────────────────────────────────
+
+export function request<T>(
+  method: string,
+  params: unknown,
+  opts?: { toolCallId?: string; source?: string },
+): { promise: Promise<T>; cancel: () => void } {
+  const id = randomUUID();
+  const frame = {
+    v: 1,
+    type: "request",
+    id,
+    method,
+    source: opts?.source ?? "main",
+    toolCallId: opts?.toolCallId,
+    params,
+  };
+
+  let settled = false;
+  let socket: net.Socket | undefined;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const promise = new Promise<T>((resolve, reject) => {
+    const target = socketTarget();
+    if (!target) {
+      // Unreachable channel → fail fast.
+      settled = true;
+      reject(new Error("bridge channel unreachable"));
+      return;
+    }
+
+    const finish = (err?: Error, value?: T) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      try { socket?.destroy(); } catch { /* already closed */ }
+      if (err) reject(err);
+      else resolve(value as T);
+    };
+
+    // 5-minute timeout (unref'd) → immediate reject + socket destroy.
+    timer = setTimeout(() => {
+      finish(new Error("bridge request timed out"));
+    }, 5 * 60 * 1000);
+    timer.unref?.();
+
+    socket = net.createConnection(target);
+    const sock = socket; // capture non-undefined for the handlers below
+    trackSocket(sock);
+    let buffer = "";
+
+    sock.on("connect", () => {
+      try { sock.write(JSON.stringify(frame) + "\n"); } catch { finish(new Error("failed to write request")); }
+    });
+    sock.on("data", (chunk: Buffer) => {
+      buffer += chunk.toString("utf-8");
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const msg = JSON.parse(trimmed) as { type?: string; id?: string; result?: T; error?: string };
+          if (msg.type === "response" && msg.id === id) {
+            if (msg.error !== undefined) finish(new Error(msg.error));
+            else finish(undefined, msg.result);
+          }
+        } catch { /* malformed line — ignore */ }
+      }
+    });
+    // error / close before a response → cancel.
+    sock.on("error", () => finish(new Error("bridge channel error")));
+    sock.on("close", () => finish(new Error("bridge channel closed before response")));
+  });
+
+  // cancel() closes the socket (→ the promise rejects with a cancel error) and
+  // is idempotent. A bare Promise cannot be cancelled, so the ASK_CANCEL path
+  // needs this surface.
+  const cancel = () => {
+    if (settled) return;
+    try { socket?.destroy(); } catch { /* already closed */ }
+  };
+
+  return { promise, cancel };
+}

package/src/bridge/events.ts

@@ -0,0 +1,197 @@
+// ── Bridge events (bus subscriptions — the state machine + subagent
+//    forwarding + push events) ─────────────────────────────────────────────
+//
+// Subscribes the SIX real bus events (nothing emits agent_start/agent_settled/
+// session_start on the bus — those are pi extension events dispatched via
+// pi.on(...) and handled in registerBridge). Bus event names map to wire names
+// as explicit literals at each call site (no lookup table, no string surgery):
+//   COST_UPDATE → cost_update, TODOS_UPDATE → todos_update, TODOS_CLEAR →
+//   todos_clear. The ASK_* trio is not forwarded as pushes of their own —
+//   ASK_REQUEST drives the refcount + subagent forwarding, ASK_CANCEL cancels
+//   the pending Client request, and ASK_RESPONSE additionally triggers a
+//   `state` push (refcount-- + pushState).
+//
+// The bridge is the SOLE emitter of child-path ASK_RESPONSE (spawn.ts only
+// signals via ASK_CANCEL). Every forwarded ASK_REQUEST is eventually paired
+// with an ASK_RESPONSE (success, error, timeout, or ASK_CANCEL) so the
+// refcount never leaks.
+//
+// start() is one-way (no teardown counterpart to channel.configure({active:
+// false})). That's safe today because bridge activation is a process-constant
+// (isBridgeMode is evaluated once at session_start and never changes within a
+// process) — a future mixed-mode change (flipping active per session) would
+// need a stop() counterpart or it would leak the bus subscriptions.
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getBus, Events } from "../bus.js";
+import { sendEvent, request } from "./channel.js";
+
+let refcount = 0;
+let settled = false;
+let started = false; // the start() idempotency guard (sole writer is start())
+let sessionCtx: ExtensionContext | undefined;
+
+const pending = new Map<string, { source: string; toolCallId?: string; cancel: () => void }>();
+const unsubscribers: Array<() => void> = [];
+
+export function state(): "working" | "idle" | "blocked" {
+  return refcount > 0 ? "blocked" : (settled ? "idle" : "working");
+}
+
+function pushState(): void {
+  sendEvent("state", { state: state() });
+}
+
+// ── Pi extension events (NOT bus events — nothing emits them on the bus;
+//    they're dispatched by the extension runner via pi.on(...) and DO fire in
+//    RPC mode, since the RPC driver runs the same session machinery). ──────
+
+export function onAgentStart(): void {
+  settled = false;
+  pushState();
+}
+
+export function onAgentSettled(): void {
+  settled = true;
+  pushState();
+}
+
+export function onSessionStart(ctx?: ExtensionContext): void {
+  if (ctx) sessionCtx = ctx;
+  // Re-emitted on every session_start so a lost frame is recoverable; the
+  // payload echoes PI_ARCHIMEDES_BRIDGE_SESSION so the Client can assert the
+  // connection↔session mapping rather than infer it from the socket path.
+  // (Does NOT set `started` — start() is the sole writer of that flag, so a
+  // call-order flip can't turn start() into a permanent no-op; the session
+  // push is unconditional by design.)
+  sendEvent("session", { ...sessionRefs(), bridgeSession: process.env.PI_ARCHIMEDES_BRIDGE_SESSION });
+}
+
+function sessionRefs(): Record<string, unknown> {
+  const sm = sessionCtx?.sessionManager;
+  if (!sm) return {};
+  const refs: Record<string, unknown> = {};
+  try { refs.sessionId = sm.getSessionId?.(); } catch { /* */ }
+  try { refs.sessionFile = sm.getSessionFile?.(); } catch { /* */ }
+  try { refs.cwd = sm.getCwd?.(); } catch { /* */ }
+  try { refs.sessionName = sm.getSessionName?.(); } catch { /* */ }
+  return refs;
+}
+
+/**
+ * Subscribe the six real bus events. Idempotent (a re-start on /reload does
+ * not double-subscribe — guarded by the `started` flag; the unsubscribers are
+ * stored so a reset can tear them down).
+ */
+export function start(): void {
+  if (started) return;
+  started = true;
+
+  unsubscribers.push(getBus().on(Events.ASK_REQUEST, (payload: unknown) => {
+    const p = payload as {
+      source: string;
+      requestId: string;
+      toolCallId?: string;
+      questions: Array<{ id: string }>;
+    };
+    refcount++;
+    // A subagent ask is forwarded to the Client. A source === "main" ask is
+    // NOT forwarded here — the root's Client request comes from bridge.ask()
+    // directly; the bus event is for the refcount only.
+    if (p.source !== "main") {
+      const { cancel } = requestAskToClient(p);
+      const entry: { source: string; toolCallId?: string; cancel: () => void } = { source: p.source, cancel };
+      if (p.toolCallId !== undefined) entry.toolCallId = p.toolCallId;
+      pending.set(p.requestId, entry);
+    }
+  }));
+
+  unsubscribers.push(getBus().on(Events.ASK_RESPONSE, () => {
+    // Defensive floor: a spurious/duplicated ASK_RESPONSE must not drive the
+    // refcount negative — a negative count would make every later ask
+    // off-by-one (state reports working/idle while a prompt is pending, never
+    // blocked again). The floor keeps the machine honest. A decrement at
+    // refcount === 0 is a bug signal (by the module's own invariant, every
+    // ASK_REQUEST is paired) — log it so the protocol violation doesn't
+    // disappear without a trace.
+    if (refcount === 0) console.warn("[archimedes:bridge] unpaired ASK_RESPONSE received (refcount already 0)");
+    refcount = Math.max(0, refcount - 1);
+    pushState();
+  }));
+
+  unsubscribers.push(getBus().on(Events.ASK_CANCEL, (payload: unknown) => {
+    const p = payload as { requestId: string };
+    const entry = pending.get(p.requestId);
+    // cancel() closes the socket → the request rejects → the .catch below
+    // emits the cancelled ASK_RESPONSE → refcount-- + pending.delete. The
+    // ASK_CANCEL itself does not touch the refcount (no double-decrement).
+    if (entry) entry.cancel();
+  }));
+
+  // Bus payload types ARE the wire types — forward verbatim.
+  unsubscribers.push(getBus().on(Events.TODOS_UPDATE, (payload: unknown) => {
+    sendEvent("todos_update", payload);
+  }));
+
+  unsubscribers.push(getBus().on(Events.TODOS_CLEAR, (payload: unknown) => {
+    sendEvent("todos_clear", payload);
+  }));
+
+  unsubscribers.push(getBus().on(Events.COST_UPDATE, (payload: unknown) => {
+    sendEvent("cost_update", payload);
+  }));
+}
+
+/**
+ * Send a forwarded (subagent) ask to the Client and wire the response. The
+ * bridge is the sole emitter of child-path ASK_RESPONSE: on a settled ask it
+ * emits the Client's response verbatim; on a failure (error / timeout /
+ * cancel / child exit) it emits a cancelled ASK_RESPONSE so the refcount
+ * always pairs.
+ */
+function requestAskToClient(
+  payload: {
+    requestId: string;
+    source: string;
+    toolCallId?: string;
+    questions: Array<{ id: string }>;
+  },
+): { cancel: () => void } {
+  const opts: { toolCallId?: string; source?: string } = { source: payload.source };
+  if (payload.toolCallId !== undefined) opts.toolCallId = payload.toolCallId;
+  const handle = request<{
+    cancelled: boolean;
+    results: Array<{ id: string; selectedOptions: string[]; customInput?: string }>;
+  }>("ask", payload.questions, opts);
+
+  handle.promise
+    .then((resp) => {
+      getBus().emit(Events.ASK_RESPONSE, {
+        requestId: payload.requestId,
+        cancelled: resp.cancelled,
+        results: resp.results,
+      });
+      pending.delete(payload.requestId);
+    })
+    .catch(() => {
+      getBus().emit(Events.ASK_RESPONSE, {
+        requestId: payload.requestId,
+        cancelled: true,
+        results: payload.questions.map((q) => ({ id: q.id, selectedOptions: [] })),
+      });
+      pending.delete(payload.requestId);
+    });
+
+  return { cancel: handle.cancel };
+}
+
+/** Test seam: reset the module singletons and tear down the bus subscriptions. */
+export function __resetForTests(): void {
+  refcount = 0;
+  settled = false;
+  started = false;
+  sessionCtx = undefined;
+  pending.clear();
+  for (const u of unsubscribers) u();
+  unsubscribers.length = 0;
+}

package/src/bridge/index.test.ts

@@ -0,0 +1,576 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { randomUUID } from "node:crypto";
+import { getBus, Events } from "../bus.js";
+import {
+  getBridge,
+  ask,
+  confirm,
+  password,
+  registerBridge,
+  BridgeInactiveError,
+} from "./index.js";
+import { configure, sendEvent, request, __resetForTests as resetChannel } from "./channel.js";
+import {
+  state,
+  start,
+  onAgentStart,
+  onAgentSettled,
+  onSessionStart,
+  __resetForTests as resetEvents,
+} from "./events.js";
+
+// ── env helpers ─────────────────────────────────────────────────────────
+
+const ENV_KEYS = [
+  "PI_ARCHIMEDES_BRIDGE",
+  "PI_ARCHIMEDES_BRIDGE_SOCKET",
+  "PI_ARCHIMEDES_BRIDGE_SESSION",
+  "PI_ARCHIMEDES_BRIDGE_SERVER_PID",
+  "PI_SUBAGENT_SOCKET",
+] as const;
+
+const savedEnv: Record<string, string | undefined> = {};
+
+function clearBridgeEnv(): void {
+  for (const k of ENV_KEYS) delete process.env[k];
+}
+
+function setBridgeEnv(overrides: Record<string, string> = {}): void {
+  clearBridgeEnv();
+  process.env.PI_ARCHIMEDES_BRIDGE = "1";
+  process.env.PI_ARCHIMEDES_BRIDGE_SOCKET = "/tmp/nonexistent-bridge.sock";
+  process.env.PI_ARCHIMEDES_BRIDGE_SESSION = "desktop-session-1";
+  process.env.PI_ARCHIMEDES_BRIDGE_SERVER_PID = "12345";
+  for (const [k, v] of Object.entries(overrides)) process.env[k] = v;
+}
+
+function makeFakeCtx(mode: "tui" | "rpc" | "json" | "print"): { mode: string } {
+  return { mode };
+}
+
+/** Register the bridge and fire its session_start handler with the given ctx. */
+function registerAndFireSessionStart(ctx: { mode: string }): void {
+  const onSpy = vi.fn();
+  registerBridge({ on: onSpy } as unknown as ExtensionAPI);
+  const calls = onSpy.mock.calls as Array<[string, (e: unknown, ctx: unknown) => void]>;
+  const startCall = calls.find((c) => c[0] === "session_start");
+  expect(startCall).toBeTruthy();
+  startCall![1](null, ctx);
+}
+
+function tempSocketPath(): string {
+  return path.join(os.tmpdir(), `bridge-test-${randomUUID()}.sock`);
+}
+
+/** A minimal valid AskQuestion (matches AskRequestPayload["questions"][n]). */
+function makeQuestion(overrides: Partial<{ id: string; question: string }> = {}): {
+  id: string;
+  question: string;
+  options: Array<{ label: string }>;
+} {
+  return {
+    id: overrides.id ?? "q1",
+    question: overrides.question ?? "Which option?",
+    options: [{ label: "A" }, { label: "B" }],
+  };
+}
+
+function startServer(
+  sockPath: string,
+  onFrame: (frame: Record<string, unknown>) => void,
+): Promise<net.Server> {
+  const server = net.createServer((socket) => {
+    let buffer = "";
+    socket.on("data", (chunk: Buffer) => {
+      buffer += chunk.toString("utf-8");
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          onFrame(JSON.parse(trimmed) as Record<string, unknown>);
+        } catch {
+          /* malformed — ignore */
+        }
+      }
+    });
+    socket.on("error", () => { /* connection dropped */ });
+  });
+  return new Promise((resolve) => server.listen(sockPath, () => resolve(server)));
+}
+
+beforeEach(() => {
+  for (const k of ENV_KEYS) savedEnv[k] = process.env[k];
+  clearBridgeEnv();
+  resetChannel();
+  resetEvents();
+});
+
+afterEach(() => {
+  for (const k of ENV_KEYS) {
+    if (savedEnv[k] === undefined) delete process.env[k];
+    else process.env[k] = savedEnv[k];
+  }
+  clearBridgeEnv();
+  resetChannel();
+  resetEvents();
+});
+
+// ── 1. Env matrix (getBridge().active at session_start) ─────────────────
+
+describe("env matrix (getBridge().active at session_start)", () => {
+  it("(a) no env → active === false", () => {
+    clearBridgeEnv();
+    registerAndFireSessionStart(makeFakeCtx("rpc"));
+    expect(getBridge().active).toBe(false);
+  });
+
+  it("(b) all env + tui mode → active === false (TUI wins)", () => {
+    setBridgeEnv();
+    registerAndFireSessionStart(makeFakeCtx("tui"));
+    expect(getBridge().active).toBe(false);
+  });
+
+  it("(c) all env + rpc mode + no PI_SUBAGENT_SOCKET → active === true", () => {
+    setBridgeEnv();
+    registerAndFireSessionStart(makeFakeCtx("rpc"));
+    expect(getBridge().active).toBe(true);
+  });
+
+  it("(d) all env + rpc mode + PI_SUBAGENT_SOCKET set → active === false (root-only)", () => {
+    setBridgeEnv({ PI_SUBAGENT_SOCKET: "/tmp/subagent.sock" });
+    registerAndFireSessionStart(makeFakeCtx("rpc"));
+    expect(getBridge().active).toBe(false);
+  });
+
+  it("missing one env var (SERVER_PID) → active === false", () => {
+    setBridgeEnv();
+    delete process.env.PI_ARCHIMEDES_BRIDGE_SERVER_PID;
+    registerAndFireSessionStart(makeFakeCtx("rpc"));
+    expect(getBridge().active).toBe(false);
+  });
+});
+
+// ── 2. Inactive API ──────────────────────────────────────────────────────
+
+describe("inactive API", () => {
+  it("ask throws BridgeInactiveError", () => {
+    clearBridgeEnv();
+    expect(() => ask({ questions: [makeQuestion()] }, "tool-1")).toThrow(BridgeInactiveError);
+    expect(() => ask({ questions: [makeQuestion()] }, "tool-1")).toThrow("bridge is not active");
+  });
+
+  it("confirm resolves false", async () => {
+    clearBridgeEnv();
+    await expect(confirm({ command: "rm -rf /", reason: "test" })).resolves.toBe(false);
+  });
+
+  it("password resolves empty string", async () => {
+    clearBridgeEnv();
+    await expect(password({ command: "sudo apt install", reason: "test" })).resolves.toBe("");
+  });
+});
+
+// ── 3. State machine ─────────────────────────────────────────────────────
+
+describe("state machine", () => {
+  it("onAgentSettled → idle; onAgentStart → working", () => {
+    start();
+    onAgentSettled();
+    expect(state()).toBe("idle");
+    onAgentStart();
+    expect(state()).toBe("working");
+  });
+
+  it("ASK_REQUEST → blocked; stays blocked through onAgentSettled; ASK_RESPONSE → idle (settled)", () => {
+    start();
+    onAgentSettled(); // settled = true
+    getBus().emit(Events.ASK_REQUEST, { source: "main", requestId: "r1", questions: [makeQuestion()] });
+    expect(state()).toBe("blocked");
+    onAgentSettled(); // still blocked (refcount > 0)
+    expect(state()).toBe("blocked");
+    getBus().emit(Events.ASK_RESPONSE, { requestId: "r1", cancelled: false, results: [] });
+    expect(state()).toBe("idle"); // settled
+  });
+
+  it("ASK_RESPONSE → working (not settled)", () => {
+    start();
+    onAgentStart(); // settled = false
+    getBus().emit(Events.ASK_REQUEST, { source: "main", requestId: "r2", questions: [makeQuestion()] });
+    expect(state()).toBe("blocked");
+    getBus().emit(Events.ASK_RESPONSE, { requestId: "r2", cancelled: false, results: [] });
+    expect(state()).toBe("working"); // not settled
+  });
+
+  it("an unpaired ASK_RESPONSE does not drive the refcount negative (floor at 0)", () => {
+    start();
+    onAgentSettled(); // settled = true
+    expect(state()).toBe("idle");
+
+    // A spurious/duplicated ASK_RESPONSE with no matching ASK_REQUEST must not
+    // push the refcount below zero (the floor keeps the machine honest).
+    getBus().emit(Events.ASK_RESPONSE, { requestId: "orphan", cancelled: false, results: [] });
+    expect(state()).toBe("idle"); // floor at 0 (not -1)
+
+    // A legitimate ask is still blocked (the floor prevented the negative count).
+    getBus().emit(Events.ASK_REQUEST, { source: "main", requestId: "r3", questions: [makeQuestion()] });
+    expect(state()).toBe("blocked");
+
+    // ...and it still unblocks cleanly.
+    getBus().emit(Events.ASK_RESPONSE, { requestId: "r3", cancelled: false, results: [] });
+    expect(state()).toBe("idle"); // settled
+  });
+});
+
+// ── 4. ASK_CANCEL flow ───────────────────────────────────────────────────
+
+describe("ASK_CANCEL flow", () => {
+  it("a cancelled subagent ask emits a cancelled ASK_RESPONSE and refcount returns to 0", async () => {
+    const sockPath = tempSocketPath();
+    const server = await startServer(sockPath, () => {
+      /* accept but never respond */
+    });
+
+    start();
+    configure({ active: true, socketPath: sockPath });
+
+    const responses: unknown[] = [];
+    const unsub = getBus().on(Events.ASK_RESPONSE, (p) => responses.push(p));
+
+    getBus().emit(Events.ASK_REQUEST, {
+      source: "subagent:x",
+      requestId: "sub-req-1",
+      questions: [makeQuestion()],
+    });
+    expect(state()).toBe("blocked");
+
+    // Give the forwarded request a moment to connect to the (silent) server.
+    await new Promise((r) => setTimeout(r, 50));
+
+    getBus().emit(Events.ASK_CANCEL, { requestId: "sub-req-1", source: "subagent:x" });
+
+    // The cancel closes the socket → the request rejects → a cancelled ASK_RESPONSE is emitted.
+    await vi.waitFor(() => {
+      expect(responses.length).toBeGreaterThanOrEqual(1);
+    }, 3000);
+
+    const resp = responses[0] as { requestId: string; cancelled: boolean; results: unknown[] };
+    expect(resp.requestId).toBe("sub-req-1");
+    expect(resp.cancelled).toBe(true);
+    expect(resp.results).toEqual([{ id: "q1", selectedOptions: [] }]);
+    expect(state()).toBe("working"); // refcount back to 0, not settled
+
+    unsub();
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+
+  it("ASK_CANCEL with no pending entry is a no-op (no crash, refcount untouched)", () => {
+    start();
+    getBus().emit(Events.ASK_CANCEL, { requestId: "does-not-exist", source: "subagent:x" });
+    expect(state()).toBe("working"); // refcount still 0
+  });
+});
+
+// ── 5. request round-trip + cancel ───────────────────────────────────────
+
+describe("request round-trip + cancel", () => {
+  it("resolves with the response result", async () => {
+    const sockPath = tempSocketPath();
+    const server = await startServer(sockPath, (frame) => {
+      /* the server's onFrame is used below via a dedicated handler */
+    });
+    // Replace with a server that echoes a response for a matching id.
+    server.close();
+    const echoServer = net.createServer((socket) => {
+      let buffer = "";
+      socket.on("data", (chunk: Buffer) => {
+        buffer += chunk.toString("utf-8");
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const msg = JSON.parse(trimmed) as { type?: string; id?: string };
+            if (msg.type === "request" && msg.id) {
+              socket.write(JSON.stringify({ v: 1, type: "response", id: msg.id, result: "roundtrip-ok" }) + "\n");
+            }
+          } catch { /* malformed — ignore */
+          }
+        }
+      });
+      socket.on("error", () => { /* connection dropped */ });
+    });
+    await new Promise<void>((resolve) => echoServer.listen(sockPath, resolve));
+
+    configure({ active: true, socketPath: sockPath });
+    const { promise } = request("ask", { questions: [makeQuestion()] });
+    await expect(promise).resolves.toBe("roundtrip-ok");
+
+    echoServer.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+
+  it("cancel() before the response rejects with a cancel error", async () => {
+    const sockPath = tempSocketPath();
+    const server = await startServer(sockPath, () => {
+      /* accept but never respond */
+    });
+
+    configure({ active: true, socketPath: sockPath });
+    const { promise, cancel } = request("ask", { questions: [makeQuestion()] });
+    await new Promise((r) => setTimeout(r, 50)); // let the socket connect
+    cancel();
+    await expect(promise).rejects.toThrow();
+    // Idempotent: a second cancel is a no-op.
+    cancel();
+
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+
+  it("an unreachable channel fails fast (rejects on connect error)", async () => {
+    configure({ active: true, socketPath: "/tmp/definitely-does-not-exist-bridge.sock" });
+    const { promise } = request("ask", { questions: [makeQuestion()] });
+    await expect(promise).rejects.toThrow();
+  });
+
+  it("ask() with an AbortSignal cancels the request on abort", async () => {
+    const sockPath = tempSocketPath();
+    const server = await startServer(sockPath, () => {
+      /* accept but never respond */
+    });
+
+    configure({ active: true, socketPath: sockPath });
+    const controller = new AbortController();
+    const p = ask({ questions: [makeQuestion()] }, "tool-1", controller.signal);
+    await new Promise((r) => setTimeout(r, 50)); // let the socket connect
+    controller.abort();
+    await expect(p).rejects.toThrow();
+
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+
+  it("ask() with a PRE-ABORTED signal cancels the request immediately (no lingering)", async () => {
+    const sockPath = tempSocketPath();
+    const server = await startServer(sockPath, () => {
+      /* accept but never respond */
+    });
+
+    configure({ active: true, socketPath: sockPath });
+    const controller = new AbortController();
+    controller.abort(); // pre-aborted BEFORE ask() is invoked
+    const p = ask({ questions: [makeQuestion()] }, "tool-1", controller.signal);
+
+    // A pre-aborted signal never dispatches its "abort" event (it fires exactly
+    // once, at abort time), so addEventListener alone would leave the request
+    // lingering until the Client responds or the 5-minute timeout. The fix
+    // calls cancel() directly when the signal is already aborted → the promise
+    // rejects quickly (the socket-close handler settles it).
+    await expect(p).rejects.toThrow();
+
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+});
+
+// ── 6. seq counter ───────────────────────────────────────────────────────
+
+describe("seq counter", () => {
+  it("two sendEvent calls produce seq 1 then seq 2 (coalesced, latest wins)", async () => {
+    const sockPath = tempSocketPath();
+    const frames: Array<{ seq: number; event: string; payload: unknown }> = [];
+    const server = net.createServer((socket) => {
+      let buffer = "";
+      socket.on("data", (chunk: Buffer) => {
+        buffer += chunk.toString("utf-8");
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const msg = JSON.parse(trimmed) as { type?: string; seq?: number; event?: string; payload?: unknown };
+            if (msg.type === "push") frames.push({ seq: msg.seq!, event: msg.event!, payload: msg.payload });
+          } catch { /* malformed — ignore */
+          }
+        }
+        socket.write("ack\n"); // ack so the sender destroys
+      });
+      socket.on("error", () => { /* connection dropped */ });
+    });
+    await new Promise<void>((resolve) => server.listen(sockPath, resolve));
+
+    configure({ active: true, socketPath: sockPath });
+    sendEvent("state", { state: "working" });
+    sendEvent("state", { state: "idle" }); // coalesced (latest wins)
+
+    await vi.waitFor(() => {
+      expect(frames.length).toBeGreaterThanOrEqual(2);
+    }, 3000);
+
+    expect(frames[0]!.seq).toBe(1);
+    expect(frames[1]!.seq).toBe(2);
+
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+
+  it("the session push is re-emitted on session_start and echoes PI_ARCHIMEDES_BRIDGE_SESSION", async () => {
+    const sockPath = tempSocketPath();
+    const frames: Array<{ event: string; payload: unknown }> = [];
+    const server = net.createServer((socket) => {
+      let buffer = "";
+      socket.on("data", (chunk: Buffer) => {
+        buffer += chunk.toString("utf-8");
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const msg = JSON.parse(trimmed) as { type?: string; event?: string; payload?: unknown };
+            if (msg.type === "push") frames.push({ event: msg.event!, payload: msg.payload! });
+          } catch { /* malformed — ignore */
+          }
+        }
+        socket.write("ack\n");
+      });
+      socket.on("error", () => { /* connection dropped */ });
+    });
+    await new Promise<void>((resolve) => server.listen(sockPath, resolve));
+
+    configure({ active: true, socketPath: sockPath });
+    process.env.PI_ARCHIMEDES_BRIDGE_SESSION = "my-desktop-session";
+    onSessionStart();
+
+    await vi.waitFor(() => {
+      expect(frames.some((f) => f.event === "session")).toBe(true);
+    }, 3000);
+
+    const sessionFrame = frames.find((f) => f.event === "session")!;
+    expect((sessionFrame.payload as { bridgeSession?: string }).bridgeSession).toBe("my-desktop-session");
+
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+});
+
+// ── 7. sendEvent retry/drop (unreachable channel) ────────────────────────
+
+describe("sendEvent retry/drop", () => {
+  // The legitimate timeline is ~4.5 s (initial + 2 retries at 500/1500 ms +
+  // the 1 s no-ack window each), so give the test an explicit timeout with
+  // real headroom against vitest's 5 s default. A unique event name keeps
+  // this test hermetic: inFlight is keyed by event type, so a foreign "state"
+  // retry chain from an earlier test can't cross-wire into "retry-probe".
+  it("retries twice then drops on a channel that never acks (no hang, no leaked timer)", { timeout: 10_000 }, async () => {
+    const sockPath = tempSocketPath();
+    let connections = 0;
+    const server = net.createServer((socket) => {
+      connections++;
+      // Accept but never ack and never close → the sender's no-ack window
+      // (1 s) treats it as a failure and retries (same finish(false) path as
+      // an unreachable socket; the retry/backoff/drop machinery is identical).
+      socket.on("error", () => { /* connection dropped */ });
+    });
+    await new Promise<void>((resolve) => server.listen(sockPath, resolve));
+
+    configure({ active: true, socketPath: sockPath });
+
+    // A unique event name (not "state") so a foreign "state" retry chain from
+    // an earlier test can't cross-wire into this one (inFlight is keyed by
+    // event type).
+    sendEvent("retry-probe", { state: "working" });
+
+    // initial + 2 retries (500 ms + 1500 ms) → exactly 3 attempts, then drop.
+    await vi.waitFor(() => {
+      expect(connections).toBe(3);
+    }, 6000);
+
+    // Dropped (not looping): a short wait later it is still exactly 3 (no 4th attempt).
+    await new Promise((r) => setTimeout(r, 500));
+    expect(connections).toBe(3);
+
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+});
+
+// ── 8. subagent ask success path (end-to-end through the bridge) ─────────
+
+describe("subagent ask success path", () => {
+  it("forwards to the Client and settles with the response verbatim (state unblocked)", async () => {
+    const sockPath = tempSocketPath();
+    const frames: Array<Record<string, unknown>> = [];
+    const server = net.createServer((socket) => {
+      let buffer = "";
+      socket.on("data", (chunk: Buffer) => {
+        buffer += chunk.toString("utf-8");
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const msg = JSON.parse(trimmed) as Record<string, unknown>;
+            frames.push(msg);
+            if (msg.type === "request") {
+              socket.write(JSON.stringify({
+                v: 1,
+                type: "response",
+                id: msg.id,
+                result: { cancelled: false, results: [{ id: "q1", selectedOptions: ["B"], customInput: "extra" }] },
+              }) + "\n");
+            }
+          } catch { /* malformed — ignore */ }
+        }
+      });
+      socket.on("error", () => { /* connection dropped */ });
+    });
+    await new Promise<void>((resolve) => server.listen(sockPath, resolve));
+
+    start();
+    configure({ active: true, socketPath: sockPath });
+
+    const responses: unknown[] = [];
+    const unsub = getBus().on(Events.ASK_RESPONSE, (p) => responses.push(p));
+
+    getBus().emit(Events.ASK_REQUEST, {
+      source: "subagent:x",
+      requestId: "sub-req-2",
+      toolCallId: "child-tool-1",
+      questions: [makeQuestion()],
+    });
+    expect(state()).toBe("blocked"); // refcount 1
+
+    // The Client answers → the bridge emits the paired ASK_RESPONSE verbatim
+    // (the same .then also drains `pending`, so the emission implies it).
+    await vi.waitFor(() => {
+      expect(responses.length).toBeGreaterThanOrEqual(1);
+    }, 3000);
+
+    const resp = responses[0] as { requestId: string; cancelled: boolean; results: unknown[] };
+    expect(resp.requestId).toBe("sub-req-2");
+    expect(resp.cancelled).toBe(false);
+    expect(resp.results).toEqual([{ id: "q1", selectedOptions: ["B"], customInput: "extra" }]);
+    expect(state()).toBe("working"); // refcount back to 0, not settled
+
+    // The forwarded request frame carried the source + toolCallId.
+    const reqFrame = frames.find((f) => f.type === "request")!;
+    expect(reqFrame.source).toBe("subagent:x");
+    expect(reqFrame.toolCallId).toBe("child-tool-1");
+
+    unsub();
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+});

package/src/bridge/index.ts

@@ -0,0 +1,116 @@
+// ── Bridge public API ────────────────────────────────────────────────────
+//
+// getBridge() is the singleton Tasks 2-3 import. The bridge is env-gated and
+// root-only: active iff (all 4 env vars present ∧ ctx.mode !== "tui" ∧
+// PI_SUBAGENT_SOCKET absent), evaluated at session_start. TUI always wins; a
+// subagent child (env present) is inactive. The `active` flag does not depend
+// on a successful connection (lazy, per-message connect).
+//
+// Inactive API: ask → throws BridgeInactiveError (loud); confirm → false;
+// password → "" (cancel).
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AskResponsePayload, AskRequestPayload } from "../bus.js";
+import * as channel from "./channel.js";
+import * as events from "./events.js";
+
+export class BridgeInactiveError extends Error {
+  constructor() {
+    super("bridge is not active");
+    this.name = "BridgeInactiveError";
+  }
+}
+
+function channelActive(): boolean {
+  return channel.isActive();
+}
+
+function eventsState(): "working" | "idle" | "blocked" {
+  return events.state();
+}
+
+export function getBridge() {
+  return { active: channelActive(), ask, confirm, password, state: eventsState };
+}
+
+/**
+ * Ask the Client (the root's direct Client request — NOT the relay/bridge bus
+ * subscription). The param is typed structurally from the bus payload —
+ * AskQuestion lives in packages/ask, which core cannot import.
+ */
+export function ask(params: { questions: AskRequestPayload["questions"] }, toolCallId: string, signal?: AbortSignal): Promise<AskResponsePayload> {
+  if (!channelActive()) throw new BridgeInactiveError();
+  const handle = channel.request<AskResponsePayload>("ask", params, { toolCallId, source: "main" });
+  if (signal) {
+    // Abort the turn → cancel the Client request (the tool's catch converts the
+    // cancel-rejection into the paired cancelled ASK_RESPONSE, so the refcount
+    // stays balanced). A signal that is ALREADY aborted never dispatches its
+    // "abort" event (it fires exactly once, at abort time), so an addEventListener
+    // alone would leave the request lingering until the Client responds or the
+    // 5-minute timeout — call cancel() directly in that case. cancel() is
+    // idempotent and settles the promise via the socket-close handler, so both
+    // branches coexist safely. The listener is removed on settle; the
+    // .then(onFulfilled, onRejected) form (not .finally) avoids an unhandled
+    // rejection from the derived promise when the request rejects.
+    if (signal.aborted) handle.cancel();
+    else signal.addEventListener("abort", handle.cancel, { once: true });
+    handle.promise.then(
+      () => { signal?.removeEventListener("abort", handle.cancel); },
+      () => { signal?.removeEventListener("abort", handle.cancel); },
+    );
+  }
+  return handle.promise;
+}
+
+export function confirm(params: { command: string; reason: string }): Promise<boolean> {
+  if (!channelActive()) return Promise.resolve(false);
+  return channel.request<{ confirmed: boolean }>("confirm", params, { source: "main" }).promise
+    .then((r) => r.confirmed)
+    .catch(() => false);
+}
+
+export function password(params: { command: string; reason: string }): Promise<string> {
+  if (!channelActive()) return Promise.resolve("");
+  return channel.request<{ password?: string }>("password", params, { source: "main" }).promise
+    .then((r) => r.password ?? "")
+    .catch(() => "");
+}
+
+/**
+ * Bridge-mode gate. PI_ARCHIMEDES_BRIDGE_SERVER_PID is presence-checked only
+ * in v1: agent-side server-pid verification is unimplemented on both
+ * platforms (Node's `net` exposes neither `GetNamedPipeServerProcessId` nor
+ * `SO_PEERCRED`); the desktop-side descendant check is the real defense.
+ */
+function isBridgeMode(ctx: { mode: string }): boolean {
+  return (
+    process.env.PI_ARCHIMEDES_BRIDGE === "1" &&
+    !!process.env.PI_ARCHIMEDES_BRIDGE_SOCKET &&
+    !!process.env.PI_ARCHIMEDES_BRIDGE_SESSION &&
+    !!process.env.PI_ARCHIMEDES_BRIDGE_SERVER_PID &&
+    ctx.mode !== "tui" &&
+    !process.env.PI_SUBAGENT_SOCKET
+  );
+}
+
+/**
+ * Subscribe the pi EXTENSION events (NOT the bus — nothing emits
+ * agent_start/agent_settled/session_start on the bus). The extension events DO
+ * fire in RPC mode (the RPC driver runs the same session machinery).
+ */
+export function registerBridge(pi: ExtensionAPI): void {
+  pi.on("session_start", (_e, ctx) => {
+    const active = isBridgeMode(ctx);
+    channel.configure({ active, socketPath: process.env.PI_ARCHIMEDES_BRIDGE_SOCKET });
+    if (active) {
+      events.start();
+      events.onSessionStart(ctx);
+    }
+  });
+  pi.on("agent_start", () => {
+    if (channelActive()) events.onAgentStart();
+  });
+  pi.on("agent_settled", () => {
+    if (channelActive()) events.onAgentSettled();
+  });
+}

package/src/bus.ts

@@ -104,6 +104,7 @@ export const Events = {
   TODOS_CLEAR: "archimedes:todos_clear",
   ASK_REQUEST: "archimedes:ask_request",
   ASK_RESPONSE: "archimedes:ask_response",
+  ASK_CANCEL: "archimedes:ask_cancel",
 } as const;
 
 interface TodoUpdatePayload {
@@ -118,6 +119,7 @@ interface TodoClearPayload {
 interface AskRequestPayload {
   source: string;        // "subagent:<agent-name>"
   requestId: string;     // unique id to match request → response
+  toolCallId?: string;   // the tool-call id of the process that invoked the tool (carried for Client correlation)
   questions: Array<{ id: string; question: string; description?: string; options: Array<{ label: string }>; multi?: boolean; recommended?: number }>;
 }
 
@@ -127,4 +129,9 @@ interface AskResponsePayload {
   results: Array<{ id: string; selectedOptions: string[]; customInput?: string }>;
 }
 
-export type { CostUpdatePayload, TodoUpdatePayload, TodoClearPayload, AskRequestPayload, AskResponsePayload };
+interface AskCancelPayload {
+  requestId: string;
+  source: string;
+}
+
+export type { CostUpdatePayload, TodoUpdatePayload, TodoClearPayload, AskRequestPayload, AskResponsePayload, AskCancelPayload };

package/src/index.test.ts

@@ -92,12 +92,16 @@ function registerAndCapture(): {
 } {
   const onSpy = vi.fn();
   registerCore({ on: onSpy } as unknown as ExtensionAPI);
-  // Top-level registrations are exactly: session_shutdown + session_start
-  // (message_end is registered inside the session_start handler).
+  // Top-level registrations: registerBridge (added right after patchConsoleLog)
+  // registers session_start + agent_start + agent_settled FIRST, then
+  // registerCore registers session_shutdown + its own session_start. The core's
+  // session_start handler (the one that drives the editor/spin logic) is the
+  // LAST session_start registered — find it by position, not .find (which would
+  // return the bridge's no-op handler).
   const calls = onSpy.mock.calls as Array<
     [string, (event: unknown, ctx: ExtensionContext) => void]
   >;
-  const startCall = calls.find((c) => c[0] === "session_start");
+  const startCall = calls.filter((c) => c[0] === "session_start").at(-1);
   const shutdownCall = calls.find((c) => c[0] === "session_shutdown");
   expect(startCall).toBeTruthy();
   expect(shutdownCall).toBeTruthy();

package/src/index.ts

@@ -10,6 +10,7 @@ import { patchThinkingRenderer } from "./thinking/patch.js";
 import { transformThinkingContent } from "./thinking/transform.js";
 import { loadCoreConfig, saveCoreConfig, DEFAULT_CORE_CONFIG, ANIMATION_STYLES, type CoreConfig } from "./config.js";
 import { initBus } from "./bus.js";
+import { registerBridge } from "./bridge/index.js";
 
 // Re-export for session lifecycle management
 export { unpatchConsoleLog } from "./startup/capture.js";
@@ -132,6 +133,11 @@ export function registerCore(pi: ExtensionAPI): void {
   // Patch console.log for model scope capture
   patchConsoleLog();
 
+  // Bridge (env-gated local channel to the Client) — top-level, like
+  // patchConsoleLog (never inside a session handler, so it doesn't accumulate
+  // on /reload).
+  registerBridge(pi);
+
   // session_shutdown handler (top-level to prevent accumulation on /reload)
   pi.on("session_shutdown", (_event, _ctx) => {
     // Restore the Working line if we hid it, and reap the editor's spinner