pi-subagents 0.81.0 → 0.82.0

package/bundle/{chunk-2XYWN7QJ.js → chunk-ZQGSDHL6.js}

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "pi-subagents",
-  version: "0.81.0",
+  version: "0.82.0",
   private: true,
   description: "Pi extension for single-agent delegation and scripted multi-agent workflows",
   author: "Nico Bailon",
@@ -106,7 +106,7 @@ var package_default = {
     "@js-temporal/polyfill": "0.5.1",
     acorn: "8.18.0",
     jiti: "2.7.0",
-    undici: "8.10.2",
+    undici: "8.12.3",
     yaml: "2.8.3"
   },
   devDependencies: {

package/bundle/control-channel.js

@@ -1,8 +1,8 @@
 import {
   requestAsyncStop
-} from "./chunk-BJN5LUQY.js";
+} from "./chunk-OYF6AFDY.js";
 import "./chunk-NIXWDZZV.js";
-import "./chunk-ZBC44JJ3.js";
+import "./chunk-CIZQXJ5Q.js";
 import "./chunk-5LFLVSTM.js";
 import "./chunk-YFCK7H2S.js";
 import "./chunk-Z7KVHQHL.js";

package/bundle/index.js

@@ -17,7 +17,7 @@ function readInstalledPackageVersion() {
 var loadedPackageVersion = readInstalledPackageVersion();
 
 // index.ts
-var registerExtension = process.env[HERDR_PI_MODE_ENV] === "1" ? (await import("./chunk-V6MR5TOQ.js")).default : process.env.PI_SUBAGENT_CHILD === "1" ? void 0 : (await import("./chunk-V3BIUPLU.js")).default;
+var registerExtension = process.env[HERDR_PI_MODE_ENV] === "1" ? (await import("./chunk-SIJ4S3EN.js")).default : process.env.PI_SUBAGENT_CHILD === "1" ? void 0 : (await import("./chunk-WVD4UEL4.js")).default;
 function registerSubagentExtension(pi) {
   const installedVersion = readInstalledPackageVersion();
   if (installedVersion !== loadedPackageVersion) {

package/bundle/intercom-bridge.js

@@ -1,8 +1,8 @@
 import {
   resolveIntercomSessionTarget
-} from "./chunk-ZP3HODFH.js";
+} from "./chunk-XSWOTIA3.js";
 import "./chunk-7F6RKT6W.js";
-import "./chunk-ZBC44JJ3.js";
+import "./chunk-CIZQXJ5Q.js";
 import "./chunk-5LFLVSTM.js";
 import "./chunk-YFCK7H2S.js";
 import "./chunk-Z7KVHQHL.js";

package/bundle/preflight.js

@@ -2,22 +2,22 @@ import {
   buildEffectiveSystemPrompt,
   canPreferForkFromSnapshot,
   resolveSubagentLaunchContext
-} from "./chunk-ARRKBB2B.js";
-import "./chunk-EYNJ6VL6.js";
+} from "./chunk-GJECHSAR.js";
+import "./chunk-PLCCBLPY.js";
 import {
   loadConfig
-} from "./chunk-WSBNENFS.js";
+} from "./chunk-NGGAFDL6.js";
 import {
   nestedResultsPath,
   processTerminalCandidatePath,
   processTerminalPath,
   resultFilePath
-} from "./chunk-VJHOELQP.js";
+} from "./chunk-NRQ75MGH.js";
 import {
   applyIntercomBridgeToAgent,
   resolveIntercomBridge,
   validateIntercomBridgeConfig
-} from "./chunk-ZP3HODFH.js";
+} from "./chunk-XSWOTIA3.js";
 import {
   AGENT_DEFINITION_PROJECTION_VERSION,
   resolveLaunchBinding,
@@ -26,7 +26,7 @@ import {
 import {
   applyThinkingSuffix,
   resolvePiLaunchToolPlan
-} from "./chunk-G5DKFLLI.js";
+} from "./chunk-4SDU2BZX.js";
 import {
   assertRequiredChildExtensionsAdmitted,
   resolveRequiredChildExtensions
@@ -34,7 +34,7 @@ import {
 import {
   getArtifactPaths,
   getArtifactsDir
-} from "./chunk-3DC5KBVP.js";
+} from "./chunk-5TYMSZX3.js";
 import {
   assertClaudeCodeModelScope,
   assertThinkingWithinCeiling,
@@ -61,7 +61,7 @@ import {
   resolveSkillsWithFallback,
   resolveStepBehavior,
   unknownAgentDiagnosticContext
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   DIRS,
   SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,

package/bundle/project-panes.js

@@ -8,10 +8,10 @@ import {
   openProjectPane,
   projectPaneBindingPath,
   readProjectPaneBinding
-} from "./chunk-V2JWDB5U.js";
+} from "./chunk-52UBALJL.js";
 import "./chunk-7J4ZXMY7.js";
-import "./chunk-3DC5KBVP.js";
-import "./chunk-ZBC44JJ3.js";
+import "./chunk-5TYMSZX3.js";
+import "./chunk-CIZQXJ5Q.js";
 import "./chunk-5LFLVSTM.js";
 import "./chunk-YFCK7H2S.js";
 import "./chunk-Z7KVHQHL.js";

package/docs/agents.md

@@ -282,6 +282,36 @@ Placed external profiles are one-shot and stop-only: they cannot steer, resume,
 
 pi-subagents never clones, pulls, or checks out on the machine. Generic `external-cli` commands and managed worktrees are rejected before launch; saved-machine placement accepts native Pi and only the six code-owned external profiles.
 
+## Running a Pi child in a Rex pane on this machine
+
+`machine: "local"` runs a native Pi child as a visible Pi in a new background tab of your own Rex session, labeled `subagent-<run id tail>`. It works wherever `machine` works: frontmatter, settings overrides, the `subagent` tool, workflow `runs.run`, chain, parallel, and dynamic-fanout steps. `local` is reserved and never looks in the Herdr catalog. The parent Pi must run inside Rex: with no `REX_SESSION`, or a session the Rex server does not confirm, the launch fails before anything starts.
+
+The parent drives the child through the same bridge as a Herdr-placed Pi: prompt, steer, follow-up, abort, `contact_supervisor`, and results. The child Pi loads pi-subagents from its own extensions, so it must be installed at the same version. `cwd` is a directory on this machine; a relative path joins the launch directory. pi-subagents finds `rex` in `$REX_BIN_DIR`, then on `PATH`, then in the Rex server app.
+
+A finished child keeps its tab open, with the idle Pi, until you close it; an aborted or stopped child's tab is closed. Limits: native Pi only (Claude Code, Codex, Cursor, and generic `external-cli` agents are rejected), fresh context only, and the same restrictions as a Herdr-placed Pi (no local extension paths, process environment, nested delegation, permission rules, or tool budgets).
+
+## Running a Pi child in a Rex pane on another Mac
+
+Name a Mac you reach over SSH in your user settings (`~/.pi/agent/settings.json`), with its repo root:
+
+```json
+{
+  "subagents": {
+    "machines": {
+      "workmac": { "rex": { "ssh": "100.82.67.118" }, "cwd": "~/dev/app" }
+    }
+  }
+}
+```
+
+`machine: "workmac"` then runs a native Pi child as a visible Pi in a new background tab of the Rex session labeled `subagents` on that Mac. pi-subagents creates the session the first time and reuses it after that; if two sessions there have that label, the launch fails until you close or rename one. Every `rex` command runs on that Mac over SSH, and the bridge socket comes back through an SSH forward, so SSH must work without a prompt (`ssh <target>` once to accept the host key). A name with a `rex` entry never looks in the Herdr catalog, so Herdr does not need to be installed.
+
+Only user settings may name a Rex host: a `rex` entry in a project's `.pi/settings.json` fails the launch, so a cloned repo cannot choose where a task runs. `cwd` can come from project or user settings, as for Herdr machines: a relative step `cwd` joins it, and an absolute or `~` path is used as given. The other Mac needs Rex, Pi on its login shell's `PATH`, and pi-subagents installed at the same version. The child edits that Mac's disk, so its changed files come from that Mac's Git state, as for a Herdr-placed child.
+
+Programs in a Rex tab run under the Rex app's macOS privacy permissions. If Pi on that Mac reads files in Desktop, Documents, or Downloads (for example a package path in its settings), allow Rex there first: open a Rex tab on that Mac, run `ls ~/Documents`, and accept the prompt. Until then Pi waits on the prompt and the launch times out.
+
+To watch the tab, open the `subagents` session in Rex on that Mac. To watch it from this Mac, add that Mac's Rex server to your hosts here once (`rex hosts add workmac <endpoint>`; after `rex server tailscale on` there, `rex whoami` on that Mac shows its Tailscale address). Tab lifecycle and limits are the same as for `machine: "local"`.
+
 ## Sandboxing background children with a launcher
 
 A launcher wraps an agent's background runner in a command you choose, so that agent can run in a different sandbox from the parent session. Define the command in the user config key [`runnerLaunchers`](configuration.md#runnerlaunchers), then name it in the agent file:
@@ -512,6 +542,7 @@ How `tools` behaves:
 - `tools` omitted: the child session gets Pi's normal builtin tools.
 - `tools` present: regular tool names become an explicit allowlist.
 - `tools:` empty: the child session gets no tools.
+- `tools: +codemode` or `tools: -write`: rejected. Pi's `--tools` and `defaultTools` accept `+name`/`-name` entries that edit the default tool set, but a child's `tools` list replaces that set, so name every tool the child needs, or omit `tools` and use `excludeTools` to drop one. A local agent with such an entry fails before launch. A Herdr- or Rex-placed child resolves its agent on that machine, so an entry only there fails when the pane bridge is configured, before the first prompt.
 - `allowNestedSubagents: true`: explicitly enables child-safe nested fanout without turning omitted `tools` into an allowlist. Depth and inherited capability ceilings still apply.
 - `allowedAgents: scout, reviewer`: if nesting is separately enabled, restricts this agent's descendant launches to those names. `allowedAgents:` denies all descendants and omission is unrestricted except for inherited/runtime policy.
 

package/docs/configuration.md

@@ -244,6 +244,14 @@ Set `enabled` to `false` (or remove the block) as a kill switch. In that state,
 
 Workflow script calls use background execution when the request omits `async`. Set `asyncByDefault` to `false` to restore foreground-by-default behavior for tool launches that still use the internal single-run primitive. Callers can still force foreground with `async: false` unless `forceTopLevelAsync` is enabled.
 
+## `autoResume`
+
+```json
+{ "autoResume": false }
+```
+
+Default `true`. When a session is reopened (`pi -c`, `pi --session`, `/resume`) or reloaded (`/reload`), its own async workflows that a Pi exit or a reload interrupted in the last 24 hours are resumed once, without delaying session start; set `autoResume` to `false` to resume them only by hand. A one-shot `pi -p` run does not auto-resume, so it does not wait on the workflow. See [Workflows](workflows.md).
+
 ## `runnerLaunchers`
 
 ```json
@@ -387,8 +395,8 @@ Adds a short `active_subagents` section to the parent's system prompt while this
 
 `defaultTimeoutMs` sets the blocking window used when a `bg_wait` call omits `timeoutMs`; explicit call values win, followed by this setting, then the 30-minute fallback. `bg_wait` is the only registered wait tool. When the window elapses, the tool returns a non-error `window_elapsed` result with the still-active work identities, and that work keeps running. Set `enabled` to `false` to make direct calls return immediately instead of blocking. The default is enabled. You can also set `"waitTool": false`; set `PI_SUBAGENT_WAIT_TOOL_ENABLED=false` (or `0`, `off`, `disabled`) to override config for one process. The effective enabled and default-timeout values are passed explicitly to child runtimes. Headless `agent_end` auto-drain retains its own strict deadline and fails if required work remains unresolved. Invalid config or environment values fail instead of being coerced.
 
-Blocking `bg_wait({ id: "..." })` keeps the current tool call open until that run changes. By default it returns when a run needs attention. Use `bg_wait({ stopOnAttention: false })` only for run-to-completion flows that should wait through idle or long-thinking attention; supervisor/contact requests still stop the wait. A steer or follow-up the operator sends while a blocking wait is open also ends it, with a non-error `user_input` result listing the still-active work, so the message reaches the model without waiting out the window. In a long-lived interactive parent session, `bg_wait({ id: "...", nonBlocking: true })` instead resolves the prefix once, persists the exact run identity, returns a subscription token immediately, and wakes that session on completion, failure, attention, reconciliation failure, or timeout. Use it for provider, detached, or other background work without a native completion notification; ordinary async subagent runs notify the parent natively and do not need a wait subscription. Armed subscriptions appear in ordinary `subagent({ action: "status" })` output and are not counted as active child work. Native completion notifications wake the session through the Pi process that launched the run, while that process is still running; a session reopened in a new process does not get that wake and should read the result with `subagent({ action: "status" })`. `nonBlocking` subscriptions need a host with a UI context, such as interactive or RPC mode; plain SDK embedding without a UI context rejects them.
 
+Blocking `bg_wait({ id: "..." })` keeps the current tool call open until that run changes. By default it returns when a run needs attention, even when the run is still working normally, for example a `bash` command open longer than `activeNoticeAfterMs`; the result then says the run is still running. Use `bg_wait({ stopOnAttention: false })` for run-to-completion flows: it waits through idle time, a tool held open, or repeated tool failures, and still ends for a supervisor/contact request, a finished run, the timeout, user input, or abort. A steer or follow-up the operator sends while a blocking wait is open also ends it, with a non-error `user_input` result listing the still-active work, so the message reaches the model without waiting out the window. In a long-lived interactive parent session, `bg_wait({ id: "...", nonBlocking: true })` instead resolves the prefix once, persists the exact run identity, returns a subscription token immediately, and wakes that session on completion, failure, attention, reconciliation failure, or timeout. Use it for provider, detached, or other background work without a native completion notification; ordinary async subagent runs notify the parent natively and do not need a wait subscription. Armed subscriptions appear in ordinary `subagent({ action: "status" })` output and are not counted as active child work. A native completion notification goes to the Pi process that launched the run while that process is running; once it has exited, the session gets the result the next time it is open in any Pi. `nonBlocking` subscriptions need a host with a UI context, such as interactive or RPC mode; plain SDK embedding without a UI context rejects them.
 This is different from `waitTool.enabled=false`, which returns immediately without registering any future wake. Provider items remain available only to blocking fleet-wide waits; non-blocking subscriptions require one async or remembered detached foreground run id.
 
 ## `resultScanLogging`

package/docs/tool-reference.md

@@ -82,7 +82,7 @@ The `subagent` tool schema lists `agent`, `task`, `workflow`, `args`, `async`, `
 | `options.context` | `fresh \| fork \| profile` | global or per-agent default, else `fresh` | Explicit `fresh` or `fork` overrides every workflow child. `profile` requires the selected agent's declared `defaultContext` and ignores config `defaultSubagentContext`; missing agent defaults fail. When omitted, [`defaultSubagentContext`](configuration.md#defaultsubagentcontext) wins over each agent's `defaultContext`; implicit fork falls back to fresh without a persisted parent session and leaf. Explicit fork is strict. Packaged `worker` defaults to `fresh`; packaged `oracle` and `advisor` default to `fork`. |
 | `model` | string | agent default | An exact `provider/id`; bare ids resolve only if unique, and agent names are not model ids. An unknown or ambiguous model fails with up to 5 closest registry ids to copy; `{action:"models"}` lists them all. A suffix such as `provider/id:high` (`off/minimal/low/medium/high/xhigh/max`) overrides agent thinking. The `thinking` field is only for `watchdog.configure`, ignored on dispatch. On the `claude-code` and `claude-code-writer` adapters the model is Claude Code's own alias or id, and the same suffix becomes its `--effort`, bounded by `subagents.maxThinking` and by an enforced `subagents.modelScope`. |
 | `options.missionId` | string | - | Attach a workflow, including each fire of `schedule.create`, to an existing project mission. Scheduled attachment uses ordinary lifecycle and retention rules. |
-| `options.reuseFrom` | string | - | Exact id of an async workflow run stopped by a runtime replacement (`workflow.stopCause: "runtime-replaced"`). An async relaunch of the same script in the same cwd, from any session, reuses that run's finished children and waits for its running ones; see [Workflows](workflows.md). |
+| `options.reuseFrom` | string | - | Exact id of an async workflow run stopped by a runtime replacement or whose Pi process exited (`workflow.stopCause: "runtime-replaced"` or `"owner-exited"`). An async relaunch of the same script in the same cwd, from any session, reuses that run's finished children and waits for its running ones; see [Workflows](workflows.md). |
 | `options.mission` | object/false | auto-create | Override the default enclosing mission with `{ title \| summary, objective?, goal?, budget?, labels? }`. Set exactly one non-empty `title` or `summary`; `objective` and `labels` are optional. `goal` may only be `true`, requires `budget.tokens`, and enables continuation notices. Pass `false` for an intentionally ephemeral workflow with no mission for it or its children and no `state` global. Explicit mission persistence failures are strict. |
 | `options.handoffPath` | string | - | Aggregate handoff manifest for `action: "worktree.discard"` or lane evidence actions, or optional explicit metadata for `action: "worktree.cleanup"`. |
 | `options.repo` | string | runtime cwd | Repository path for `action: "worktree.cleanup"`; required explicitly for apply. The configured worktree base filters candidates by their per-project folder under it but never discovers them. |
@@ -329,6 +329,7 @@ subagent({ action: "stop", id: "<run-id>" })
 subagent({ action: "resume", id: "<run-id>", message: "follow-up question after it pauses or finishes" })
 subagent({ action: "resume", id: "<run-id>", message: "follow-up for child 2", options: { index: 1 } })
 subagent({ action: "resume", id: "<nested-run-id>", message: "follow-up for a nested child" })
+subagent({ action: "resume", id: "<stopped-workflow-run-id>" })
 subagent({ action: "steer", id: "<run-id>", message: "guidance for the running child" })
 subagent({ action: "steer", id: "<run-id>", message: "check this after the current turn", options: { mode: "follow_up" } })
 subagent({ action: "steer", id: "<run-id>", message: "guidance for child 2", options: { index: 1, mode: "auto" } })
@@ -379,6 +380,7 @@ Commands remain owned by the child session. Normal completion with unfinished co
 - Completed external-job runs, including nested runs, can use the same `resume` action as a provider follow-up when the registered provider exposes `followUp(input)`. Running external-job parents fail closed with guidance to wait for completion. Unsupported providers fail with an update/reload message.
 - Revive starts a new child session from the old session context; it does not resume the live session, and it requires the chosen child to have a persisted `.jsonl` session file.
 - Direct revival takes an exclusive cross-process lease on the canonical session file until the new child finishes. A concurrent attempt fails before Pi is spawned and identifies the owning revived run; dead-owner leases are reclaimed only when staleness can be proved.
+- Without `message` (and without `index` or `chain`), `resume` on a top-level async workflow run that stopped because its session was replaced or its Pi process exited (`workflow.stopCause: "runtime-replaced"` or `"owner-exited"`) relaunches it once from the launch it saved, reusing its finished children, and its receipt starts with `Resumed workflow '<id>' as <new id>.`; a run that cannot be resumed is refused as `Cannot resume workflow '<id>': <reason>.` The session that owns the run also resumes it on its own when reopened or reloaded, unless [`autoResume`](configuration.md#autoresume) is off; see [Workflows](workflows.md).
 
 ### stop
 

package/docs/workflows.md

@@ -14,6 +14,8 @@ Packaged `worker` defaults to fresh context so implementation starts from its as
 
 Launch children in the background (`async` follows `asyncByDefault`, normally true) and consume each result at the point a later step depends on it. Native completion wakes the parent session, so the parent returns control instead of sleeping or polling. Use `async: false` only when the parent must block, not for final reviews or gates. When an oracle or advisor reaches an unknown that needs a decision, it asks through supervisor dialogue; use a one-shot oracle call only when one was requested.
 
+A background child awaited by an `async: false` workflow cannot receive a supervisor decision while its parent is blocked in that call. Its native `contact_supervisor` decision or interview request returns a tool error promptly, asking it to report the blocker and partial results and stop. The transport error is not a supervisor reply or approval. Use `async: true` for workflows whose children may need a decision. Progress updates remain non-blocking, and an explicit child `async: true` still returns its launch receipt without being awaited.
+
 Child-safety boundaries are enforced at runtime:
 
 - Child sessions do not receive the bundled `pi-subagents` skill.
@@ -31,8 +33,22 @@ Failed workflow details and async `status.json` include `workflow.failureKind` a
 
 When `/reload`, a session resume, or a pi-web project switch replaces the extension runtime, a running async workflow stops with `workflow.stopCause: "runtime-replaced"` in `status.json`, and its awaited async children keep running. Its in-process foreground children are stopped, including ones that detached to ask their supervisor. When the same workflow script is launched again with the same `args` in that session, a `runs.run` with the same key and params returns a child that already finished successfully without launching it, and waits for a child that is still running instead of starting another. Those results carry `reused: true`, their step and trace entry are marked `reused`, and the new run records `workflow.reusedFrom`. Failed and stopped children, and children that ran in-process, launch again. Reuse applies only when the newest run of that script and args in the session was stopped this way; a user stop or a completed run ends it. From another session, such as one that took over after a handoff, relaunch the same script as an async workflow with `options: { reuseFrom: "<stopped run id>" }`; the run must have stopped this way in the same cwd, and `args` may differ, because each child is still reused only when its key and params match.
 
+When the Pi process that ran an async workflow exits before the workflow finishes (a crash, a kill, or a machine restart), the stale-run check that runs when its session reopens, or when `options.reuseFrom` names the run, marks it failed with `workflow.stopCause: "owner-exited"`, and a relaunch reuses its finished children the same way. On any relaunch, `runs.steer` and `runs.host` calls run again and only `runs.run` results are reused, so a replayed check such as "tests passed" can be stale.
+
+A stopped run is continued by one relaunch only. While that relaunch exists, another relaunch of the same stopped run, by the same script or by `options.reuseFrom`, is refused with `workflow run '<id>' was resumed as <new id>; wait on it or stop it.` If that relaunch stops the same way, relaunch it instead: it carries the children of every run before it. If the Pi process that started the relaunch exits before the relaunch begins, the stopped run can be relaunched again.
+
+To continue a stopped run without sending its script again, resume it by id from the session that owns it: `subagent({ action: "resume", id: "<stopped run id>" })` with no `message`. Every async top-level workflow saves its launch (the script or named resource, its `args` and options) when it starts, and the resume relaunches that launch with `options.reuseFrom` set to the stopped run, in the stopped run's cwd, with no more authority than it had. A named resource is resolved again and must still have the same script. The new run records `workflow.resumeOrigin: { sourceRunId, attempt }`, where `attempt` counts the resumes that followed a Pi exit. Another session cannot resume the run by id; reopen the session that started it, or relaunch the same script with `options.reuseFrom`. When the run cannot be resumed this way (it started before launches were saved, was launched from `tasks` or `chain`, or its resource changed), the refusal says so; relaunch the same script by hand with `options: { reuseFrom: "<stopped run id>" }`.
+
+When the session that owns such a run is reopened or reloaded, the run is resumed this way automatically, once, if it was interrupted in the last 24 hours: for a Pi exit, measured from the last time the dead Pi process updated the run. Session start does not wait for the relaunch. A run that cannot be relaunched is named in its notice (`Not auto-resumed: …`, with how to continue by hand); a launch that fails after session start also posts one `Workflow <id> was not auto-resumed: <reason>.` message. Either way the run is not tried again. `/new` and forks do not resume the runs of the session they replaced. The `autoResume` setting turns this off; see [Configuration](configuration.md#autoresume).
+
+Starting Pi in a folder where another session's subagent runs were cut off by its Pi dying in the last 24 hours shows one info line per such session, such as ``2 subagent runs were interrupted in another session. Reopen it to resume them: `pi --session <id>` ``; it only points to that session, changes nothing in it, and is not sent to the model.
+
+The completion notice of a workflow stopped by a Pi exit or a runtime replacement has one line right after `Workflow run: <id>` that says what happens next: `Auto-resumed as <new id>.`, `Resumed as <new id>.` (resumed by id), `Relaunched as <new id>.` (relaunched with the same script or `options.reuseFrom`), `Not auto-resumed: <reason>.` followed by the way to continue by hand, or, when nothing continues it, `Resume by hand: subagent({ action: "resume", id: "<id>" })` (or the `options.reuseFrom` form when its launch cannot be resumed by id).
+
 After `/new`, `/resume`, or a fork in the same Pi process, the new session owns the async runs of the session it replaced, and of the sessions that one replaced. It can list, `bg_wait` on, steer, stop, and resume them, receives their completion notices, and answers their children's pending supervisor requests. Over RPC, a host can steer, interrupt, stop, resume, and inspect them, and sees them in the fleet and `subagent-async` snapshots. Startup and other Pi processes inherit nothing; `/reload` adds nothing new but keeps what the session already inherited. To relaunch a stopped workflow instead of controlling its children one by one, use `options.reuseFrom`.
 
+Once the Pi process that started a background single, parallel, or chain run has exited, the run is reported once to a Pi window that has its session open, whether it finished while Pi was closed or finishes later. A workflow's children are reported through their workflow.
+
 Pi core may print a generic `pi -ne` extension-load hint; that out-of-repo hint is not protocol-approved fallback. A verified compaction abort may continue the retained child once on its already resolved model; it does not authorize an execution-mode or model switch.
 
 ## Prompt shortcuts

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "pi-subagents",
-  "version": "0.81.0",
+  "version": "0.82.0",
   "description": "Pi extension for single-agent delegation and scripted multi-agent workflows",
   "author": "Nico Bailon",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "@js-temporal/polyfill": "0.5.1",
     "acorn": "8.18.0",
     "jiti": "2.7.0",
-    "undici": "8.10.2",
+    "undici": "8.12.3",
     "yaml": "2.8.3"
   },
   "peerDependencies": {

package/skills/pi-subagents/references/execution-controls.md

@@ -169,10 +169,11 @@ subagent runs notify the parent automatically. Use `bg_wait({ all: true })` for
 all work active at call time, `bg_wait({ id: "..." })` for one async or
 remembered detached foreground run, and `bg_wait({ timeoutMs })` to cap the
 block; active work keeps running if it elapses. `bg_wait({ stopOnAttention:
-false })` keeps a blocking wait through idle or long-thinking attention, but
-supervisor/contact requests still stop it. In a long-lived interactive parent
-session, use `bg_wait({ id: "...", nonBlocking: true })` only for a known
-detached or otherwise non-notifying run to resolve the prefix to one exact run,
+false })` keeps a blocking wait through idle time, a tool held open, or repeated
+tool failures; supervisor/contact requests, finished runs, timeout and user
+input still stop it. In a long-lived interactive parent session, use
+`bg_wait({ id: "...", nonBlocking: true })` only for a known detached or
+otherwise non-notifying run to resolve the prefix to one exact run,
 persist an armed subscription, return immediately, and wake later on
 completion, failure, attention, reconciliation failure, or timeout. Ordinary
 status lists armed subscriptions separately from active children. This differs

package/src/agents/agent-management.js

@@ -5,7 +5,7 @@ import { serializeAgent } from "./agent-serializer.js";
 import { mergeAgentsForScope } from "./agent-selection.js";
 import { discoverAvailableSkills, resolveSkills } from "./skills.js";
 import { buildProactiveSkillSubagentRecommendationLines, } from "./proactive-skills.js";
-import { parseFrontmatter, parseFrontmatterList } from "./frontmatter.js";
+import { parseFrontmatter, parseUnquotedList } from "./frontmatter.js";
 import { resolveEffectiveThinking, toModelInfo } from "../shared/model-info.js";
 import { resolveSubagentModelOverride } from "../runs/shared/model-resolution.js";
 import { validateToolBudgetConfig } from "../runs/shared/tool-budget.js";
@@ -175,9 +175,9 @@ function withDeclaredExtensionPaths(config, filePath) {
     const { extensions: _extensions, subagentOnlyExtensions: _subagentOnlyExtensions, ...withoutResolvedExtensions } = config;
     return {
         ...withoutResolvedExtensions,
-        ...(frontmatter.extensions !== undefined ? { extensions: parseFrontmatterList(frontmatter.extensions) } : {}),
+        ...(frontmatter.extensions !== undefined ? { extensions: parseUnquotedList(frontmatter.extensions) } : {}),
         ...(frontmatter.subagentOnlyExtensions !== undefined
-            ? { subagentOnlyExtensions: parseFrontmatterList(frontmatter.subagentOnlyExtensions) }
+            ? { subagentOnlyExtensions: parseUnquotedList(frontmatter.subagentOnlyExtensions) }
             : {}),
     };
 }

package/src/agents/agent-memory.js

@@ -236,7 +236,9 @@ export function readMemoryFile(memoryDir) {
     let fd;
     try {
         const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
-        fd = fs.openSync(file, fs.constants.O_RDONLY | noFollow);
+        // A FIFO must not block the launch before fstat can reject non-files.
+        const nonBlock = typeof fs.constants.O_NONBLOCK === "number" ? fs.constants.O_NONBLOCK : 0;
+        fd = fs.openSync(file, fs.constants.O_RDONLY | noFollow | nonBlock);
     }
     catch (error) {
         const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";

package/src/agents/agents.js

@@ -19,7 +19,7 @@ import { parseChain, parseJsonChain } from "./chain-serializer.js";
 import { mergeAgentsForScope } from "./agent-selection.js";
 import { projectScopeRequiresTrustMessage } from "./agent-scope.js";
 import { closestMatch } from "../shared/edit-distance.js";
-import { parseFrontmatter, parseFrontmatterList } from "./frontmatter.js";
+import { parseFrontmatter, parseFrontmatterList, parseUnquotedList } from "./frontmatter.js";
 import { buildRuntimeName, parsePackageName } from "./identity.js";
 import { parseModelScopeConfig } from "../runs/shared/model-scope.js";
 export { BUILTIN_AGENT_NAMES } from "./builtin-names.js";
@@ -1919,11 +1919,11 @@ function loadAgentsFromDefinitionFiles(files, source, discoveryPriority, package
                 else
                     throw new Error(`Agent '${localName}' has invalid advertise frontmatter; expected true or false.`);
             }
-            const rawTools = parseFrontmatterList(frontmatter.tools);
+            const rawTools = parseUnquotedList(frontmatter.tools);
             const parsedTools = splitToolList(rawTools);
             const tools = parsedTools.tools ?? [];
             const mcpDirectTools = parsedTools.mcpDirectTools ?? [];
-            const excludeTools = parseFrontmatterList(frontmatter.excludeTools);
+            const excludeTools = parseUnquotedList(frontmatter.excludeTools);
             const parsedAllowedAgents = parseFrontmatterList(frontmatter.allowedAgents);
             const allowedAgents = parsedAllowedAgents === undefined ? undefined : normalizeCapabilityCeilingAllowedAgents(parsedAllowedAgents);
             const defaultReads = parseFrontmatterList(frontmatter.defaultReads);
@@ -1997,9 +1997,9 @@ function loadAgentsFromDefinitionFiles(files, source, discoveryPriority, package
                 else
                     throw new Error(`Agent '${localName}' has invalid acceptanceRole frontmatter; expected 'read-only' or 'writer'.`);
             }
-            const extensions = resolveAgentRelativeExtensionPaths(parseFrontmatterList(frontmatter.extensions), filePath);
-            const subagentOnlyExtensions = resolveAgentRelativeExtensionPaths(parseFrontmatterList(frontmatter.subagentOnlyExtensions), filePath);
-            const mutationTools = parseFrontmatterList(frontmatter.mutationTools);
+            const extensions = resolveAgentRelativeExtensionPaths(parseUnquotedList(frontmatter.extensions), filePath);
+            const subagentOnlyExtensions = resolveAgentRelativeExtensionPaths(parseUnquotedList(frontmatter.subagentOnlyExtensions), filePath);
+            const mutationTools = parseUnquotedList(frontmatter.mutationTools);
             let fast;
             if (frontmatter.fast !== undefined) {
                 if (frontmatter.fast === "true")

package/src/agents/frontmatter.d.ts

@@ -5,6 +5,8 @@
  * alone because parseFrontmatter has already removed their quotes, so `"notes #1.md"` must survive.
  */
 export declare function parseFrontmatterList(raw: string | undefined): string[] | undefined;
+/** A tool or extension name list whose items may each be quoted, as in `"read", "bash"` or `- "read"`. */
+export declare function parseUnquotedList(raw: string | undefined): string[] | undefined;
 /**
  * Parse YAML frontmatter from agent/chain files.
  * Handles both flat (key: value) and nested block (key: \n  sub: val) values.

package/src/agents/frontmatter.js

@@ -56,6 +56,16 @@ export function parseFrontmatterList(raw) {
         .map((value) => value.trim())
         .filter(Boolean);
 }
+function unquoteName(value) {
+    if (value.length >= 2 && ((value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"')))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+/** A tool or extension name list whose items may each be quoted, as in `"read", "bash"` or `- "read"`. */
+export function parseUnquotedList(raw) {
+    return parseFrontmatterList(raw)?.map(unquoteName);
+}
 /**
  * Parse YAML frontmatter from agent/chain files.
  * Handles both flat (key: value) and nested block (key: \n  sub: val) values.
@@ -115,7 +125,11 @@ export function parseFrontmatter(content) {
             if (key === undefined || rawValueValue === undefined)
                 continue;
             const rawValue = rawValueValue.trim();
-            const isQuoted = (rawValue.startsWith('"') && rawValue.endsWith('"')) || (rawValue.startsWith("'") && rawValue.endsWith("'"));
+            const quote = rawValue[0];
+            const nameList = key === "tools" || key === "excludeTools" || key === "mutationTools" || key === "extensions" || key === "subagentOnlyExtensions";
+            // `"read", "bash"` starts and ends with a quote, but it is a list. Keep those item quotes for the splitter.
+            const quotedList = nameList && (quote === '"' || quote === "'") && (rawValue.includes(`${quote},`) || rawValue.includes(`, ${quote}`));
+            const isQuoted = !quotedList && (quote === '"' || quote === "'") && rawValue.endsWith(quote);
             const value = isQuoted ? rawValue.slice(1, -1) : rawValue;
             const isFolded = !isQuoted && (rawValue === ">" || rawValue === ">-");
             const isLiteral = !isQuoted && (rawValue === "|" || rawValue === "|-");

package/src/agents/skills.js

@@ -45,7 +45,8 @@ function readOptionalJsonFile(filePath, label) {
         const code = typeof error === "object" && error !== null && "code" in error
             ? error.code
             : undefined;
-        if (code === "ENOENT")
+        // ENOTDIR: a settings package entry may name a single extension file, so `<file>/package.json` is no manifest.
+        if (code === "ENOENT" || code === "ENOTDIR")
             return null;
         const message = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to read ${label} '${filePath}': ${message}`, {

package/src/extension/config.js

@@ -217,6 +217,9 @@ function validateConfig(config) {
     if (config.enableSlashCommands !== undefined && typeof config.enableSlashCommands !== "boolean") {
         throw new Error("config.enableSlashCommands must be a boolean");
     }
+    if (config.autoResume !== undefined && typeof config.autoResume !== "boolean") {
+        throw new Error("config.autoResume must be a boolean");
+    }
     if (config.toolActivation !== undefined && config.toolActivation !== "auto" && config.toolActivation !== "dynamic" && config.toolActivation !== "eager") {
         throw new Error('config.toolActivation must be "auto", "dynamic", or "eager"');
     }

package/src/extension/herdr-pi-bridge.js

@@ -10,6 +10,7 @@ import { buildSkillInjection, resolveSkills } from "../agents/skills.js";
 import { buildAgentMemoryInjection } from "../agents/agent-memory.js";
 import { appendAgentRefinementOverlay } from "../agents/agent-refinements.js";
 import { rewriteSubagentPrompt } from "../runs/shared/subagent-prompt-runtime.js";
+import { assertNoToolModifierEntries } from "../runs/shared/child-tool-plan.js";
 import { resolveExistingReadPaths } from "../shared/settings.js";
 import { MODEL_ONLY_TOOL } from "../shared/extension-context.js";
 function gitEvidence(cwd) {
@@ -37,6 +38,7 @@ export function resolveRemoteHerdrResources(cwd, resources, remoteDefaultTools =
     const reads = resources.reads === undefined ? agent.defaultReads ?? false : resources.reads;
     const readPaths = Array.isArray(reads) ? resolveExistingReadPaths(reads, cwd) : [];
     const systemPrompt = appendAgentRefinementOverlay(`${agent.systemPrompt}${buildAgentMemoryInjection(agent, cwd)}${skillPrompt ? `\n\n${skillPrompt}` : ""}${readPaths.length ? `\n\n[Read from: ${readPaths.join(", ")}]` : ""}`, { cwd, agentName: agent.name });
+    assertNoToolModifierEntries(agent.name, agent.tools ?? []);
     const denied = new Set(agent.excludeTools ?? []);
     const tools = (agent.tools === undefined ? remoteDefaultTools : agent.tools).filter((tool) => !denied.has(tool) && (!resources.toolCeiling || resources.toolCeiling.includes(tool)));
     if (agent.tools === undefined && !tools.length)
@@ -91,7 +93,6 @@ export default 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,
@@ -104,11 +105,11 @@ export default 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, 65_536) ?? "", ...(input.interview !== undefined ? { 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 {
@@ -145,7 +146,10 @@ export default function registerHerdrPiBridge(pi) {
             if (!entry)
                 throw new Error("Unknown supervisor request.");
             supervisor.delete(request.supervisorId);
-            entry.resolve(request.text ?? "");
+            if (request.error !== undefined)
+                entry.reject(new Error(request.error));
+            else
+                entry.resolve(request.text ?? "");
         }
         send({ type: "control-ack", requestId, operation: request.operation, nativeSessionId });
     };
@@ -165,7 +169,7 @@ export default function registerHerdrPiBridge(pi) {
         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: packageJson.version, runId, socketPath, nativeSessionId, pid: process.pid }), { mode: 0o600, flag: "wx" });
-        send({ type: "ready", packageVersion: packageJson.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}` : undefined, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
+        send({ type: "ready", packageVersion: packageJson.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}` : undefined, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
     });
     on("message_end", (event) => {
         const message = event.message;
@@ -215,11 +219,11 @@ export default function registerHerdrPiBridge(pi) {
                         const invalidReads = resources.reads !== undefined && 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 !== undefined ? { 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 !== undefined ? { 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;
@@ -234,7 +238,10 @@ export default function registerHerdrPiBridge(pi) {
                     const text = frame.text;
                     if (text !== undefined && (typeof text !== "string" || Buffer.byteLength(text) > 256 * 1024))
                         throw new Error("Bridge request text is invalid or too large.");
-                    pending.set(frame.requestId, { operation: operation, ...(text !== undefined ? { text } : {}), ...(typeof frame.supervisorId === "string" ? { supervisorId: frame.supervisorId } : {}) });
+                    const error = frame.error;
+                    if (error !== undefined && (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: operation, ...(text !== undefined ? { text } : {}), ...(typeof frame.supervisorId === "string" ? { supervisorId: frame.supervisorId } : {}), ...(error !== undefined ? { error } : {}) });
                     send({ type: "prepared", requestId: frame.requestId, nativeSessionId });
                 }
             }
@@ -245,7 +252,7 @@ export default function registerHerdrPiBridge(pi) {
         socket.on("close", () => { if (client === socket)
             client = undefined; });
         if (context && nativeSessionId)
-            send({ type: "ready", packageVersion: packageJson.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}` : undefined, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
+            send({ type: "ready", packageVersion: packageJson.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}` : undefined, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
     });
     server.listen(socketPath, () => { fs.chmodSync(socketPath, 0o600); });
 }