pi-subagents 0.80.0 → 0.82.0

package/CHANGELOG.md

@@ -2,6 +2,72 @@
 
 ## [Unreleased]
 
+## [0.82.0] - 2026-10-24
+
+### Highlights
+
+- Background workflows cut off by Pi crashing, quitting or reloading resume where they stopped when you reopen their session, without running finished steps again.
+- Background runs that finished while Pi was closed report their results when you reopen their session, and a foreground run cut off by a crash can be resumed by id.
+- Pi children can run in their own Rex terminal tabs, on this Mac or on another Mac over SSH.
+- After a machine restart, runs that died with it no longer show as running or hold a capacity slot.
+- `/subagents-fleet` shows each child's task next to its agent name, so children of one run are easy to tell apart.
+
+### Added
+
+- Background workflows cut off by Pi exiting, crashing or reloading now resume on their own when you reopen or reload their session within a day, and steps that already finished are not run again. You can also resume one yourself with `subagent({ action: "resume", id })`, or set `autoResume: false` to resume them only by hand. A stopped workflow is resumed only once, and its notice says how it resumed. If you start a new Pi in the same folder instead, it tells you which session to reopen. See [docs/workflows.md](docs/workflows.md).
+- `machine: "local"` runs a native Pi child in a new background tab of your own Rex session, with the same controls as a Herdr-placed Pi child: prompts, steering, follow-ups, abort, `contact_supervisor` and results. The launch fails if the parent Pi is not running inside Rex, and Claude Code, Codex, Cursor and generic `external-cli` agents are rejected. A finished child's tab stays open until you close it; an aborted or stopped child's tab is closed. See [docs/agents.md](docs/agents.md#running-a-pi-child-in-a-rex-pane-on-this-machine).
+- A native Pi child can also run in a Rex tab on another Mac over SSH. Name the Mac in your user settings with `subagents.machines.<name>.rex.ssh`, then pass `machine: "<name>"`. The child opens in that Mac's `subagents` Rex session, which is created the first time it is needed. These machines do not need Herdr, and project settings cannot name a Rex host. See [docs/agents.md](docs/agents.md#running-a-pi-child-in-a-rex-pane-on-another-mac).
+
+### Changed
+
+- Each background child's row in `/subagents-fleet` now shows its task after the agent name, for example `worker · Fix two Cycode Python SAST findings…`, so you can tell children of one run apart without opening each one. The selected child's header still shows the run id. Thanks to [@MattDavisRV](https://github.com/MattDavisRV) for #3020.
+
+### Fixed
+
+- A background run that was still working when Pi exited or crashed never reported its result, even after you reopened its session. Its result now shows once in the reopened session: right away if the run already finished, or as soon as it finishes.
+- A foreground single run cut off by a Pi crash can now be resumed by id. It used to be recorded only when it ended, so nothing pointed to its transcript. It is now recorded when it starts, shows as `interrupted when Pi exited · resume <id>` when its session reopens, and `subagent({ action: "resume", id, message })` continues it from its transcript. Foreground runs remembered by earlier versions are not carried over and can no longer be resumed by id.
+- After Pi crashed or was killed while an async workflow ran, relaunching the same workflow ran every child again. The workflow is now marked `stopCause: "owner-exited"` when its session reopens, or when `options.reuseFrom` names it from another session, and a relaunch reuses the children that already finished, the same as after `/reload`. Its failed result says the Pi process exited. See [docs/workflows.md](docs/workflows.md).
+- A workflow relaunched more than once could start a second copy of a child that was still running, or run a finished child again. A relaunch only looked at the run it reused, and that run had no record of children still waiting for a concurrency slot when it stopped. A relaunch now looks at every earlier run in its relaunch chain and takes each child from the newest run that recorded it. Thanks to [@wireknight](https://github.com/wireknight) for the report on #3021.
+- After a machine restart, a background run or workflow that died with the machine could show as running, and hold its capacity slot, for up to a day, because its old process id could now belong to another process. On Linux and macOS, Pi now saves a boot id next to each process id and treats a process id from an earlier boot as dead. Runs started through a `launcher` are unchanged.
+- A background child awaited by an `async: false` workflow now gets an immediate `contact_supervisor` tool error when it asks a question, because its blocked parent cannot answer. The error tells it to report partial results or use an async workflow. Before, the question could wait until the run deadline and reach the parent after the child had timed out. Async workflows and children that are not awaited still get normal supervisor replies. Thanks to [@XLi-hub](https://github.com/XLi-hub) for #3028 and [@isjiajia01](https://github.com/isjiajia01) for the report in #3018.
+- Agents called `bg_wait` in a loop when it returned early because a run that was still working needed attention, such as a long `bash` command or a quiet stretch. The result now says the run is still running and that `stopOnAttention: false` waits through this, and the option's description says it still stops for supervisor requests. Thanks to [@jettoblack](https://github.com/jettoblack) for #3019.
+- A quoted name in an agent's `tools`, `excludeTools`, `mutationTools`, `extensions` or `subagentOnlyExtensions` list, such as `tools: "read", "bash"` or a `- "read"` list item, is no longer read with its quote marks. A quoted tool name made the child fail to start, and a quoted extension path pointed at a file that doesn't exist. Thanks to [@HerbertGao](https://github.com/HerbertGao) for #3017.
+- An agent whose `tools` list has a Pi `+name` or `-name` entry, such as `tools: +codemode`, now fails before launch with an error that names the agent and the entry. Before, the entry was kept as a literal tool name, so the child required a tool named `+codemode` that no child has, and adding `read` for skills, MCP tools or `structured_output` produced a list that Pi rejects. A Herdr- or Rex-placed child whose agent definition on that machine has such an entry fails the same way before its first prompt. `tools` is a complete list: name every tool the child needs, or omit `tools` and use `excludeTools` to drop one. See [docs/agents.md](docs/agents.md#tool-and-extension-selection). Thanks to [@Nyarlathoteppppp](https://github.com/Nyarlathoteppppp) for #3029.
+- A host-required child extension (`registerRequiredChildExtensions`) is now recognized when Pi loads it through another spelling of its path, such as a symlink, a different letter case, or a path with a Unicode space, so its load, provider-registration and startup failures still stop the launch. A required extension that Pi did not load at all now stops the launch instead of letting the child start without it. Thanks to [@pandalaohe](https://github.com/pandalaohe) for #3012.
+- A child agent's `MEMORY.md` that is a named pipe (FIFO) no longer stalls its launch while the prompt is built; it is skipped like any other file that is not a regular file. Thanks to [@XLi-hub](https://github.com/XLi-hub) for #3027.
+- Skill discovery no longer fails with `ENOTDIR` when a `settings.json` `packages` entry names a single extension file. Thanks to [@tara-marchand](https://github.com/tara-marchand) for #3011.
+- Herdr-placed native Pi children no longer fail before their first prompt. The child's pane bridge looked for its active tools where Pi does not provide them, found none, and rejected every launch.
+- A corrupt saved run status or mission file no longer prints the same warning on every status refresh or retry. The warning prints once, and again only when the file or its outcome changes. The run is still skipped or retried as before, and the file is left as it is. Thanks to [@ozand](https://github.com/ozand) for #3037 and the report in #3036.
+- Updated `undici` from 8.10.2 to 8.12.3, outside the range of [GHSA-xjj6-f33q-929c](https://github.com/advisories/GHSA-xjj6-f33q-929c), so projects that install pi-subagents no longer fail `npm audit` because of it. Thanks to [@setanta00](https://github.com/setanta00) for #3022.
+
+## [0.81.0] - 2026-10-22
+
+### Highlights
+
+- Pi starts faster on Windows. pi-subagents now loads from about 30 files instead of about 240, which cut its load time from about 2.0 s to about 1.1 s on a Windows machine with Defender.
+- Pi no longer freezes for about 8 seconds on every Windows start when the subagent temp folder has broken permissions.
+- A child with an `outputSchema` that forgets to call `structured_output` gets one more turn to call it instead of failing and losing its work.
+- The parent model can tell subagent notices apart from text you typed.
+- In fullscreen FleetView you can click a child to select it and scroll its output with the mouse wheel or trackpad.
+
+### Added
+
+- In fullscreen mode, the FleetView inspector now selects a child when you click its roster row and scrolls the output pane with the mouse wheel or trackpad, without scrolling the conversation behind it. Keyboard controls are unchanged. Thanks to [@IdrisGit](https://github.com/IdrisGit) for #2992.
+- Structured delegation `:update` and `:response` events now carry an optional `providerDiagnostics` field, so a host extension can tell a child stuck in provider retry backoff (for example HTTP 429) from a long model turn. It reports the count and kind of failed requests and Pi's current retry phase, never the raw provider error. See [docs/extension-api.md](docs/extension-api.md). Thanks to [@IdrisGit](https://github.com/IdrisGit) for #2999 and [@legendtang](https://github.com/legendtang) for [#2991](https://github.com/nicobailon/pi-subagents/issues/2991).
+
+### Changed
+
+- A native Pi child with an `outputSchema` that ends its run without calling `structured_output` now gets one follow-up turn in the same session asking it to call `structured_output` without repeating the work. Before, the run failed at once with "Missing structured_output call" and all of the child's work was lost. If the child still does not call it, the run fails with the same error as before. The extra turn counts toward the run's usage and is still bounded by the run's timeout. A call that `structured_output` rejects does not get this turn, because the tool already returns the validation error to the child. Thanks to [@legendtang](https://github.com/legendtang) for [#2997](https://github.com/nicobailon/pi-subagents/issues/2997).
+- When the `parallel` workflow's args or tasks, a `tasks` item, or a chain step include `worktree` or another setting that only works for the whole call, the error now says to put it on the `subagent` call itself, where it applies to every child. The tool description is unchanged, so ordinary requests use no extra tokens. Thanks to [@jinglebiscuits](https://github.com/jinglebiscuits) for [#3009](https://github.com/nicobailon/pi-subagents/issues/3009) and #3010.
+
+### Fixed
+
+- Loading pi-subagents at Pi startup took 0.3 to 2.7 s on Windows, because Pi loaded about 240 separate files and Windows security software scanned each one. The npm package now ships the extension and its subpath exports as a bundle of about 30 files. On a Windows machine with Defender, loading drops from about 2.0 s to about 1.1 s; on macOS it is about 8% faster. Child processes still run from the unbundled files, and the subagent executor still loads after startup. The unpacked package grows from 6.9 MB to 10.8 MB. Thanks to [@kiote](https://github.com/kiote) for #3006, and to [@tututuhehehe](https://github.com/tututuhehehe) and [@localhedge](https://github.com/localhedge) for the measurements in [#2980](https://github.com/nicobailon/pi-subagents/issues/2980).
+- On Windows, Pi could freeze for about 8 seconds on every start when the subagent temp results folder had broken permissions (`EPERM`/`EACCES`), because the startup check kept retrying before it switched to a fallback folder. The startup check now gives up after at most 85 ms per operation; result writes and other file operations keep their full retries. Thanks to [@821869798](https://github.com/821869798) for [#2998](https://github.com/nicobailon/pi-subagents/issues/2998).
+- The parent model can now tell subagent notices from text you typed. Pi sends extension messages to the model as ordinary user messages, so a completion notice that started a turn on its own looked like a user request. pi-subagents notices the model sees, including completion and supervisor notices, wait results and `/run` results, are now wrapped in a `<pi_subagents_notice>` tag that names the message type and says it is an automated message from pi-subagents. Only the model request changes; the stored transcript and the chat view stay the same. Thanks to [@ktheunlikedoll](https://github.com/ktheunlikedoll) for [#2994](https://github.com/nicobailon/pi-subagents/issues/2994) and [@isjiajia01](https://github.com/isjiajia01) for the context-hook approach.
+- YAML comments in agent frontmatter lists changed the parsed values. An indented `# note` in a `tools:` list became a tool name, a column-zero comment dropped every item after it, and a trailing `# why` stayed on a `- item` line. Comments are now ignored in frontmatter lists; `#` inside quoted values and `|`/`>` block scalars is kept. Thanks to [@builtroller](https://github.com/builtroller) for [#2995](https://github.com/nicobailon/pi-subagents/issues/2995).
+- When a workflow child's process died without writing a result, `mission.show` listed that child as failed in the mission's runs but still running in its workflow children. The failed result recorded for the dead child now keeps its workflow id and key, so the mission marks it failed in both places. Thanks to [@isjiajia01](https://github.com/isjiajia01) for [#3005](https://github.com/nicobailon/pi-subagents/issues/3005).
+
 ## [0.80.0] - 2026-10-21
 
 ### Highlights

package/bundle/agents.js

@@ -0,0 +1,18 @@
+import {
+  RUNTIME_AGENT_REGISTER_EVENT,
+  RUNTIME_AGENT_REGISTER_VERSION,
+  registerAgentViaEvents
+} from "./chunk-43SCHIMD.js";
+import {
+  registerRuntimeAgent
+} from "./chunk-YKEWIB4M.js";
+import "./chunk-CIZQXJ5Q.js";
+import "./chunk-5LFLVSTM.js";
+import "./chunk-YFCK7H2S.js";
+import "./chunk-Z7KVHQHL.js";
+export {
+  RUNTIME_AGENT_REGISTER_EVENT,
+  RUNTIME_AGENT_REGISTER_VERSION,
+  registerRuntimeAgent as registerAgent,
+  registerAgentViaEvents
+};

package/bundle/background-work.js

@@ -0,0 +1,16 @@
+import {
+  BACKGROUND_WORK_PROTOCOL_VERSION,
+  BACKGROUND_WORK_REGISTRY_KEY,
+  listBackgroundWorkProviders,
+  listBackgroundWorkWakeChannels,
+  registerBackgroundWorkProvider,
+  snapshotBackgroundWork
+} from "./chunk-N2BN7BF5.js";
+export {
+  BACKGROUND_WORK_PROTOCOL_VERSION,
+  BACKGROUND_WORK_REGISTRY_KEY,
+  listBackgroundWorkProviders,
+  listBackgroundWorkWakeChannels,
+  registerBackgroundWorkProvider,
+  snapshotBackgroundWork
+};

package/bundle/capability-ceiling.js

@@ -0,0 +1,22 @@
+import {
+  SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY,
+  SUBAGENT_CAPABILITY_CEILING_VERSION,
+  decodeSubagentCapabilityCeiling,
+  encodeSubagentCapabilityCeiling,
+  intersectSubagentCapabilityCeilings,
+  parseSubagentCapabilityCeiling,
+  registerSubagentCapabilityCeiling,
+  resolveCurrentSubagentCapabilityCeiling,
+  resolveSubagentCapabilityCeiling
+} from "./chunk-Z7KVHQHL.js";
+export {
+  SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY,
+  SUBAGENT_CAPABILITY_CEILING_VERSION,
+  decodeSubagentCapabilityCeiling,
+  encodeSubagentCapabilityCeiling,
+  intersectSubagentCapabilityCeilings,
+  parseSubagentCapabilityCeiling,
+  registerSubagentCapabilityCeiling,
+  resolveCurrentSubagentCapabilityCeiling,
+  resolveSubagentCapabilityCeiling
+};

package/bundle/child-tool-plan.js

@@ -0,0 +1,11 @@
+import {
+  resolvePiLaunchToolPlan
+} from "./chunk-4SDU2BZX.js";
+import "./chunk-CTPAE36Y.js";
+import "./chunk-CIZQXJ5Q.js";
+import "./chunk-5LFLVSTM.js";
+import "./chunk-YFCK7H2S.js";
+import "./chunk-Z7KVHQHL.js";
+export {
+  resolvePiLaunchToolPlan
+};

package/bundle/chunk-43SCHIMD.js

@@ -0,0 +1,57 @@
+import {
+  registerRuntimeAgent
+} from "./chunk-YKEWIB4M.js";
+
+// src/agents/runtime-agent-events.ts
+var RUNTIME_AGENT_REGISTER_EVENT = "pi-subagents:runtime-agent-register:v1";
+var RUNTIME_AGENT_REGISTER_VERSION = 1;
+function errorFrom(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function registerAgentViaEvents(input) {
+  const request = {
+    version: RUNTIME_AGENT_REGISTER_VERSION,
+    name: input.name,
+    definition: input.definition
+  };
+  input.pi.events.emit(RUNTIME_AGENT_REGISTER_EVENT, request);
+  const result = request.result;
+  if (result === void 0) {
+    throw new Error("pi-subagents is not installed, not ready, or does not support runtime agent event registration.");
+  }
+  if (result && typeof result === "object" && !Array.isArray(result)) {
+    const candidate = result;
+    if (candidate.ok === true && candidate.registration && typeof candidate.registration === "object" && typeof candidate.registration.dispose === "function") {
+      return candidate.registration;
+    }
+    if (candidate.ok === false && candidate.error instanceof Error) throw candidate.error;
+  }
+  throw new Error("pi-subagents returned a malformed runtime agent registration result.");
+}
+function registerRuntimeAgentEventListener(pi) {
+  return pi.events.on(RUNTIME_AGENT_REGISTER_EVENT, (rawRequest) => {
+    if (!rawRequest || typeof rawRequest !== "object" || Array.isArray(rawRequest)) return;
+    const request = rawRequest;
+    if (request.result !== void 0) return;
+    try {
+      if (request.version !== RUNTIME_AGENT_REGISTER_VERSION) {
+        throw new Error(`Unsupported runtime agent registration event version '${String(request.version)}'.`);
+      }
+      const registration = registerRuntimeAgent({
+        pi,
+        name: request.name,
+        definition: request.definition
+      });
+      request.result = { ok: true, registration };
+    } catch (error) {
+      request.result = { ok: false, error: errorFrom(error) };
+    }
+  });
+}
+
+export {
+  RUNTIME_AGENT_REGISTER_EVENT,
+  RUNTIME_AGENT_REGISTER_VERSION,
+  registerAgentViaEvents,
+  registerRuntimeAgentEventListener
+};

package/bundle/chunk-4QFZZV3O.js

@@ -0,0 +1,57 @@
+// src/runs/shared/herdr-pi-protocol.ts
+var HERDR_PI_PROTOCOL = 1;
+var HERDR_PI_MAX_FRAME_BYTES = 1024 * 1024;
+var HERDR_PI_MODE_ENV = "PI_SUBAGENTS_HERDR_BRIDGE";
+var HERDR_PI_RUN_ENV = "PI_SUBAGENTS_HERDR_RUN_ID";
+var HERDR_PI_RUNTIME_DIR_ENV = "PI_SUBAGENTS_HERDR_RUNTIME_DIR";
+var SAFE_ID = /^[A-Za-z0-9_-]{8,96}$/u;
+function validateHerdrPiRunId(value) {
+  if (typeof value !== "string" || !SAFE_ID.test(value)) throw new Error("Herdr Pi bridge run identity is invalid.");
+  return value;
+}
+function encodeHerdrPiFrame(frame) {
+  const data = Buffer.from(`${JSON.stringify(frame)}
+`, "utf8");
+  if (data.byteLength > HERDR_PI_MAX_FRAME_BYTES) throw new Error(`Herdr Pi frame exceeds ${HERDR_PI_MAX_FRAME_BYTES} bytes.`);
+  return data;
+}
+var HerdrPiFrameDecoder = class {
+  #buffer = Buffer.alloc(0);
+  push(chunk) {
+    this.#buffer = Buffer.concat([this.#buffer, chunk]);
+    if (this.#buffer.byteLength > HERDR_PI_MAX_FRAME_BYTES) throw new Error(`Herdr Pi frame exceeds ${HERDR_PI_MAX_FRAME_BYTES} bytes.`);
+    const frames = [];
+    for (; ; ) {
+      const newline = this.#buffer.indexOf(10);
+      if (newline < 0) break;
+      const line = this.#buffer.subarray(0, newline);
+      this.#buffer = this.#buffer.subarray(newline + 1);
+      let value;
+      try {
+        value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(line));
+      } catch {
+        throw new Error("Herdr Pi bridge emitted malformed JSON or UTF-8.");
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Herdr Pi bridge frame must be an object.");
+      const frame = value;
+      if (frame.protocol !== HERDR_PI_PROTOCOL || typeof frame.type !== "string") throw new Error("Herdr Pi bridge protocol mismatch.");
+      validateHerdrPiRunId(frame.runId);
+      frames.push(frame);
+    }
+    return frames;
+  }
+  end() {
+    if (this.#buffer.byteLength) throw new Error("Herdr Pi bridge ended with a partial frame.");
+  }
+};
+
+export {
+  HERDR_PI_PROTOCOL,
+  HERDR_PI_MAX_FRAME_BYTES,
+  HERDR_PI_MODE_ENV,
+  HERDR_PI_RUN_ENV,
+  HERDR_PI_RUNTIME_DIR_ENV,
+  validateHerdrPiRunId,
+  encodeHerdrPiFrame,
+  HerdrPiFrameDecoder
+};