pi-subagents 0.81.0 → 0.82.0

package/bundle/{chunk-74RT5YQE.js → chunk-RMQFMMAT.js}

@@ -1,9 +1,78 @@
-// src/runs/shared/herdr-connection.ts
-import { spawn, spawnSync } from "node:child_process";
+// src/runs/shared/rex-machine.ts
+import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
-import * as net from "node:net";
 import * as os from "node:os";
 import * as path from "node:path";
+var REX_LOCAL_MACHINE = "local";
+var REX_EXIT_GONE = 3;
+var REX_EXIT_UNREACHABLE = 4;
+function isRexLocalMachine(machine) {
+  return machine?.provider === "rex" && !("target" in machine);
+}
+var REX_BUNDLE_BIN = "Library/Application Support/com.superlogical.rex/RexServer/Versions/Current/Rex Server.app/Contents/MacOS/rex";
+var REX_CALL_TIMEOUT_MS = 15e3;
+var REX_MAX_OUTPUT = 1024 * 1024;
+function rexGlobalArgs(server) {
+  return server ? ["--autostart=false", "-S", server] : ["--autostart=false"];
+}
+function executable(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return fs.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveRexBinary(env = process.env) {
+  const fromDir = env.REX_BIN_DIR ? [path.join(env.REX_BIN_DIR, "rex")] : [];
+  const fromPath = (env.PATH ?? "").split(path.delimiter).filter((dir) => path.isAbsolute(dir)).map((dir) => path.join(dir, "rex"));
+  const found = [...fromDir, ...fromPath, path.join(os.homedir(), REX_BUNDLE_BIN)].find(executable);
+  if (!found) throw new Error("The Rex CLI was not found: set REX_BIN_DIR, put rex on PATH, or install Rex.");
+  return found;
+}
+function rexCommandEnv(source = process.env) {
+  const { REX_SESSION: _session, REX_BLOCK: _block, REX_SERVER: _server, ...env } = source;
+  return env;
+}
+function sessionConfirmed(stdout, session) {
+  try {
+    const parsed = JSON.parse(stdout);
+    return parsed?.session_id === session;
+  } catch {
+    return false;
+  }
+}
+function resolveRexLocalPlacement(input) {
+  if (process.platform === "win32") throw new Error("Machine 'local' runs the child in a Rex pane, which is not supported on Windows.");
+  const env = input.env ?? process.env, session = env.REX_SESSION?.trim(), server = env.REX_SERVER?.trim();
+  if (!session) throw new Error("Machine 'local' opens the child in a new tab of this Rex session, but this Pi is not running inside Rex (REX_SESSION is not set).");
+  const result = spawnSync(resolveRexBinary(env), [...rexGlobalArgs(server), "session", "inspect", session, "--json"], { encoding: "utf8", env: rexCommandEnv(env), timeout: REX_CALL_TIMEOUT_MS, maxBuffer: REX_MAX_OUTPUT, windowsHide: true });
+  if (result.error) throw new Error(`Could not ask Rex about this session: ${result.error.message}`, { cause: result.error });
+  if (result.status === REX_EXIT_GONE) throw new Error(`Machine 'local' needs this Pi's Rex session, but the Rex server does not know session ${session}.`);
+  if (result.status === REX_EXIT_UNREACHABLE) throw new Error("Machine 'local' needs the Rex server, but it is unreachable.");
+  if (result.status !== 0) throw new Error(`rex session inspect exited with code ${result.status}: ${(result.stderr || result.stdout).trim().slice(0, 512)}`);
+  if (!sessionConfirmed(result.stdout, session)) throw new Error(`The Rex server did not confirm session ${session}.`);
+  const stepCwd = input.stepCwd?.trim();
+  const home = stepCwd === "~" || stepCwd?.startsWith("~/") ? path.join(os.homedir(), stepCwd.slice(1)) : void 0;
+  const requested = home ?? (stepCwd ? path.resolve(input.cwd, stepCwd) : input.cwd);
+  let cwd;
+  try {
+    cwd = fs.realpathSync(requested);
+  } catch (error) {
+    throw new Error(`Machine 'local' cwd does not exist: ${requested}.`, { cause: error });
+  }
+  if (!fs.statSync(cwd).isDirectory()) throw new Error(`Machine 'local' cwd is not a directory: ${requested}.`);
+  const machine = { provider: "rex", id: REX_LOCAL_MACHINE, session, cwd };
+  if (server) machine.server = server;
+  return machine;
+}
+
+// src/runs/shared/herdr-connection.ts
+import { spawn, spawnSync as spawnSync2 } from "node:child_process";
+import * as fs2 from "node:fs";
+import * as net from "node:net";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
 var MAX_DISCOVERY_BYTES = 256 * 1024;
 var MAX_RPC_BYTES = 4 * 1024 * 1024;
 var SUBSCRIPTION_ACK_TIMEOUT_MS = 15e3;
@@ -52,11 +121,14 @@ function sshEnvCommand(session, command) {
   return `/usr/bin/env -u HERDR_SOCKET_PATH -u HERDR_SESSION${assignment} ${remoteShellCommand(command)}`;
 }
 function runHerdrRemoteCommand(machine, command, options = {}) {
-  return spawnSync(options.sshBin ?? "ssh", [...herdrSshArgs(options.env), machine.target, command], { encoding: "utf8", env: hardenedSshEnv(options.env), timeout: options.timeout ?? 15e3, maxBuffer: options.maxBuffer ?? MAX_DISCOVERY_BYTES, windowsHide: true });
+  return spawnSync2(options.sshBin ?? "ssh", [...herdrSshArgs(options.env), machine.target, command], { encoding: "utf8", env: hardenedSshEnv(options.env), timeout: options.timeout ?? 15e3, maxBuffer: options.maxBuffer ?? MAX_DISCOVERY_BYTES, windowsHide: true });
 }
 function runHerdrRemoteCommandAsync(machine, command, options = {}) {
-  return new Promise((resolve) => {
-    const child = spawn(options.sshBin ?? "ssh", [...herdrSshArgs(options.env), machine.target, command], { env: hardenedSshEnv(options.env), stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+  return runBoundedCommand(options.sshBin ?? "ssh", [...herdrSshArgs(options.env), machine.target, command], { env: hardenedSshEnv(options.env), timeout: options.timeout, maxBuffer: options.maxBuffer });
+}
+function runBoundedCommand(file, args, options) {
+  return new Promise((resolve2) => {
+    const child = spawn(file, args, { env: options.env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
     const stdout = [], stderr = [], maxBuffer = options.maxBuffer ?? MAX_DISCOVERY_BYTES;
     let stdoutBytes = 0, stderrBytes = 0, error, settled = false, escalation;
     const finish = (status, spawnError = error) => {
@@ -64,7 +136,7 @@ function runHerdrRemoteCommandAsync(machine, command, options = {}) {
       settled = true;
       clearTimeout(timer);
       if (escalation) clearTimeout(escalation);
-      resolve({ status, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8"), ...spawnError ? { error: spawnError } : {} });
+      resolve2({ status, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8"), ...spawnError ? { error: spawnError } : {} });
     };
     const terminate = () => {
       child.kill("SIGTERM");
@@ -100,7 +172,7 @@ function parseHerdrEndpoint(value, expectedSession) {
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Remote Herdr endpoint discovery returned no endpoint.");
   const p = parsed;
-  if (typeof p.socket !== "string" || !path.posix.isAbsolute(p.socket) || typeof p.version !== "string" || typeof p.protocol !== "number") throw new Error("Remote Herdr endpoint discovery returned incomplete identity.");
+  if (typeof p.socket !== "string" || !path2.posix.isAbsolute(p.socket) || typeof p.version !== "string" || typeof p.protocol !== "number") throw new Error("Remote Herdr endpoint discovery returned incomplete identity.");
   const session = canonicalHerdrSession(typeof p.session === "string" ? p.session : null), expected = canonicalHerdrSession(expectedSession);
   if (expected !== session) throw new Error(`Remote Herdr session identity mismatch: expected ${expected ?? "default"}, received ${session ?? "default"}.`);
   if (p.running !== true || p.compatible !== true || p.endpoint_compatible === false) throw new Error("The selected remote Herdr session is stopped or incompatible.");
@@ -122,7 +194,7 @@ var SocketRpcClient = class {
     this.#subscriptionAckTimeoutMs = subscriptionAckTimeoutMs;
   }
   call(method, params = {}, timeoutMs = 15e3) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const socket = net.createConnection(this.#socketPath);
       let bytes = 0;
       let data = Buffer.alloc(0);
@@ -135,7 +207,7 @@ var SocketRpcClient = class {
         finished = true;
         clearTimeout(timer);
         socket.destroy();
-        error ? reject(error) : resolve(value);
+        error ? reject(error) : resolve2(value);
       };
       socket.on("connect", () => socket.write(`${JSON.stringify({ id, method, params })}
 `));
@@ -172,8 +244,8 @@ var SocketRpcClient = class {
     const id = String(++this.#next);
     let buffer = Buffer.alloc(0), bytes = 0, acknowledged = false, intentional = false, notified = false, settled = false;
     let resolveAck, rejectAck;
-    const acknowledgement = new Promise((resolve, reject) => {
-      resolveAck = resolve;
+    const acknowledgement = new Promise((resolve2, reject) => {
+      resolveAck = resolve2;
       rejectAck = reject;
     });
     const failHandshake = (error) => {
@@ -260,19 +332,19 @@ async function waitForSocket(socketPath, child) {
   for (let attempt = 0; attempt < 100; attempt++) {
     if (child.exitCode !== null) throw new Error(`SSH StreamLocal forwarding exited with code ${child.exitCode}.`);
     try {
-      const stat = fs.lstatSync(socketPath);
+      const stat = fs2.lstatSync(socketPath);
       if (stat.isSocket()) {
-        fs.chmodSync(socketPath, 384);
+        fs2.chmodSync(socketPath, 384);
         return;
       }
     } catch {
     }
-    await new Promise((resolve) => setTimeout(resolve, 25));
+    await new Promise((resolve2) => setTimeout(resolve2, 25));
   }
   throw new Error("SSH StreamLocal forwarding did not create its local socket.");
 }
 async function terminateChild(child) {
-  const wait = (ms) => child.exitCode !== null || child.signalCode !== null ? Promise.resolve() : Promise.race([new Promise((resolve) => child.once("exit", () => resolve())), new Promise((resolve) => setTimeout(resolve, ms))]);
+  const wait = (ms) => child.exitCode !== null || child.signalCode !== null ? Promise.resolve() : Promise.race([new Promise((resolve2) => child.once("exit", () => resolve2())), new Promise((resolve2) => setTimeout(resolve2, ms))]);
   if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
   await wait(1e3);
   if (child.exitCode === null && child.signalCode === null) {
@@ -280,22 +352,20 @@ async function terminateChild(child) {
     await wait(1e3);
   }
 }
-async function connectHerdrMachine(machine, options = {}) {
-  if (process.platform === "win32") throw new Error("Pane-native Herdr placement requires OpenSSH StreamLocal forwarding and is not supported on Windows.");
-  const endpoint = await discoverHerdrEndpoint(machine, options);
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-herdr-"));
-  fs.chmodSync(dir, 448);
+function openSshSockets(machine, options) {
+  const dir = fs2.mkdtempSync(path2.join(os2.tmpdir(), "pi-subagents-herdr-"));
+  fs2.chmodSync(dir, 448);
   const children = /* @__PURE__ */ new Set();
   const forward = async (remotePath, name) => {
-    if (!path.posix.isAbsolute(remotePath)) throw new Error("Remote socket path must be absolute.");
-    const local = path.join(dir, `${name}.sock`);
+    if (!path2.posix.isAbsolute(remotePath)) throw new Error("Remote socket path must be absolute.");
+    const local = path2.join(dir, `${name}.sock`);
     const child = spawn(options.sshBin ?? "ssh", [...herdrSshArgs(options.env), "-N", "-o", "StreamLocalBindUnlink=yes", "-L", `${local}:${remotePath}`, machine.target], { env: hardenedSshEnv(options.env), stdio: "ignore", windowsHide: true });
     children.add(child);
     const stop = async () => {
       await terminateChild(child);
       children.delete(child);
       try {
-        fs.rmSync(local, { force: true });
+        fs2.rmSync(local, { force: true });
       } catch {
       }
     };
@@ -307,20 +377,40 @@ async function connectHerdrMachine(machine, options = {}) {
     }
     return { socketPath: local, close: stop };
   };
-  const primary = await forward(endpoint.socket, "herdr").catch((error) => {
-    fs.rmSync(dir, { recursive: true, force: true });
-    throw error;
-  });
-  return { endpoint, socketPath: primary.socketPath, client: new SocketRpcClient(primary.socketPath), forwardRemoteSocket: forward, close: async () => {
+  return { forwardRemoteSocket: forward, close: async () => {
     await Promise.all([...children].map(terminateChild));
     children.clear();
-    fs.rmSync(dir, { recursive: true, force: true });
+    fs2.rmSync(dir, { recursive: true, force: true });
   } };
 }
+function sshMachineAccess(machine, options = {}) {
+  return { shellCommand: remoteShellCommand, run: (command, limits = {}) => runHerdrRemoteCommand(machine, command, { ...options, ...limits }), runAsync: (command, limits = {}) => runHerdrRemoteCommandAsync(machine, command, { ...options, ...limits }), openSockets: () => openSshSockets(machine, options) };
+}
+async function connectHerdrMachine(machine, options = {}) {
+  if (process.platform === "win32") throw new Error("Pane-native Herdr placement requires OpenSSH StreamLocal forwarding and is not supported on Windows.");
+  const endpoint = await discoverHerdrEndpoint(machine, options);
+  const sockets = sshMachineAccess(machine, options).openSockets();
+  const primary = await sockets.forwardRemoteSocket(endpoint.socket, "herdr").catch(async (error) => {
+    await sockets.close();
+    throw error;
+  });
+  return { endpoint, socketPath: primary.socketPath, client: new SocketRpcClient(primary.socketPath), forwardRemoteSocket: sockets.forwardRemoteSocket, close: sockets.close };
+}
 
 export {
   remoteShellCommand,
-  runHerdrRemoteCommand,
-  runHerdrRemoteCommandAsync,
-  connectHerdrMachine
+  runBoundedCommand,
+  sshMachineAccess,
+  connectHerdrMachine,
+  REX_LOCAL_MACHINE,
+  REX_EXIT_GONE,
+  REX_EXIT_UNREACHABLE,
+  isRexLocalMachine,
+  REX_BUNDLE_BIN,
+  REX_CALL_TIMEOUT_MS,
+  REX_MAX_OUTPUT,
+  rexGlobalArgs,
+  resolveRexBinary,
+  rexCommandEnv,
+  resolveRexLocalPlacement
 };

package/bundle/{chunk-V6MR5TOQ.js → chunk-SIJ4S3EN.js}

@@ -1,23 +1,26 @@
 import {
   rewriteSubagentPrompt
-} from "./chunk-L5ZHE4L4.js";
+} from "./chunk-GC4DSPMH.js";
 import {
   package_default
-} from "./chunk-2XYWN7QJ.js";
-import "./chunk-BPS2AGBZ.js";
+} from "./chunk-ZQGSDHL6.js";
+import "./chunk-W2SZ22EM.js";
 import {
   MODEL_ONLY_TOOL
-} from "./chunk-NNLASTQE.js";
+} from "./chunk-VH5OAWVG.js";
 import "./chunk-NF7IEKBH.js";
 import {
   appendAgentRefinementOverlay
-} from "./chunk-EYNJ6VL6.js";
-import "./chunk-VJHOELQP.js";
+} from "./chunk-PLCCBLPY.js";
+import "./chunk-NRQ75MGH.js";
 import "./chunk-NIXWDZZV.js";
-import "./chunk-ZP3HODFH.js";
+import "./chunk-XSWOTIA3.js";
 import "./chunk-7F6RKT6W.js";
+import {
+  assertNoToolModifierEntries
+} from "./chunk-4SDU2BZX.js";
 import "./chunk-CTPAE36Y.js";
-import "./chunk-3DC5KBVP.js";
+import "./chunk-5TYMSZX3.js";
 import {
   HERDR_PI_MAX_FRAME_BYTES,
   HERDR_PI_PROTOCOL,
@@ -34,7 +37,7 @@ import {
   discoverAgents,
   resolveExistingReadPaths,
   resolveSkills
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import "./chunk-5LFLVSTM.js";
 import "./chunk-YFCK7H2S.js";
 import "./chunk-Z7KVHQHL.js";
@@ -70,6 +73,7 @@ function resolveRemoteHerdrResources(cwd, resources, remoteDefaultTools = []) {
 ${skillPrompt}` : ""}${readPaths.length ? `
 
 [Read from: ${readPaths.join(", ")}]` : ""}`, { cwd, agentName: agent.name });
+  assertNoToolModifierEntries(agent.name, agent.tools ?? []);
   const denied = new Set(agent.excludeTools ?? []);
   const tools = (agent.tools === void 0 ? remoteDefaultTools : agent.tools).filter((tool) => !denied.has(tool) && (!resources.toolCeiling || resources.toolCeiling.includes(tool)));
   if (agent.tools === void 0 && !tools.length) throw new Error(`Remote agent '${agent.name}' resolved no default active tools within the inherited ceiling.`);
@@ -117,7 +121,6 @@ function registerHerdrPiBridge(pi) {
     client.write(encodeHerdrPiFrame(record));
   };
   const sessionId = (ctx) => ctx.sessionManager?.getSessionId?.();
-  const activeTools = (ctx) => ctx.getActiveTools?.() ?? [];
   pi.registerTool({
     name: "contact_supervisor",
     ...MODEL_ONLY_TOOL,
@@ -129,11 +132,11 @@ function registerHerdrPiBridge(pi) {
       const id = `sup_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
       send({ type: "supervisor-request", requestId: id, reason: input.reason, message: input.message?.slice(0, 65536) ?? "", ...input.interview !== void 0 ? { interview: input.interview } : {}, expectsReply: input.reason !== "progress_update", nativeSessionId });
       if (input.reason === "progress_update") {
-        await new Promise((resolve) => supervisor.set(id, { reason: input.reason, resolve }));
+        await new Promise((resolve, reject) => supervisor.set(id, { reason: input.reason, resolve, reject }));
         return { content: [{ type: "text", text: "Supervisor progress update queued." }], details: { delivered: true, requestId: id, reason: input.reason } };
       }
       const reason = input.reason;
-      const answer = await new Promise((resolve) => supervisor.set(id, { reason, resolve }));
+      const answer = await new Promise((resolve, reject) => supervisor.set(id, { reason, resolve, reject }));
       const details = { requestId: id, reason };
       if (reason === "interview_request") try {
         details.structuredReply = JSON.parse(answer.replace(/^```(?:json)?\s*|\s*```$/giu, ""));
@@ -162,7 +165,8 @@ ${answer}` }], details };
       const entry = request.supervisorId ? supervisor.get(request.supervisorId) : void 0;
       if (!entry) throw new Error("Unknown supervisor request.");
       supervisor.delete(request.supervisorId);
-      entry.resolve(request.text ?? "");
+      if (request.error !== void 0) entry.reject(new Error(request.error));
+      else entry.resolve(request.text ?? "");
     }
     send({ type: "control-ack", requestId, operation: request.operation, nativeSessionId });
   };
@@ -182,7 +186,7 @@ ${resolvedSystemPrompt}` } : void 0;
     nativeSessionId = sessionId(ctx);
     if (!nativeSessionId) throw new Error("Pane-native Pi bridge requires a persisted native session identity.");
     fs.writeFileSync(manifestPath, JSON.stringify({ protocol: HERDR_PI_PROTOCOL, packageVersion: package_default.version, runId, socketPath, nativeSessionId, pid: process.pid }), { mode: 384, flag: "wx" });
-    send({ type: "ready", packageVersion: package_default.version, nativeSessionId, sessionFile: ctx.sessionManager?.getSessionFile?.(), cwd: process.cwd(), tools: activeTools(ctx), model: ctx.model?.provider && ctx.model.id ? `${ctx.model.provider}/${ctx.model.id}` : void 0, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
+    send({ type: "ready", packageVersion: package_default.version, nativeSessionId, sessionFile: ctx.sessionManager?.getSessionFile?.(), cwd: process.cwd(), tools: pi.getActiveTools(), model: ctx.model?.provider && ctx.model.id ? `${ctx.model.provider}/${ctx.model.id}` : void 0, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
   });
   on("message_end", (event) => {
     const message = event.message;
@@ -233,11 +237,11 @@ ${resolvedSystemPrompt}` } : void 0;
             const invalidSkills = resources.skills !== void 0 && (!Array.isArray(resources.skills) || resources.skills.some((name) => typeof name !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(name)));
             const invalidReads = resources.reads !== void 0 && resources.reads !== false && (!Array.isArray(resources.reads) || resources.reads.some((name) => typeof name !== "string"));
             if (typeof resources.agent !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(resources.agent) || invalidSkills || invalidReads) throw new Error("Remote logical resource names are invalid.");
-            const resolved = resolveRemoteHerdrResources(process.cwd(), { agent: resources.agent, ...resources.skills ? { skills: resources.skills } : {}, ...resources.toolCeiling ? { toolCeiling: resources.toolCeiling } : {}, ...resources.reads !== void 0 ? { reads: resources.reads } : {} }, context ? activeTools(context) : []);
+            const resolved = resolveRemoteHerdrResources(process.cwd(), { agent: resources.agent, ...resources.skills ? { skills: resources.skills } : {}, ...resources.toolCeiling ? { toolCeiling: resources.toolCeiling } : {}, ...resources.reads !== void 0 ? { reads: resources.reads } : {} }, context ? pi.getActiveTools() : []);
             resolvedSystemPrompt = resolved.systemPrompt;
             resolvedContextPolicy = resolved;
-            pi.setActiveTools?.(resolved.tools);
-            const acknowledged = context ? activeTools(context) : [];
+            pi.setActiveTools(resolved.tools);
+            const acknowledged = context ? pi.getActiveTools() : [];
             if (acknowledged.some((tool) => !resolved.tools.includes(tool)) || resolved.tools.some((tool) => !acknowledged.includes(tool))) throw new Error("Remote Pi did not apply the resolved active-tool set exactly.");
             configured = true;
             send({ type: "configured", requestId: frame.requestId, nativeSessionId, agent: resolved.agent, skills: resolved.skills, model: context?.model?.provider && context.model.id ? `${context.model.provider}/${context.model.id}` : void 0, tools: acknowledged });
@@ -248,7 +252,9 @@ ${resolvedSystemPrompt}` } : void 0;
           if (!["prompt", "steer", "follow-up", "abort", "supervisor-reply"].includes(operation)) throw new Error("Unsupported bridge operation.");
           const text = frame.text;
           if (text !== void 0 && (typeof text !== "string" || Buffer.byteLength(text) > 256 * 1024)) throw new Error("Bridge request text is invalid or too large.");
-          pending.set(frame.requestId, { operation, ...text !== void 0 ? { text } : {}, ...typeof frame.supervisorId === "string" ? { supervisorId: frame.supervisorId } : {} });
+          const error = frame.error;
+          if (error !== void 0 && (operation !== "supervisor-reply" || typeof error !== "string" || Buffer.byteLength(error) > 256 * 1024)) throw new Error("Bridge supervisor error is invalid or too large.");
+          pending.set(frame.requestId, { operation, ...text !== void 0 ? { text } : {}, ...typeof frame.supervisorId === "string" ? { supervisorId: frame.supervisorId } : {}, ...error !== void 0 ? { error } : {} });
           send({ type: "prepared", requestId: frame.requestId, nativeSessionId });
         }
       } catch (error) {
@@ -258,7 +264,7 @@ ${resolvedSystemPrompt}` } : void 0;
     socket.on("close", () => {
       if (client === socket) client = void 0;
     });
-    if (context && nativeSessionId) send({ type: "ready", packageVersion: package_default.version, nativeSessionId, sessionFile: context.sessionManager?.getSessionFile?.(), cwd: process.cwd(), tools: activeTools(context), model: context.model?.provider && context.model.id ? `${context.model.provider}/${context.model.id}` : void 0, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
+    if (context && nativeSessionId) send({ type: "ready", packageVersion: package_default.version, nativeSessionId, sessionFile: context.sessionManager?.getSessionFile?.(), cwd: process.cwd(), tools: pi.getActiveTools(), model: context.model?.provider && context.model.id ? `${context.model.provider}/${context.model.id}` : void 0, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
   });
   server.listen(socketPath, () => {
     fs.chmodSync(socketPath, 384);

package/bundle/{chunk-NNLASTQE.js → chunk-VH5OAWVG.js}

@@ -39,10 +39,10 @@ import {
   validateModelResponseAliases,
   withWorkflowChildRunModel,
   withWorktreeTransaction
-} from "./chunk-VJHOELQP.js";
+} from "./chunk-NRQ75MGH.js";
 import {
   validateIntercomBridgeConfig
-} from "./chunk-ZP3HODFH.js";
+} from "./chunk-XSWOTIA3.js";
 import {
   stableJsonDigest
 } from "./chunk-7F6RKT6W.js";
@@ -73,7 +73,7 @@ import {
   validateToolBudgetConfig,
   waitForFileSystemRetry,
   writeAtomicJson
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   DIRS,
   RUNNER_LAUNCHER_NAME_PATTERN,
@@ -2133,6 +2133,7 @@ function isAsyncStatusIsolationError(asyncDir, error) {
   const message = getErrorMessage(error);
   return /^(?:Failed to (?:inspect|read|parse|validate) async status file|Invalid async status file) '/.test(message) || message.startsWith(`Invalid async status '${statusPath}'`) || message.startsWith(`Invalid host step '${statusPath}`) || /^(workflowChildren|Invalid workflowChildren)/.test(message);
 }
+var reportedCorruptStatus = /* @__PURE__ */ new Map();
 function isolateCorruptActiveRun(asyncDir, runId, error, now) {
   const statusPath = path3.join(asyncDir, "status.json");
   const processTerminal = readProcessTerminal(asyncDir, { runId });
@@ -2152,7 +2153,18 @@ function isolateCorruptActiveRun(asyncDir, runId, error, now) {
       markerAction = `failed to release active marker: ${getErrorMessage(releaseError)}`;
     }
   }
-  console.error(`[pi-subagents] Skipping corrupt active async run '${runId}' at '${statusPath}': ${getErrorMessage(error)}; ${markerAction}.`);
+  const line = `[pi-subagents] Skipping corrupt active async run '${runId}' at '${statusPath}': ${getErrorMessage(error)}; ${markerAction}.`;
+  let fileSignature = "";
+  try {
+    const stat = fs3.statSync(statusPath);
+    fileSignature = `${stat.size}:${stat.mtimeMs}`;
+  } catch {
+  }
+  const signature = `${fileSignature}
+${line}`;
+  if (reportedCorruptStatus.get(statusPath) === signature) return;
+  reportedCorruptStatus.set(statusPath, signature);
+  console.error(line);
 }
 function isNotFoundError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -2467,14 +2479,16 @@ function listAsyncRuns(asyncDirRoot, options = {}, observeStatus) {
     const asyncDir = path3.join(asyncDirRoot, entry);
     let status;
     try {
+      let owned = false;
       if (owners) {
         const stored = readStatus(asyncDir);
         if (stored && !owners.has(stored.sessionId)) {
           observeStatus?.(stored);
           continue;
         }
+        owned = stored !== null;
       }
-      const reconciliation = options.reconcile === false ? void 0 : reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now }, observeStatus);
+      const reconciliation = options.reconcile === false ? void 0 : reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now, adoptCompletionOwnerId: owned ? options.adoptCompletionOwnerId : void 0 }, observeStatus);
       status = reconciliation?.status ?? readStatus(asyncDir);
       if (options.reconcile === false) observeStatus?.(status);
     } catch (error) {