pi-subagents 0.80.0 → 0.82.0

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); });
 }

package/src/extension/index.js

@@ -43,6 +43,7 @@ import { createResultWatcher } from "../runs/background/result-watcher.js";
 import { createResultDeliveryOwnership } from "../runs/background/result-delivery-ownership.js";
 import { createScheduledRunManager } from "../runs/background/scheduled-runs.js";
 import { registerSlashCommands } from "../slash/slash-commands.js";
+import { ADMIN_MESSAGE_TYPE } from "../slash/subagents-admin.js";
 import { registerPromptTemplateDelegationBridge } from "../slash/prompt-template-bridge.js";
 import { registerMainWatchdog } from "../watchdog/register-main.js";
 import { registerSlashSubagentBridge } from "../slash/slash-bridge.js";
@@ -72,10 +73,14 @@ import { loadConfig, resolveAsyncByDefault, resolveScheduledStoreRoot } from "./
 import { buildSubagentToolDescription, buildSubagentToolPromptMetadata } from "./tool-description.js";
 import { formatWorkflowPreflightSummary, normalizeWorkflowPreflight } from "../workflows/workflow-preflight.js";
 import { runtimeReplacedAbortReason } from "../workflows/workflow-reuse.js";
+import { autoResumeFailureText, cancelPendingWorkflowAutoResumes, finishWorkflowAutoResume, planWorkflowAutoResumes, WORKFLOW_AUTO_RESUME_MESSAGE_TYPE } from "../workflows/workflow-auto-resume.js";
+import { recordWorkflowResumeRefusal, releaseWorkflowResumeClaim, resumedRunStarted } from "../workflows/workflow-resume-claim.js";
+import { workflowResumeRefusal } from "../workflows/workflow-resume.js";
 import { finalizeToolResult } from "./tool-result.js";
 import { flattenSubagentToolOptions } from "./subagent-options.js";
 import { collectGoalContinuationNotices } from "../missions/goal-driver.js";
 import { restoreForegroundRunHistory } from "../runs/foreground/foreground-history.js";
+import { createInterruptedElsewhereCollector } from "../runs/background/interrupted-elsewhere.js";
 import { resolveMissionStoreLocation } from "../missions/store.js";
 import { listRetainedChildren } from "../runs/background/retained-children.js";
 import { DIRS, DEFAULT_ARTIFACT_CONFIG, SLASH_RESULT_TYPE, SLASH_TEXT_RESULT_TYPE, SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_PROCESS_TERMINAL_EVENT, SUBAGENT_CONTROL_EVENT, SUBAGENT_STEERING_NOTICE_EVENT, WIDGET_KEY, resolveMaxSubagentSpawnsPerSession, } from "../shared/types.js";
@@ -433,6 +438,7 @@ export default function registerSubagentExtension(pi) {
             refreshResultDelivery();
         },
         onJobCleanup: (asyncId) => deliveredRunIds.delete(asyncId),
+        deliveryOwnerId: resultDeliveryOwnership.deliveryOwnerId,
         supervisorRequestState: supervisorChannel.getSupervisorRequestState,
         onJobsChanged: programStatus.sync,
     });
@@ -557,13 +563,32 @@ export default function registerSubagentExtension(pi) {
             return undefined;
         return createSlashResultComponent(details, options, theme, config.mainWindowRenderer, foregroundDetachShortcut, () => state.lastUiContext?.ui.theme ?? theme);
     });
-    // Keep view-only reports in the transcript/RPC stream, but out of model context.
-    // SLASH_RESULT_TYPE carries delegated work and must remain model-visible.
-    pi.on("context", (event) => ({
-        messages: event.messages.filter((message) => message.role !== "custom"
-            || message.customType !== SLASH_TEXT_RESULT_TYPE
-            || message.details?.viewOnly !== true),
-    }));
+    // Pi sends custom messages to the model as plain user messages, so every model-visible
+    // pi-subagents message is wrapped in a marker naming its source. The marker depends only on
+    // the message, so history renders the same bytes every turn and cached prefixes stay valid.
+    const markedMessageTypes = new Set([...SUBAGENT_MESSAGE_TYPES, "subagent-compaction-resume", SLASH_RESULT_TYPE, SLASH_TEXT_RESULT_TYPE, ADMIN_MESSAGE_TYPE]);
+    pi.on("context", (event) => {
+        const messages = [];
+        for (const message of event.messages) {
+            if (message.role !== "custom" || !markedMessageTypes.has(message.customType)) {
+                messages.push(message);
+                continue;
+            }
+            // Keep view-only reports in the transcript/RPC stream, but out of model context.
+            // SLASH_RESULT_TYPE carries delegated work and must remain model-visible.
+            if (message.customType === SLASH_TEXT_RESULT_TYPE && message.details?.viewOnly === true)
+                continue;
+            const open = `<pi_subagents_notice type="${message.customType}" origin="automated message from the pi-subagents extension, not typed by the user">`;
+            const close = "</pi_subagents_notice>";
+            messages.push({
+                ...message,
+                content: typeof message.content === "string"
+                    ? `${open}\n${message.content}\n${close}`
+                    : [{ type: "text", text: `${open}\n` }, ...message.content, { type: "text", text: `\n${close}` }],
+            });
+        }
+        return { messages };
+    });
     pi.registerMessageRenderer(SLASH_TEXT_RESULT_TYPE, (message, _options, _theme) => {
         const content = typeof message.content === "string"
             ? message.content
@@ -577,6 +602,60 @@ export default function registerSubagentExtension(pi) {
         await waitForAdvertisement();
         return (await getExecutor()).executePublic(id, params, signal, onUpdate, ctx);
     };
+    // Names this runtime's planned auto-resumes in the process-global registry.
+    const autoResumeOwner = {};
+    const postAutoResumeFailure = (sourceRunId, refusal) => {
+        pi.sendMessage({ customType: WORKFLOW_AUTO_RESUME_MESSAGE_TYPE, content: autoResumeFailureText(sourceRunId, refusal), display: true }, { triggerTurn: false });
+    };
+    // Each session start claims its interrupted workflows synchronously, then launches them here, off
+    // session start. Cleanup and the next session start cancel the launches that have not started.
+    const launchWorkflowAutoResume = async (entry, ctx) => {
+        const { prepared } = entry;
+        try {
+            // Let the rest of session start (agent advertisement, other handlers) run first.
+            await new Promise((resolve) => setImmediate(resolve));
+            await waitForAdvertisement();
+            const executor = await getExecutor();
+            if (entry.state !== "pending")
+                return;
+            entry.state = "started";
+            const outcome = await executor.executeWorkflowResume(randomUUID(), prepared, new AbortController().signal, ctx);
+            // The executor has given back the claim and recorded any refusal; nothing below may replace them.
+            // A run launched by a runtime that was cleaned up meanwhile would keep running through its stale context.
+            if (outcome.launched && runtimeCleaned)
+                state.workflowControllers?.get(prepared.newRunId)?.abort(runtimeReplacedAbortReason());
+            // A cleaned-up runtime's pi can no longer post; the refusal stays in the run for its notice.
+            if (outcome.launched || runtimeCleaned)
+                return;
+            try {
+                postAutoResumeFailure(prepared.sourceRunId, outcome.refusal);
+            }
+            catch (error) {
+                console.error(`Failed to post the auto-resume failure of workflow ${prepared.sourceRunId}:`, error);
+            }
+        }
+        catch (error) {
+            // A cancelled launch already gave its claim back.
+            if (entry.state === "cancelled")
+                return;
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to auto-resume workflow ${prepared.sourceRunId}:`, error);
+            try {
+                if (resumedRunStarted(prepared.sourceAsyncDir, prepared.newRunId))
+                    return;
+                releaseWorkflowResumeClaim(prepared.sourceAsyncDir, prepared.newRunId);
+                const refusal = workflowResumeRefusal("launch-failed", `launch failed: ${message}`, prepared.sourceRunId);
+                recordWorkflowResumeRefusal(prepared.sourceAsyncDir, { reason: refusal.reason, byHand: refusal.byHand, newRunId: prepared.newRunId });
+                postAutoResumeFailure(prepared.sourceRunId, refusal);
+            }
+            catch (cleanupError) {
+                console.error(`Failed to give back the auto-resume claim of workflow ${prepared.sourceRunId}:`, cleanupError);
+            }
+        }
+        finally {
+            finishWorkflowAutoResume(entry);
+        }
+    };
     const executeSubagentCollapsed = (id, params, signal, onUpdate, ctx) => {
         if (ctx.hasUI)
             ctx.ui.setToolsExpanded(false);
@@ -853,12 +932,31 @@ export default function registerSubagentExtension(pi) {
         resetJobs(ctx);
         logSlowPhase("reset-jobs", phaseStartedAt);
         phaseStartedAt = Date.now();
-        restoreForegroundRunHistory(state, { resultsDir: DIRS.results });
+        // Runs other sessions in this folder left when their Pi died, from what this restore reads anyway.
+        const interruptedElsewhere = ctx.hasUI ? createInterruptedElsewhereCollector({ currentSessionId: state.currentSessionId, cwd: ctx.cwd, now: Date.now() }) : undefined;
+        restoreForegroundRunHistory(state, { resultsDir: DIRS.results, observeForeign: interruptedElsewhere?.observeForegroundRun });
         logSlowPhase("foreground-history", phaseStartedAt);
         phaseStartedAt = Date.now();
-        restoreActiveJobs(ctx);
+        restoreActiveJobs(ctx, interruptedElsewhere?.observeStatus);
         logSlowPhase("active-job-restore", phaseStartedAt);
         phaseStartedAt = Date.now();
+        // Read-only and UI-only: never sent to the model, so prompts and history are unchanged.
+        if (interruptedElsewhere)
+            for (const line of interruptedElsewhere.lines())
+                ctx.ui.notify(line, "info");
+        logSlowPhase("cross-session-notice", phaseStartedAt);
+        // Before any stored result is delivered, so the interrupted run's notice can name its resume.
+        phaseStartedAt = Date.now();
+        // Launches an earlier session start of this runtime planned and has not started belong to that session.
+        cancelPendingWorkflowAutoResumes((entry) => entry.owner === autoResumeOwner);
+        // Not in a one-shot print run: its turn would then wait on the resumed workflow at settle.
+        if (recovering && ctx.hasUI && config.autoResume !== false) {
+            for (const entry of planWorkflowAutoResumes({ asyncDirRoot: DIRS.async, currentSessionId: state.currentSessionId, now: Date.now(), owner: autoResumeOwner })) {
+                void launchWorkflowAutoResume(entry, ctx);
+            }
+        }
+        logSlowPhase("workflow-auto-resume", phaseStartedAt);
+        phaseStartedAt = Date.now();
         scheduledRunManager.bindSession(ctx);
         logSlowPhase("scheduled-runs", phaseStartedAt);
         phaseStartedAt = Date.now();
@@ -883,6 +981,8 @@ export default function registerSubagentExtension(pi) {
             if (runtimeCleaned)
                 return;
             runtimeCleaned = true;
+            // Synchronously, so a reload's new runtime finds these runs unclaimed when it scans.
+            cancelPendingWorkflowAutoResumes((entry) => entry.owner === autoResumeOwner);
             programStatus.dispose(shutdownReason);
             releaseHostSessionLiveness();
             releaseHostSessionLiveness = () => { };

package/src/extension/schemas.js

@@ -205,7 +205,7 @@ const SubagentParamProperties = {
         description: "true: run the one ```js workflow block written in this same reply (false invalid). String with '/': script file read from request cwd. Other string: named workflow resource. Raw scripts (true or path) have no runs.host.",
     })),
     args: Type.Optional(Type.Unsafe({ type: "object", maxProperties: MAX_ARGS_FIELDS, additionalProperties: true, description: `Plain-JSON args for workflow; ${MAX_ARGS_FIELDS} fields/object, ${MAX_ARGS_ITEMS} items/array, depth ${MAX_ARGS_DEPTH}, ${MAX_ARGS_BYTES / 1024} KiB total; raw-script args are exposed deeply frozen and persisted, so do not include secrets.` })),
-    reuseFrom: Type.Optional(Type.String({ minLength: 1, description: "Exact id of a workflow run stopped by a session handoff or reload; this async workflow reuses its finished children and re-attaches to its running ones." })),
+    reuseFrom: Type.Optional(Type.String({ minLength: 1, description: "Exact id of a workflow run ended by a reload, handoff or Pi exit; this async workflow reuses its finished children and re-attaches to its running ones." })),
     globalConcurrencyLimit: Type.Optional(Type.Integer({ minimum: 1 })),
     maxSubagentSpawnsPerRun: Type.Optional(Type.Integer({ minimum: 1 })),
     preflight: Type.Optional(WorkflowPreflightOverride),
@@ -227,7 +227,7 @@ const SubagentParamProperties = {
     usageBudget: Type.Optional(UsageBudgetOverride),
     agentScope: Type.Optional(Type.String({ description: "user/project/both (default); project wins collisions." })),
     cwd: Type.Optional(Type.String({ description: "Execution/project-pane directory." })),
-    machine: Type.Optional(Type.String({ minLength: 1, maxLength: 128, description: "Herdr saved machine id or label; runs an external CLI agent there. cwd then means the directory on that machine." })),
+    machine: Type.Optional(Type.String({ minLength: 1, maxLength: 128, description: "Herdr saved machine id or label (runs an external CLI agent), a Rex host named in settings (runs a Pi child), or \"local\" (a Pi child in a Rex pane here). On another machine, cwd is a directory there." })),
     artifacts: Type.Optional(Type.Boolean({ description: "Debug artifacts; default true." })),
     includeProgress: Type.Optional(Type.Boolean({ description: "Full result progress; default false." })),
     share: Type.Optional(Type.Boolean({ description: "Upload session to GitHub Gist; default false." })),
@@ -306,6 +306,6 @@ const SubagentWaitParamsSchema = Type.Object({
     nonBlocking: Type.Optional(Type.Boolean({ description: "Subscribe to id's wake and return immediately; requires id, not with all." })),
     all: Type.Optional(Type.Boolean({ description: "Wait for all work active at call time." })),
     timeoutMs: Type.Optional(Type.Integer({ minimum: 1, description: "Max wait; default waitTool.defaultTimeoutMs, then 30 min." })),
-    stopOnAttention: Type.Optional(Type.Boolean({ description: "false: keep waiting through idle or long-thinking attention." })),
+    stopOnAttention: Type.Optional(Type.Boolean({ description: "false: keep waiting through all attention except supervisor requests." })),
 });
 export const SubagentWaitParams = keepTopLevelParameterDescriptions(SubagentWaitParamsSchema);

package/src/intercom/native-supervisor-channel.js

@@ -113,6 +113,8 @@ async function waitForReply(channelDir, requestId, initialDeadline, signal) {
         if (fs.existsSync(file)) {
             const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
             if (parsed.type === "subagent.supervisor.reply" && parsed.requestId === requestId && typeof parsed.message === "string") {
+                if (typeof parsed.error === "string")
+                    throw new Error(parsed.error);
                 return parsed;
             }
         }
@@ -761,6 +763,24 @@ export function createNativeSupervisorChannel(pi, state, deps = {}) {
                 cleanupRequestLifecycle(request, lifecycle);
                 continue;
             }
+            if (request.expectsReply && runState(request).blockingWorkflowChildren?.has(request.runId)) {
+                // Pi cannot deliver an ask behind the workflow tool call that awaits this child.
+                // Return a tool error instead of renewing an unreachable ask until the run deadline.
+                try {
+                    writePrivateAtomicJson(replyPath(channelDir, request.id), {
+                        type: "subagent.supervisor.reply", requestId: request.id, createdAt: now, message: "",
+                        error: "Supervisor unavailable: the parent is blocked in an async:false workflow and cannot answer this request. Report the blocker and any partial results, then stop. Relaunch the workflow with async:true to allow supervisor replies.",
+                    });
+                }
+                catch (error) {
+                    console.error(`Failed to report unreachable supervisor request ${request.id}; will retry:`, error);
+                    continue;
+                }
+                seenFiles.add(file);
+                observeRequestLifecycle(request, "resolved");
+                cleanupRequestLifecycle(request, "resolved");
+                continue;
+            }
             seenFiles.add(file);
             if (!request.expectsReply) {
                 // Progress is already visible through child activity; do not inject a

package/src/missions/lifecycle.js

@@ -253,7 +253,13 @@ export function readMissionBinding(asyncDir) {
     const bindingPath = path.join(asyncDir, MISSION_BINDING_FILE);
     if (!fs.existsSync(bindingPath))
         return undefined;
-    return parsePersistedBinding(JSON.parse(fs.readFileSync(bindingPath, "utf-8")), bindingPath);
+    const raw = fs.readFileSync(bindingPath, "utf-8");
+    try {
+        return parsePersistedBinding(JSON.parse(raw), bindingPath);
+    }
+    catch (error) {
+        throw new Error(`Invalid mission binding file '${bindingPath}': ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
 }
 export function syncMissionFromAsyncCompletion(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))

package/src/runs/background/active-async-capacity.d.ts

@@ -34,6 +34,7 @@ interface CapacityOptions {
     abandonedSlotReleaseAfterMs?: number | false;
     pidLiveness?: (pid: number) => PidLiveness;
     pidNamespaceScope?: () => string | undefined;
+    bootId?: () => string | undefined;
     afterSlotRename?: (releasedDir: string) => void;
     writeOwner?: (filePath: string, owner: ActiveAsyncCapacityOwner) => void;
 }

package/src/runs/background/active-async-capacity.js

@@ -4,7 +4,8 @@ import * as path from "node:path";
 import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
 import { TEMP_ROOT_DIR } from "../../shared/types.js";
 import { readStatus } from "../../shared/utils.js";
-import { checkPidLiveness } from "./stale-run-reconciler.js";
+import { checkPidLiveness, checkRecordedPidLiveness } from "./stale-run-reconciler.js";
+import { currentBootId } from "./boot-id.js";
 import { currentPidNamespaceScope } from "./pid-namespace.js";
 import { readProcessTerminal } from "./process-terminal.js";
 import { isTerminalAsyncState as terminalState, readWorkflowChildEvidence, readWorkflowChildProcessEvidence } from "./workflow-terminal-proof.js";
@@ -201,9 +202,14 @@ function abandonedRunnerReleaseVerdict(status, proofState, options, anyTerminalS
     if (typeof status.pid !== "number" || !Number.isInteger(status.pid) || status.pid < 1)
         return { state: "retained", reason: `${proofReason}; runner PID is missing or invalid` };
     // A PID from another namespace can look dead here while the runner is alive.
-    if (status.pidNamespaceScope !== undefined && status.pidNamespaceScope !== (options.pidNamespaceScope ?? currentPidNamespaceScope)())
+    const observedScope = (options.pidNamespaceScope ?? currentPidNamespaceScope)();
+    if (status.pidNamespaceScope !== undefined && status.pidNamespaceScope !== observedScope)
         return { state: "retained", reason: `${proofReason}; runner PID namespace differs from this process, so liveness is unknown` };
-    const liveness = (options.pidLiveness ?? checkPidLiveness)(status.pid);
+    const liveness = checkRecordedPidLiveness({ pid: status.pid, pidNamespaceScope: status.pidNamespaceScope, bootId: status.bootId }, {
+        observedScope,
+        observedBootId: (options.bootId ?? currentBootId)(),
+        probe: options.pidLiveness ?? ((pid) => checkPidLiveness(pid)),
+    });
     if (liveness !== "dead")
         return { state: "retained", reason: `${proofReason}; runner PID liveness is ${liveness}` };
     const lastActivityAt = status.lastActivityAt ?? status.lastUpdate ?? status.endedAt;

package/src/runs/background/async-execution.js

@@ -13,7 +13,7 @@ import { childCacheRetentionEnv } from "../../shared/child-cache-retention.js";
 import { buildEffectiveSystemPrompt } from "../shared/effective-system-prompt.js";
 import { currentCompletionOwnerId } from "../../shared/completion-owner.js";
 import { planChildLaunch, projectChainOutputSchemas, resolveStepBehavior, suppressProgressForReadOnlyTask } from "../shared/child-launch-plan.js";
-import { formatHerdrMachineRunnerUnsupported, resolveHerdrMachinePlacement } from "../shared/herdr-machine.js";
+import { formatHerdrMachineRunnerUnsupported, resolveMachinePlacement } from "../shared/herdr-machine.js";
 import { applyThinkingSuffix, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan } from "../shared/child-tool-plan.js";
 import { assertClaudeCodeModelScope, isClaudeCodeAdapterId, resolveClaudeCodeOverride } from "../shared/claude-code-adapter.js";
 import { injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
@@ -51,8 +51,9 @@ import { usageBudgetState } from "../shared/usage-budget.js";
 import { finalizeProcessTerminal, initializeProcessTerminal, readProcessTerminal } from "./process-terminal.js";
 import { persistRunnerStartupFailure } from "./runner-startup-failure.js";
 import { statusStepDescription } from "./chain-append.js";
+import { currentBootId, currentRecordedPid } from "./boot-id.js";
 import { currentPidNamespaceScope } from "./pid-namespace.js";
-import { checkPidLiveness } from "./stale-run-reconciler.js";
+import { checkRecordedPidLiveness } from "./stale-run-reconciler.js";
 import { lookupRunnerLauncher, resolveAgentRunnerLauncher, runnerLauncherPlacementError } from "../shared/runner-launcher.js";
 import { SUBAGENT_PROCESS_TERMINAL_EVENT } from "../../shared/types.js";
 import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
@@ -432,7 +433,12 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
     const runnerProcessInstanceId = randomUUID();
     const hasRevivalLease = typeof cfg.revivalLease === "object";
     const launchBarrierToken = hasRevivalLease ? undefined : runnerProcessInstanceId;
-    const launchConfig = { ...cfg, runnerProcessInstanceId, ...(launchBarrierToken ? { launchBarrierToken } : {}) };
+    // A broker launcher may start the runner outside its own process, even under another kernel, so the
+    // spawned pid is only the wrapper's and only a direct runner shares Pi's boot id. The runner reports
+    // its own identity before it is allowed to proceed.
+    const launcher = cfg.launcher;
+    const bootId = launcher ? undefined : currentBootId();
+    const launchConfig = { ...cfg, runnerProcessInstanceId, ...(launchBarrierToken ? { launchBarrierToken } : {}), ...(bootId ? { bootId } : {}) };
     writePrivateAtomicJson(cfgPath, launchConfig);
     const command = binaryHost ?? nodeExecutable;
     const launchForStartup = launchConfig;
@@ -456,9 +462,6 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
         fs.rmSync(startupConfirmPath, { force: true });
     if (startupProceedPath)
         fs.rmSync(startupProceedPath, { force: true });
-    // A broker launcher may start the runner outside its own process, so the spawned pid is only the
-    // wrapper's. The runner reports its own identity before it is allowed to proceed.
-    const launcher = launchConfig.launcher;
     const identityPath = launcher && launchBarrierToken && launchAsyncDir ? path.join(launchAsyncDir, "runner-startup.json") : undefined;
     if (identityPath)
         fs.rmSync(identityPath, { force: true });
@@ -550,7 +553,8 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
                     }
                     // The runner may outlive its wrapper; only a confirmed-dead runner in this pid namespace finalizes here,
                     // otherwise status-pid reconciliation does it later.
-                    if (!runnerIdentity || runnerIdentity.pidNamespaceScope !== currentPidNamespaceScope() || checkPidLiveness(runnerIdentity.pid, process.kill, runnerIdentity.pidNamespaceScope !== undefined) !== "dead")
+                    if (!runnerIdentity || runnerIdentity.pidNamespaceScope !== currentPidNamespaceScope()
+                        || checkRecordedPidLiveness(runnerIdentity) !== "dead")
                         return;
                 }
                 finalizeProcessTerminal(asyncDir, runId, {
@@ -612,7 +616,7 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchP
         try {
             writePrivateAtomicJson(initialStatusPath, {
                 ...initialStatus,
-                ...(launcher ? {} : { pid: proc.pid, pidNamespaceScope: currentPidNamespaceScope() }),
+                ...(launcher ? {} : { pid: proc.pid, pidNamespaceScope: currentPidNamespaceScope(), ...(bootId ? { bootId } : {}) }),
                 processTerminal: { version: 1, state: "pending", runId: initialStatus.runId, runnerProcessInstanceId },
             });
             // Aggregate waits must see the launch before the runner's first status update.
@@ -834,7 +838,7 @@ export function buildAsyncRunnerSteps(id, params) {
         let machineEnv;
         if (requestedMachine) {
             try {
-                const placement = resolveHerdrMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: s.cwd ?? params.machineCwd });
+                const placement = resolveMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: s.cwd ?? params.machineCwd });
                 machine = placement.machine;
                 machineEnv = placement.env;
             }
@@ -1331,6 +1335,7 @@ export function executeAsyncChain(id, params) {
     }
     const initialStatusAt = Date.now();
     const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
+    const completionOwnerProcess = currentRecordedPid();
     const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
     try {
         writeRetainedRequiredChildExtensions(asyncDir, params.requiredExtensions ?? ctx.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(launchParentSessionId ?? undefined));
@@ -1355,6 +1360,7 @@ export function executeAsyncChain(id, params) {
             asyncDir,
             sessionId: ctx.currentSessionId,
             completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
+            completionOwnerProcess,
             ...(capabilityCeiling ? { capabilityCeiling } : {}),
             piPackageRoot,
             childSessionFactoryModule: childSessionFactoryModule(),
@@ -1393,6 +1399,7 @@ export function executeAsyncChain(id, params) {
             runId: id,
             ...(ctx.currentSessionId ? { sessionId: ctx.currentSessionId } : {}),
             ...(initialCompletionOwnerId ? { completionOwnerId: initialCompletionOwnerId } : {}),
+            completionOwnerProcess,
             mode: resultMode,
             state: "running",
             startedAt: initialStatusAt,
@@ -1620,7 +1627,7 @@ export function executeAsyncSingle(id, params) {
     let machineEnv;
     if (requestedMachine) {
         try {
-            const placement = resolveHerdrMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: params.machineCwd });
+            const placement = resolveMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: params.machineCwd });
             machine = placement.machine;
             machineEnv = placement.env;
         }
@@ -1895,6 +1902,7 @@ export function executeAsyncSingle(id, params) {
     let spawnResultOrPromise = {};
     const initialStatusAt = Date.now();
     const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
+    const completionOwnerProcess = currentRecordedPid();
     const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
     try {
         spawnResultOrPromise = spawnRunner({
@@ -1977,6 +1985,7 @@ export function executeAsyncSingle(id, params) {
             asyncDir,
             sessionId: ctx.currentSessionId,
             completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
+            completionOwnerProcess,
             ...(capabilityCeiling ? { capabilityCeiling } : {}),
             piPackageRoot,
             childSessionFactoryModule: childSessionFactoryModule(),
@@ -2018,6 +2027,7 @@ export function executeAsyncSingle(id, params) {
             runId: id,
             ...(ctx.currentSessionId ? { sessionId: ctx.currentSessionId } : {}),
             ...(initialCompletionOwnerId ? { completionOwnerId: initialCompletionOwnerId } : {}),
+            completionOwnerProcess,
             mode: "single",
             ...(params.toolCallId ? { toolCallId: params.toolCallId } : {}),
             state: "running",

package/src/runs/background/async-job-tracker.d.ts

@@ -1,6 +1,8 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import * as fs from "node:fs";
 import { type AsyncJobState, type AsyncWidgetLayout, type ControlEvent, type SubagentState } from "../../shared/types.ts";
+import type { RawDrainStatusObserver } from "../shared/readonly-drain-observation.ts";
+import type { ResultDeliveryOwnership } from "./result-delivery-ownership.ts";
 interface AsyncJobTrackerOptions {
     completionRetentionMs?: number;
     /** Slow safety sweep for liveness repair when filesystem events are missed. */
@@ -12,6 +14,8 @@ interface AsyncJobTrackerOptions {
     platform?: NodeJS.Platform;
     onJobTerminal?: (job: AsyncJobState) => void;
     onJobCleanup?: (asyncId: string) => void;
+    /** Lets a run whose launching Pi exited hold its publication in the session that owns it. */
+    deliveryOwnerId?: ResultDeliveryOwnership["deliveryOwnerId"];
     watch?: typeof fs.watch;
     kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
     now?: () => number;
@@ -26,7 +30,8 @@ export declare function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">,
     handleStarted: (data: unknown) => void;
     handleComplete: (data: unknown) => void;
     resetJobs: (ctx?: ExtensionContext) => void;
-    restoreActiveJobs: (ctx?: ExtensionContext) => void;
+    /** `observeStatus` also sees the statuses of other sessions' runs that the listing skips. */
+    restoreActiveJobs: (ctx?: ExtensionContext, observeStatus?: RawDrainStatusObserver) => void;
     dispose: () => void;
 };
 export {};

package/src/runs/background/async-job-tracker.js

@@ -15,6 +15,7 @@ import { withWorkflowChildRunModel } from "./workflow-terminal-proof.js";
 import { validHostStepNodes } from "../shared/host-step-status.js";
 import { readProcessTerminal } from "./process-terminal.js";
 import { withCachedUiContext } from "../../shared/extension-context.js";
+import { OWNING_SESSION_COMPLETION_OWNER } from "../../shared/completion-owner.js";
 const CONTROL_EVENT_READ_CHUNK_BYTES = 64 * 1024;
 const MAX_CONTROL_EVENT_LINE_BYTES = 1024 * 1024;
 const CONTROL_EVENT_SCAN_WINDOW_BYTES = 2 * 1024 * 1024;
@@ -560,8 +561,11 @@ export function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
                 if (isTerminalJobStatus(job.status)) {
                     let publication = terminalPublications.get(job.asyncId);
                     if (!publication && status.mode !== "workflow" && status.processTerminal?.state === "pending"
-                        && status.runId === job.asyncId && status.sessionId === state.currentSessionId
-                        && status.completionOwnerId && status.completionOwnerId === state.completionOwnerId) {
+                        && status.runId === job.asyncId && status.completionOwnerId
+                        && ((status.sessionId === state.currentSessionId && status.completionOwnerId === state.completionOwnerId)
+                            // Also covers a session inherited after /new or /resume: deliveryOwnerId checks run ownership.
+                            || (typeof status.sessionId === "string"
+                                && options.deliveryOwnerId?.(status.sessionId, status.completionOwnerId, status.completionOwnerProcess, status.parentWorkflowRunId) === OWNING_SESSION_COMPLETION_OWNER))) {
                         publication = { instanceId: status.processTerminal.runnerProcessInstanceId, pending: true };
                         terminalPublications.set(job.asyncId, publication);
                     }
@@ -883,7 +887,7 @@ export function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
             rerenderWidget(ctx, []);
         }
     };
-    const restoreActiveJobs = (ctx) => {
+    const restoreActiveJobs = (ctx, observeStatus) => {
         if (ctx?.hasUI)
             state.lastUiContext = ctx;
         state.statusProjectionSessionId = null;
@@ -891,7 +895,8 @@ export function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
             return;
         let runs;
         try {
-            runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: state.currentSessionId, resultsDir, kill: options.kill, now: options.now });
+            // A workflow whose Pi exited is repaired here, in the session that owns it, which then delivers its notice.
+            runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: state.currentSessionId, resultsDir, kill: options.kill, now: options.now, adoptCompletionOwnerId: state.completionOwnerId }, observeStatus);
         }
         catch (error) {
             console.error(`Failed to restore active async jobs from '${asyncDirRoot}':`, error);

package/src/runs/background/async-status.d.ts

@@ -142,6 +142,8 @@ interface AsyncRunListOptions {
     includeNested?: boolean;
     /** Explicit repair/debug escape hatch. Normal runtime paths must not set this. */
     repairScan?: boolean;
+    /** This process's completion owner, adopted by an owner-exited workflow repair of a run the session owns; needs `sessionId`. */
+    adoptCompletionOwnerId?: string;
 }
 type TargetedAsyncRunResolution = {
     kind: "exact";