pi-subagents 0.81.0 → 0.82.0

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 ## [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

package/bundle/agents.js

@@ -2,11 +2,11 @@ import {
   RUNTIME_AGENT_REGISTER_EVENT,
   RUNTIME_AGENT_REGISTER_VERSION,
   registerAgentViaEvents
-} from "./chunk-LSRUTHT7.js";
+} from "./chunk-43SCHIMD.js";
 import {
   registerRuntimeAgent
-} from "./chunk-3IF2PGW7.js";
-import "./chunk-ZBC44JJ3.js";
+} from "./chunk-YKEWIB4M.js";
+import "./chunk-CIZQXJ5Q.js";
 import "./chunk-5LFLVSTM.js";
 import "./chunk-YFCK7H2S.js";
 import "./chunk-Z7KVHQHL.js";

package/bundle/child-tool-plan.js

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

package/bundle/{chunk-LSRUTHT7.js → chunk-43SCHIMD.js}

@@ -1,6 +1,6 @@
 import {
   registerRuntimeAgent
-} from "./chunk-3IF2PGW7.js";
+} from "./chunk-YKEWIB4M.js";
 
 // src/agents/runtime-agent-events.ts
 var RUNTIME_AGENT_REGISTER_EVENT = "pi-subagents:runtime-agent-register:v1";

package/bundle/{chunk-G5DKFLLI.js → chunk-4SDU2BZX.js}

@@ -7,7 +7,7 @@ import {
   getAgentDir,
   getConfigDirName,
   getProjectConfigDir
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   TEMP_ROOT_DIR
 } from "./chunk-5LFLVSTM.js";
@@ -935,6 +935,15 @@ function formatRuntimeSnapshotMcpServersError(agentName, serverNames) {
   const subject = agentName ? `Agent '${agentName}'` : "Subagent";
   return `${subject} selects MCP tools from servers that exist only in pi-mcp-adapter's runtime snapshot (${serverNames.join(", ")}). MCP servers from the runtime snapshot cannot be provided to in-process children; MCP tools must come from an ambient adapter extension in a background child (\`async: true\`), so add the server to the adapter's configuration file instead.`;
 }
+function isToolExtensionPath(entry) {
+  return entry.includes("/") || entry.endsWith(".ts") || entry.endsWith(".js");
+}
+function assertNoToolModifierEntries(agentName, tools) {
+  const entries = tools.filter((entry) => /^[+-]/u.test(entry) && !isToolExtensionPath(entry));
+  if (entries.length === 0) return;
+  const subject = agentName ? `Agent '${agentName}'` : "Subagent";
+  throw new Error(`${subject} lists Pi tool modifier ${entries.length === 1 ? "entry" : "entries"} in \`tools\`: ${entries.join(", ")}. A child's \`tools\` list is the complete set of tools it gets, so +name and -name entries are not supported; name every tool the child needs, or omit \`tools\` and use \`excludeTools\` to drop one.`);
+}
 function projectLaunchResolvedChildExtensions(toolPlan) {
   const runtime = boundedExtensionIdentifiers(toolPlan.runtimeExtensions);
   const configured = boundedExtensionIdentifiers(toolPlan.configuredExtensions);
@@ -1014,9 +1023,8 @@ function resolvePiLaunchToolPlan(input) {
     throw new Error(`Capability ceiling from ${capabilityCeiling.sources.join(", ") || "unknown source"} denies extensions but this host requires: ${requiredExtensions.map(({ id }) => id).join(", ")}.`);
   }
   const allowedToolSet = capabilityCeiling?.allowedTools === void 0 ? void 0 : new Set(capabilityCeiling.allowedTools);
-  const requestedBuiltinTools = input.tools?.filter(
-    (tool) => !(tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js"))
-  ) ?? [];
+  const requestedBuiltinTools = input.tools?.filter((tool) => !isToolExtensionPath(tool)) ?? [];
+  assertNoToolModifierEntries(input.agentName, input.tools ?? []);
   if (input.requireReadTool && allowedToolSet && !allowedToolSet.has("read")) {
     throw new Error(
       `Capability ceiling from ${capabilityCeiling?.sources.join(", ") || "unknown source"} excludes required tool 'read' for lazy skill loading.`
@@ -1031,9 +1039,7 @@ function resolvePiLaunchToolPlan(input) {
   if (effectiveDeclaredBuiltinTools.includes("subagent_supervisor") && !fanoutAuthorized) {
     throw new Error("Tool 'subagent_supervisor' requires fanout authorization: include 'subagent' in the effective tools allowlist or enable allowNestedSubagents.");
   }
-  const toolExtensionPaths = capabilityCeiling?.denyExtensions ? [] : (input.tools ?? []).filter(
-    (tool) => !requestedBuiltinTools.includes(tool) && (tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js"))
-  );
+  const toolExtensionPaths = capabilityCeiling?.denyExtensions ? [] : (input.tools ?? []).filter(isToolExtensionPath);
   const mcpResolution = capabilityCeiling?.denyExtensions ? { selections: [], unresolvedSelectors: [] } : input.builtinMcpTools ? { selections: input.builtinMcpTools, unresolvedSelectors: [], builtin: true } : resolveMcpDirectToolResolution(input.mcpDirectTools, input.cwd, input.runtimeSnapshotHost);
   if (mcpResolution.runtimeServerNames?.length) {
     throw new Error(formatRuntimeSnapshotMcpServersError(input.agentName, mcpResolution.runtimeServerNames));
@@ -1114,9 +1120,7 @@ function resolvePiLaunchToolPlan(input) {
     ) ?? [],
     internalTools,
     extensionsDenied: capabilityCeiling.denyExtensions,
-    removedExtensionCount: capabilityCeiling.denyExtensions ? (input.extensions?.length ?? 0) + (input.subagentOnlyExtensions?.length ?? 0) + (input.tools ?? []).filter(
-      (tool) => tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js")
-    ).length : 0,
+    removedExtensionCount: capabilityCeiling.denyExtensions ? (input.extensions?.length ?? 0) + (input.subagentOnlyExtensions?.length ?? 0) + (input.tools ?? []).filter(isToolExtensionPath).length : 0,
     requestedMcpToolCount: input.mcpDirectTools?.length ?? 0,
     effectiveMcpTools,
     agentAllowed: input.agentName === void 0 ? true : isAgentAllowedByCapabilityCeiling(
@@ -1180,6 +1184,7 @@ export {
   deriveForkPromptCacheKey,
   supervisorChannelDir,
   applyThinkingSuffix,
+  assertNoToolModifierEntries,
   projectLaunchResolvedChildExtensions,
   resolvePiLaunchToolPlan
 };

package/bundle/{chunk-V2JWDB5U.js → chunk-52UBALJL.js}

@@ -3,11 +3,11 @@ import {
 } from "./chunk-7J4ZXMY7.js";
 import {
   getProjectSubagentsDir
-} from "./chunk-3DC5KBVP.js";
+} from "./chunk-5TYMSZX3.js";
 import {
   getPiSpawnCommand,
   writeAtomicJson
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 
 // src/inspectors/herdr/project-panes.ts
 import * as fs from "node:fs";

package/bundle/{chunk-3DC5KBVP.js → chunk-5TYMSZX3.js}

@@ -1,6 +1,6 @@
 import {
   getAgentDir
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   TEMP_ARTIFACTS_DIR
 } from "./chunk-5LFLVSTM.js";

package/bundle/{chunk-CEKS3TFO.js → chunk-7IVSUMQQ.js}

@@ -1,27 +1,27 @@
 import {
-  currentCompletionOwnerId,
   isTrustedRecordedSessionFile,
   resolveSubagentRunId
-} from "./chunk-KSWQVGDW.js";
+} from "./chunk-7PCKZHR5.js";
 import {
   agentStreamOptions,
   opencodeSessionHeaders,
   ownsRun,
   resolveAsyncResumeTarget
-} from "./chunk-NNLASTQE.js";
+} from "./chunk-VH5OAWVG.js";
 import {
+  currentCompletionOwnerId,
   listMissions,
   missionRecordPath,
   readMissionBinding,
   reconcileAsyncRun,
   resolveAuthorityDecision,
   resolveMissionStoreLocation
-} from "./chunk-VJHOELQP.js";
+} from "./chunk-NRQ75MGH.js";
 import {
   deliverInterruptRequest,
   queueRevivalBrief,
   requestAsyncSteer
-} from "./chunk-BJN5LUQY.js";
+} from "./chunk-OYF6AFDY.js";
 import {
   formatShellCommand
 } from "./chunk-7J4ZXMY7.js";
@@ -32,7 +32,7 @@ import {
   tryLease,
   writeAtomicJson,
   writePrivateAtomicJson
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   DIRS
 } from "./chunk-5LFLVSTM.js";

package/bundle/{chunk-KSWQVGDW.js → chunk-7PCKZHR5.js}

@@ -11,11 +11,15 @@ import {
   resolveAsyncStatusChild,
   stopStoppableAsyncStatusChildren,
   summarizeContextModes,
+  utf8Tail,
   workflowPreflightLaneForRuntimeKey
-} from "./chunk-NNLASTQE.js";
+} from "./chunk-VH5OAWVG.js";
 import {
   assertSafeNestedId,
+  checkRecordedPidLiveness,
+  encodeIndexSegment,
   findNestedRunMatchesById,
+  isRecordedPid,
   readActiveRunToolCallIndex,
   readProcessTerminal,
   readTerminalRunToolCallIndex,
@@ -26,12 +30,13 @@ import {
   resultPayloadPathForIndexedRun,
   resultPayloadPathForSessionRun,
   updateActiveRunIndex,
+  validateModelResponseAliases,
   writeAsyncResultFile
-} from "./chunk-VJHOELQP.js";
+} from "./chunk-NRQ75MGH.js";
 import {
   deliverStopRequest,
   stopInboxClosedPath
-} from "./chunk-BJN5LUQY.js";
+} from "./chunk-OYF6AFDY.js";
 import {
   SUBAGENT_STOPPED_MESSAGE,
   formatDuration,
@@ -39,8 +44,10 @@ import {
   formatTokens,
   readStatus,
   shortenPath,
-  writeAtomicJson
-} from "./chunk-ZBC44JJ3.js";
+  validateAcceptanceInput,
+  writeAtomicJson,
+  writePrivateAtomicJson
+} from "./chunk-CIZQXJ5Q.js";
 import {
   DIRS
 } from "./chunk-5LFLVSTM.js";
@@ -49,15 +56,6 @@ import {
   truncateDisplayText
 } from "./chunk-YFCK7H2S.js";
 
-// src/shared/completion-owner.ts
-import { randomUUID } from "node:crypto";
-var COMPLETION_OWNER_KEY = /* @__PURE__ */ Symbol.for("pi-subagents.completion-owner-id");
-function currentCompletionOwnerId() {
-  const runtime = globalThis;
-  runtime[COMPLETION_OWNER_KEY] ??= randomUUID();
-  return runtime[COMPLETION_OWNER_KEY];
-}
-
 // src/workflows/chat-progress.ts
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
@@ -411,8 +409,8 @@ function formatDetachedForegroundFleetLines(runs) {
 }
 function externalCliStepFacts(step, now) {
   if (step.runner?.type !== "external-cli") return void 0;
-  const process = step.externalProcess;
-  const elapsed = process ? process.durationMs ?? Math.max(0, (process.endedAt ?? now) - process.startedAt) : void 0;
+  const process2 = step.externalProcess;
+  const elapsed = process2 ? process2.durationMs ?? Math.max(0, (process2.endedAt ?? now) - process2.startedAt) : void 0;
   return `external-cli${elapsed !== void 0 ? ` \xB7 ${formatDuration(elapsed)}` : ""}`;
 }
 function formatAsyncFleetLines(runs, now = Date.now()) {
@@ -861,6 +859,8 @@ function sealPausedRun(asyncDir, status, resultsDir) {
       sessionId: status.sessionId,
       asyncDir,
       ...status.completionOwnerId ? { completionOwnerId: status.completionOwnerId } : {},
+      ...status.completionOwnerProcess ? { completionOwnerProcess: status.completionOwnerProcess } : {},
+      ...status.parentWorkflowRunId ? { parentWorkflowRunId: status.parentWorkflowRunId } : {},
       ...status.toolCallId ? { toolCallId: status.toolCallId } : {},
       results: (status.steps ?? []).map((step) => ({
         agent: step.agent,
@@ -1010,8 +1010,209 @@ function stopAsyncRun(state, runId, kill, location, childId) {
   }
 }
 
+// src/runs/foreground/foreground-history.ts
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+var MAX_REMEMBERED_FOREGROUND_RUNS = 50;
+var FOREGROUND_OWNER_EXITED_STOP_ERROR = "Subagent stopped because the Pi process that ran it exited before the run finished.";
+var MAX_INLINE_OUTPUT_BYTES = 64 * 1024;
+var MAX_RESUME_CONTRACT_BYTES = 64 * 1024;
+function historyDir(resultsDir) {
+  return path6.join(resultsDir, "foreground-history");
+}
+function runHistoryPath(resultsDir, runId) {
+  return path6.join(historyDir(resultsDir), `${encodeIndexSegment(runId)}.json`);
+}
+function boundedTail(value) {
+  return utf8Tail(value, MAX_INLINE_OUTPUT_BYTES).text;
+}
+function compactChild(child) {
+  const outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
+  return {
+    agent: child.agent,
+    index: child.index,
+    ...child.sessionName ? { sessionName: child.sessionName } : {},
+    ...child.context ? { context: child.context } : {},
+    ...child.sessionFile ? { sessionFile: child.sessionFile } : {},
+    ...child.model ? { model: child.model } : {},
+    ...child.thinking ? { thinking: child.thinking } : {},
+    status: child.status,
+    ...child.activityState ? { activityState: child.activityState } : {},
+    ...child.lastActivityAt !== void 0 ? { lastActivityAt: child.lastActivityAt } : {},
+    ...child.currentTool ? { currentTool: child.currentTool } : {},
+    ...child.currentToolStartedAt !== void 0 ? { currentToolStartedAt: child.currentToolStartedAt } : {},
+    ...child.currentPath ? { currentPath: child.currentPath } : {},
+    ...child.turnCount !== void 0 ? { turnCount: child.turnCount } : {},
+    ...child.tokens !== void 0 ? { tokens: child.tokens } : {},
+    ...child.toolCount !== void 0 ? { toolCount: child.toolCount } : {},
+    ...child.exitCode !== void 0 ? { exitCode: child.exitCode } : {},
+    ...child.error ? { error: child.error } : {},
+    ...!outputPath && child.finalOutput ? { finalOutput: boundedTail(child.finalOutput) } : {},
+    ...child.outputState ? { outputState: child.outputState } : {},
+    ...child.outputPartial ? { outputPartial: true } : {},
+    ...child.outputMode ? { outputMode: child.outputMode } : {},
+    ...child.savedOutputPath ? { savedOutputPath: child.savedOutputPath } : {},
+    ...child.outputSaveError ? { outputSaveError: child.outputSaveError } : {},
+    ...child.artifactPaths ? { artifactPaths: child.artifactPaths } : {},
+    ...child.transcriptPath ? { transcriptPath: child.transcriptPath } : {},
+    ...child.transcriptError ? { transcriptError: child.transcriptError } : {},
+    ...child.acceptance ? { acceptance: child.acceptance } : {},
+    ...child.resumeContract ? { resumeContract: child.resumeContract } : {},
+    ...child.launchContractDigest ? { launchContractDigest: child.launchContractDigest } : {},
+    ...child.extensionBindings ? { extensionBindings: child.extensionBindings } : {},
+    ...child.requiredExtensions ? { requiredExtensions: child.requiredExtensions } : {},
+    ...child.capabilityCeiling ? { capabilityCeiling: child.capabilityCeiling } : {},
+    ...child.updatedAt !== void 0 ? { updatedAt: child.updatedAt } : {}
+  };
+}
+function isRestorableForegroundStatus(status) {
+  return status === "completed" || status === "failed" || status === "paused" || status === "stopped";
+}
+function hasRunningChild(run) {
+  return run.children.some((child) => child.status === "running");
+}
+function isAdmittedChildStatus(run, status) {
+  return isRestorableForegroundStatus(status) || status === "running" && run.mode === "single" && isRecordedPid(run.owner);
+}
+function isRestorableResumeContract(value) {
+  if (value === void 0) return true;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  try {
+    if (Buffer.byteLength(JSON.stringify(value), "utf8") > MAX_RESUME_CONTRACT_BYTES) return false;
+    validateModelResponseAliases(value?.modelResponseAliases);
+  } catch {
+    return false;
+  }
+  const contract = value;
+  if (Object.keys(contract).some((key) => !["modelResponseAliases", "outputSchema", "agentContract", "acceptance", "output", "outputMode"].includes(key))) return false;
+  if (contract.outputSchema !== void 0 && contract.outputSchema !== false && (!contract.outputSchema || typeof contract.outputSchema !== "object" || Array.isArray(contract.outputSchema))) return false;
+  if (contract.agentContract !== void 0 && (!contract.agentContract || typeof contract.agentContract !== "object" || Array.isArray(contract.agentContract) || contract.agentContract.version !== 1)) return false;
+  if (validateAcceptanceInput(contract.acceptance).length > 0) return false;
+  if (contract.output !== void 0 && typeof contract.output !== "string" && typeof contract.output !== "boolean") return false;
+  return contract.outputMode === void 0 || contract.outputMode === "inline" || contract.outputMode === "file-only";
+}
+function compactRun(run) {
+  if (!run.sessionId) return void 0;
+  if (run.children.length === 0 || !run.children.every((child) => isAdmittedChildStatus(run, child.status) && isRestorableResumeContract(child.resumeContract))) return void 0;
+  const running = hasRunningChild(run);
+  return {
+    runId: run.runId,
+    mode: run.mode,
+    cwd: run.cwd,
+    sessionId: run.sessionId,
+    updatedAt: run.updatedAt,
+    children: run.children.map(compactChild),
+    ...running ? { owner: run.owner } : {},
+    ...run.parentWorkflowRunId ? { parentWorkflowRunId: run.parentWorkflowRunId } : {}
+  };
+}
+function readRunFile(filePath) {
+  try {
+    const parsed = JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+    return isRestorableRun(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function historyFiles(dir) {
+  try {
+    return fs6.readdirSync(dir).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+}
+function isRestorableRun(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const run = value;
+  return typeof run.runId === "string" && Boolean(run.runId) && (run.mode === "single" || run.mode === "parallel" || run.mode === "chain") && typeof run.cwd === "string" && Boolean(run.cwd) && typeof run.sessionId === "string" && Boolean(run.sessionId) && typeof run.updatedAt === "number" && Number.isFinite(run.updatedAt) && Array.isArray(run.children) && run.children.length > 0 && (run.owner === void 0 || isRecordedPid(run.owner)) && (run.parentWorkflowRunId === void 0 || typeof run.parentWorkflowRunId === "string") && run.children.every((child) => Boolean(child && typeof child === "object" && !Array.isArray(child) && typeof child.agent === "string" && typeof child.index === "number" && isRestorableResumeContract(child.resumeContract) && isAdmittedChildStatus(run, child.status)));
+}
+function pruneHistory(dir, limit) {
+  const files = historyFiles(dir);
+  if (files.length <= limit) return;
+  const byAge = files.flatMap((name) => {
+    try {
+      return [{ name, mtimeMs: fs6.statSync(path6.join(dir, name)).mtimeMs }];
+    } catch {
+      return [];
+    }
+  }).sort((left, right) => left.mtimeMs - right.mtimeMs);
+  for (const { name, mtimeMs } of byAge.slice(0, byAge.length - limit)) {
+    const filePath = path6.join(dir, name);
+    const run = readRunFile(filePath);
+    if (run && hasRunningChild(run) && !ownerConfirmedDead(run)) continue;
+    try {
+      if (fs6.statSync(filePath).mtimeMs !== mtimeMs) continue;
+    } catch {
+      continue;
+    }
+    fs6.rmSync(filePath, { force: true });
+  }
+}
+function persistForegroundRun(run, options = {}) {
+  const compact = compactRun(run);
+  if (!compact) return;
+  const resultsDir = options.resultsDir ?? DIRS.results;
+  const dir = historyDir(resultsDir);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
+    fs6.rmSync(path6.join(resultsDir, "foreground-history.json"), { force: true });
+  }
+  writePrivateAtomicJson(runHistoryPath(resultsDir, compact.runId), compact);
+  pruneHistory(dir, options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
+}
+function discardRunningForegroundRun(runId, options = {}) {
+  const filePath = runHistoryPath(options.resultsDir ?? DIRS.results, runId);
+  const run = readRunFile(filePath);
+  if (run && hasRunningChild(run) && run.owner?.pid === process.pid) fs6.rmSync(filePath, { force: true });
+}
+function ownerConfirmedDead(run) {
+  return checkRecordedPidLiveness(run.owner) === "dead";
+}
+function restoreInterruptedRun(run) {
+  if (!ownerConfirmedDead(run)) return void 0;
+  const { owner: _owner, ...rest } = run;
+  return {
+    ...rest,
+    children: run.children.map((child) => {
+      if (child.status !== "running") return child;
+      const { activityState: _activityState, currentTool: _currentTool, currentToolStartedAt: _currentToolStartedAt, currentPath: _currentPath, sessionFile, ...stopped } = child;
+      return {
+        ...stopped,
+        status: "stopped",
+        exitCode: 1,
+        error: FOREGROUND_OWNER_EXITED_STOP_ERROR,
+        finalOutput: FOREGROUND_OWNER_EXITED_STOP_ERROR,
+        ...sessionFile && fs6.existsSync(sessionFile) ? { sessionFile } : {}
+      };
+    })
+  };
+}
+function foregroundChildStateLabel(run, child) {
+  if (child.status !== "stopped" || child.error !== FOREGROUND_OWNER_EXITED_STOP_ERROR) return child.status;
+  return child.sessionFile ? `interrupted when Pi exited \xB7 resume ${run.runId}` : "interrupted when Pi exited";
+}
+function restoreForegroundRunHistory(state, options = {}) {
+  const sessionId = options.sessionId ?? state.currentSessionId;
+  if (!sessionId) return 0;
+  const dir = historyDir(options.resultsDir ?? DIRS.results);
+  const saved = historyFiles(dir).flatMap((name) => readRunFile(path6.join(dir, name)) ?? []);
+  if (options.observeForeign) {
+    for (const run of saved) if (run.sessionId !== sessionId && hasRunningChild(run)) options.observeForeign(run);
+  }
+  const runs = saved.filter((run) => run.sessionId === sessionId).sort((left, right) => right.updatedAt - left.updatedAt).slice(0, options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
+  state.foregroundRuns ??= /* @__PURE__ */ new Map();
+  let restored = 0;
+  for (const run of runs) {
+    if (state.foregroundRuns.has(run.runId)) continue;
+    const loaded = hasRunningChild(run) ? restoreInterruptedRun(run) : run;
+    if (!loaded) continue;
+    state.foregroundRuns.set(run.runId, loaded);
+    restored += 1;
+  }
+  return restored;
+}
+
 export {
-  currentCompletionOwnerId,
   resolveGitRepositoryIdentity,
   resolveWorkflowChatProgress,
   buildWorkflowChatProgressRows,
@@ -1023,5 +1224,11 @@ export {
   formatAsyncResultTranscript,
   resolveSubagentRunId,
   deliverAsyncRunStop,
-  stopAsyncRun
+  stopAsyncRun,
+  MAX_REMEMBERED_FOREGROUND_RUNS,
+  persistForegroundRun,
+  discardRunningForegroundRun,
+  ownerConfirmedDead,
+  foregroundChildStateLabel,
+  restoreForegroundRunHistory
 };

package/bundle/{chunk-563BHAZ5.js → chunk-7YMXOYEU.js}

@@ -6,33 +6,35 @@ import {
   resolveWorkflowForegroundSteeringTarget,
   steerAsyncRun,
   steerWorkflowForegroundTarget
-} from "./chunk-CEKS3TFO.js";
+} from "./chunk-7IVSUMQQ.js";
 import {
   FLEET_STATUS_WIDGET_KEY,
   reportFleetWarning,
-  runningTone
-} from "./chunk-2ZSNH26H.js";
+  runningTone,
+  stepTaskSummary
+} from "./chunk-M2CTFYT3.js";
 import {
+  foregroundChildStateLabel,
   formatAsyncRunTranscript,
   stopAsyncRun
-} from "./chunk-KSWQVGDW.js";
+} from "./chunk-7PCKZHR5.js";
 import {
   contextModeBadge,
   contextModeLabel,
   decodeUtf8Tail,
   listAsyncRuns
-} from "./chunk-NNLASTQE.js";
-import "./chunk-VJHOELQP.js";
-import "./chunk-BJN5LUQY.js";
+} from "./chunk-VH5OAWVG.js";
+import "./chunk-NRQ75MGH.js";
+import "./chunk-OYF6AFDY.js";
 import "./chunk-NIXWDZZV.js";
-import "./chunk-ZP3HODFH.js";
+import "./chunk-XSWOTIA3.js";
 import "./chunk-7F6RKT6W.js";
 import "./chunk-CTPAE36Y.js";
 import "./chunk-7J4ZXMY7.js";
 import {
   getArtifactPaths,
   getArtifactsDir
-} from "./chunk-3DC5KBVP.js";
+} from "./chunk-5TYMSZX3.js";
 import {
   snapshotExternalRuns
 } from "./chunk-UKG4V45O.js";
@@ -44,7 +46,7 @@ import {
   formatTokens,
   readStatus,
   shortenPath
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   DIRS
 } from "./chunk-5LFLVSTM.js";
@@ -203,18 +205,22 @@ function asyncItems(run, description) {
   if (run.steps.length === 0 || run.mode === "workflow") {
     return [{ key: `async:${run.id}`, kind: "async", runId: run.id, agent: run.mode, state: run.state, updatedAt, run, ...description ? { description } : {} }];
   }
-  return run.steps.map((step) => ({
-    key: `async:${run.id}:${step.index}`,
-    kind: "async",
-    runId: run.id,
-    index: step.index,
-    agent: step.label ? `${step.label} (${step.agent})` : step.agent,
-    state: step.status,
-    updatedAt: step.lastActivityAt ?? updatedAt,
-    run,
-    step,
-    ...description ? { description } : {}
-  }));
+  return run.steps.map((step) => {
+    const task = stepTaskSummary(step, step.agent);
+    return {
+      key: `async:${run.id}:${step.index}`,
+      kind: "async",
+      runId: run.id,
+      index: step.index,
+      agent: step.label ? `${step.label} (${step.agent})` : step.agent,
+      state: step.status,
+      updatedAt: step.lastActivityAt ?? updatedAt,
+      run,
+      step,
+      ...task ? { task } : {},
+      ...description ? { description } : {}
+    };
+  });
 }
 function orderFleetAsyncRuns(runs, terminalLimit, trackedJobs) {
   const updatedAt = (run) => run.lastUpdate ?? run.endedAt ?? run.startedAt;
@@ -503,7 +509,7 @@ function foregroundRecentDetail(item, state) {
   const lines = [
     `Run: ${item.runId}`,
     "Source: foreground",
-    `State: ${child.status}`,
+    `State: ${foregroundChildStateLabel(run, child)}`,
     `Mode: ${run.mode}`,
     `Child: ${child.index} (${child.agent})${contextModeLabel(child.context) ? ` ${contextModeLabel(child.context)}` : ""}`,
     modelThinking ? `Model: ${modelThinking}` : void 0,
@@ -1179,8 +1185,10 @@ var SubagentFleetComponent = class {
       const item = this.snapshot.items[index];
       const marker = index === this.selected ? this.theme.fg("accent", "\u203A") : " ";
       const context = item.kind === "async" ? contextModeBadge(this.theme, item.step?.context ?? item.run.context) : item.kind === "foreground-recent" ? contextModeBadge(this.theme, item.child.context) : "";
-      const agent = index === this.selected ? this.theme.bold(item.agent) : item.agent;
-      const identity = item.runId.slice(0, 8);
+      const task = item.kind === "async" ? item.task : void 0;
+      const name = task && item.kind === "async" && item.step ? item.step.agent : item.agent;
+      const agent = index === this.selected ? this.theme.bold(name) : name;
+      const identity = task ?? item.runId.slice(0, 8);
       const left = `${marker} ${statusGlyph(item, this.theme)} ${agent}${context} ${this.theme.fg("dim", `\xB7 ${identity}`)}`;
       return rightAligned(left, this.theme.fg("dim", item.state), layout.roster.width);
     });