pi-subagents 0.81.0 → 0.82.1

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-2ZSNH26H.js → chunk-4Y2ROR7L.js}

@@ -1,6 +1,6 @@
 import {
   buildWorkflowChatProgressRows
-} from "./chunk-KSWQVGDW.js";
+} from "./chunk-FXUXCX2K.js";
 import {
   aggregateStepStatus,
   contextModeBadge,
@@ -25,13 +25,13 @@ import {
   projectWorkflowChecklist,
   withCachedUiContext,
   workflowGraphStageNodes
-} from "./chunk-NNLASTQE.js";
+} from "./chunk-6XJB7PIX.js";
 import {
   flatToLogicalStepIndex,
   formatWorkflowJsonPreview,
   hostStepReportName,
   hostStepVerdictLabel
-} from "./chunk-VJHOELQP.js";
+} from "./chunk-46XKCPJR.js";
 import {
   snapshotExternalRuns
 } from "./chunk-UKG4V45O.js";
@@ -49,7 +49,7 @@ import {
   getSingleResultOutput,
   shortenPath,
   unresolvedChildWatchdogBlockers
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   MAX_WIDGET_JOBS,
   WIDGET_ANIMATION_INTERVAL_MS,
@@ -1029,12 +1029,11 @@ function shouldCollapseSingleChildDetails(job, step) {
   if (job.status === "complete") return isCompletedWidgetStepStatus(step.status);
   return false;
 }
-function singleChildTask(job, step) {
+function stepTaskSummary(step, agentName) {
   const task = compactTaskText(step.description, step.label);
   if (task) return task;
   const sessionName = step.sessionName?.trim();
   if (!sessionName) return void 0;
-  const agentName = singleChildAgentName(job, step);
   const sessionTask = stripRepeatedAgentPrefix(sessionName, agentName);
   return sessionTask === agentName ? void 0 : compactTaskText(sessionTask);
 }
@@ -1952,7 +1951,7 @@ function foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index, tota
   const lines = [`${rowIndent}${rowMarker}${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index - 1), frame, thinking)} ${themeBold(theme, rowLabel)}${contextModeBadge(theme, step.context)} ${theme.fg("dim", "\xB7")} ${status}${modelDisplay}${stats ? ` ${theme.fg("dim", "\xB7")} ${stats}` : ""}`];
   const lane = projectAsyncLane(job, step);
   if (lane) lines.push(...formatLaneProjectionLines(lane, theme, detailIndent));
-  const task = collapseDetails ? singleChildTask(job, step) : compactTaskText(step.description, step.label);
+  const task = collapseDetails ? stepTaskSummary(step, displayName) : compactTaskText(step.description, step.label);
   if (task) lines.push(`${detailIndent}${theme.fg("dim", `task: ${task}`)}`);
   const activity = widgetStepActivityLine(step, width, expanded, job.updatedAt);
   const currentPath = options?.includeCurrentPath && step.currentPath ? shortenPath(step.currentPath) : void 0;
@@ -4153,6 +4152,7 @@ export {
   buildAsyncStatusSnapshotForState,
   clearLegacyResultAnimationTimer,
   widgetRenderKey,
+  stepTaskSummary,
   setInlineWorkflowCoverage,
   renderWidget,
   renderSubagentSummary,

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-NNLASTQE.js → chunk-6XJB7PIX.js}

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

package/bundle/{chunk-ZBC44JJ3.js → chunk-CIZQXJ5Q.js}

@@ -307,6 +307,15 @@ function parseFrontmatterList(raw) {
     return item.split(",");
   }).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;
+}
+function parseUnquotedList(raw) {
+  return parseFrontmatterList(raw)?.map(unquoteName);
+}
 function parseFrontmatter(content) {
   const frontmatter = {};
   const normalized = content.replace(/\r\n/g, "\n");
@@ -350,7 +359,10 @@ function parseFrontmatter(content) {
       const [key, rawValueValue] = match.slice(1);
       if (key === void 0 || rawValueValue === void 0) 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";
+      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 === "|-");
@@ -4045,7 +4057,8 @@ function readMemoryFile(memoryDir) {
   let fd;
   try {
     const noFollow = typeof fs9.constants.O_NOFOLLOW === "number" ? fs9.constants.O_NOFOLLOW : 0;
-    fd = fs9.openSync(file, fs9.constants.O_RDONLY | noFollow);
+    const nonBlock = typeof fs9.constants.O_NONBLOCK === "number" ? fs9.constants.O_NONBLOCK : 0;
+    fd = fs9.openSync(file, fs9.constants.O_RDONLY | noFollow | nonBlock);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
     return code === "ELOOP" ? "unsafe" : null;
@@ -5691,11 +5704,11 @@ function loadAgentsFromDefinitionFiles(files, source, discoveryPriority, package
         else if (frontmatter.advertise === "false") advertise = false;
         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 === void 0 ? void 0 : normalizeCapabilityCeilingAllowedAgents(parsedAllowedAgents);
       const defaultReads = parseFrontmatterList(frontmatter.defaultReads);
@@ -5744,9 +5757,9 @@ function loadAgentsFromDefinitionFiles(files, source, discoveryPriority, package
         if (frontmatter.acceptanceRole === "read-only" || frontmatter.acceptanceRole === "writer") acceptanceRole = frontmatter.acceptanceRole;
         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 !== void 0) {
         if (frontmatter.fast === "true") fast = true;
@@ -7824,7 +7837,7 @@ function readOptionalJsonFile(filePath, label) {
     return JSON.parse(fs15.readFileSync(filePath, "utf-8"));
   } catch (error) {
     const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
-    if (code === "ENOENT") return null;
+    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}`, {
       cause: error instanceof Error ? error : void 0
@@ -8393,7 +8406,7 @@ export {
   resolveExternalCliRunnerStatus,
   normalizeExternalCliRunnerStatus,
   externalCliReceiptMetadata,
-  parseFrontmatterList,
+  parseUnquotedList,
   parseFrontmatter,
   resolveSkills,
   resolveSkillsWithFallback,

package/bundle/{chunk-KSWQVGDW.js → chunk-FXUXCX2K.js}

@@ -11,11 +11,15 @@ import {
   resolveAsyncStatusChild,
   stopStoppableAsyncStatusChildren,
   summarizeContextModes,
+  utf8Tail,
   workflowPreflightLaneForRuntimeKey
-} from "./chunk-NNLASTQE.js";
+} from "./chunk-6XJB7PIX.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-46XKCPJR.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
 };