pi-subagents 0.80.0 → 0.82.0

package/src/runs/foreground/foreground-history.js

@@ -5,12 +5,18 @@ import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
 import { utf8Tail } from "../../shared/utf8.js";
 import { validateAcceptanceInput } from "../shared/acceptance.js";
 import { validateModelResponseAliases } from "../../shared/model-response-aliases.js";
+import { checkRecordedPidLiveness, isRecordedPid } from "../background/stale-run-reconciler.js";
+import { encodeIndexSegment } from "../background/index-segment.js";
 export const MAX_REMEMBERED_FOREGROUND_RUNS = 50;
-const HISTORY_VERSION = 1;
+export const FOREGROUND_OWNER_EXITED_STOP_ERROR = "Subagent stopped because the Pi process that ran it exited before the run finished.";
 const MAX_INLINE_OUTPUT_BYTES = 64 * 1024;
 const MAX_RESUME_CONTRACT_BYTES = 64 * 1024;
-function historyPath(resultsDir) {
-    return path.join(resultsDir, "foreground-history.json");
+// One file per run, so Pi processes sharing the results dir never rewrite each other's records.
+function historyDir(resultsDir) {
+    return path.join(resultsDir, "foreground-history");
+}
+function runHistoryPath(resultsDir, runId) {
+    return path.join(historyDir(resultsDir), `${encodeIndexSegment(runId)}.json`);
 }
 function boundedTail(value) {
     return utf8Tail(value, MAX_INLINE_OUTPUT_BYTES).text;
@@ -57,6 +63,13 @@ function compactChild(child) {
 function isRestorableForegroundStatus(status) {
     return status === "completed" || status === "failed" || status === "paused" || status === "stopped";
 }
+function hasRunningChild(run) {
+    return run.children.some((child) => child.status === "running");
+}
+/** A `running` record is kept only for a single run whose owning Pi process can be probed later. */
+function isAdmittedChildStatus(run, status) {
+    return isRestorableForegroundStatus(status) || (status === "running" && run.mode === "single" && isRecordedPid(run.owner));
+}
 function isRestorableResumeContract(value) {
     if (value === undefined)
         return true;
@@ -86,8 +99,9 @@ function isRestorableResumeContract(value) {
 function compactRun(run) {
     if (!run.sessionId)
         return undefined;
-    if (run.children.length === 0 || !run.children.every((child) => isRestorableForegroundStatus(child.status) && isRestorableResumeContract(child.resumeContract)))
+    if (run.children.length === 0 || !run.children.every((child) => isAdmittedChildStatus(run, child.status) && isRestorableResumeContract(child.resumeContract)))
         return undefined;
+    const running = hasRunningChild(run);
     return {
         runId: run.runId,
         mode: run.mode,
@@ -95,23 +109,26 @@ function compactRun(run) {
         sessionId: run.sessionId,
         updatedAt: run.updatedAt,
         children: run.children.map(compactChild),
+        ...(running ? { owner: run.owner } : {}),
+        ...(run.parentWorkflowRunId ? { parentWorkflowRunId: run.parentWorkflowRunId } : {}),
     };
 }
-function readIndex(resultsDir) {
-    const filePath = historyPath(resultsDir);
-    if (!fs.existsSync(filePath))
-        return { version: HISTORY_VERSION, runs: [] };
+/** One saved run, or undefined when the file is missing, unreadable or invalid. */
+function readRunFile(filePath) {
     try {
         const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-            return { version: HISTORY_VERSION, runs: [] };
-        const record = parsed;
-        if (record.version !== HISTORY_VERSION || !Array.isArray(record.runs))
-            return { version: HISTORY_VERSION, runs: [] };
-        return { version: HISTORY_VERSION, runs: record.runs.filter(isRestorableRun) };
+        return isRestorableRun(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function historyFiles(dir) {
+    try {
+        return fs.readdirSync(dir).filter((name) => name.endsWith(".json"));
     }
     catch {
-        return { version: HISTORY_VERSION, runs: [] };
+        return [];
     }
 }
 function isRestorableRun(value) {
@@ -125,40 +142,125 @@ function isRestorableRun(value) {
         && typeof run.updatedAt === "number" && Number.isFinite(run.updatedAt)
         && Array.isArray(run.children)
         && run.children.length > 0
+        && (run.owner === undefined || isRecordedPid(run.owner))
+        && (run.parentWorkflowRunId === undefined || 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)
-            && isRestorableForegroundStatus(child.status)));
+            && isAdmittedChildStatus(run, child.status)));
 }
-function sortAndBound(runs, limit) {
-    return [...runs].sort((left, right) => right.updatedAt - left.updatedAt).slice(0, limit);
+/** Deletes the oldest final run files beyond the cap; running records stay, so the cap can be exceeded while runs are live. */
+function pruneHistory(dir, limit) {
+    const files = historyFiles(dir);
+    if (files.length <= limit)
+        return;
+    const byAge = files.flatMap((name) => {
+        try {
+            return [{ name, mtimeMs: fs.statSync(path.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 = path.join(dir, name);
+        // A running record is replaced later by its run's final save, possibly in another Pi process;
+        // once its owner is confirmed dead nothing can replace it, so it is final.
+        const run = readRunFile(filePath);
+        if (run && hasRunningChild(run) && !ownerConfirmedDead(run))
+            continue;
+        // A file rewritten since the snapshot is a fresh record, not the old one judged here.
+        try {
+            if (fs.statSync(filePath).mtimeMs !== mtimeMs)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        fs.rmSync(filePath, { force: true });
+    }
 }
-export function persistForegroundRunHistory(state, options = {}) {
+/**
+ * Saves one foreground run to its own history file. A run with a `running` child is a launch-time
+ * record; the run's final save replaces it.
+ */
+export function persistForegroundRun(run, options = {}) {
+    const compact = compactRun(run);
+    if (!compact)
+        return;
     const resultsDir = options.resultsDir ?? DIRS.results;
-    const limit = options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS;
-    const existing = readIndex(resultsDir);
-    const merged = new Map(existing.runs.map((run) => [run.runId, run]));
-    for (const run of state.foregroundRuns?.values() ?? []) {
-        const compact = compactRun(run);
-        if (compact)
-            merged.set(compact.runId, compact);
+    const dir = historyDir(resultsDir);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+        // The single shared file used before per-run files is not read or migrated.
+        fs.rmSync(path.join(resultsDir, "foreground-history.json"), { force: true });
     }
-    const runs = sortAndBound([...merged.values()], limit);
-    writePrivateAtomicJson(historyPath(resultsDir), { version: HISTORY_VERSION, runs });
+    writePrivateAtomicJson(runHistoryPath(resultsDir, compact.runId), compact);
+    pruneHistory(dir, options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
+}
+/** Drops this process's `running` record for a launch that threw, so it never loads as interrupted. */
+export 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)
+        fs.rmSync(filePath, { force: true });
+}
+/** For a record with a `running` child: its owning Pi process is gone. */
+export function ownerConfirmedDead(run) {
+    // readRunFile admits a running child only with a valid owner.
+    return checkRecordedPidLiveness(run.owner) === "dead";
+}
+/** A run whose owning Pi process is gone loads as stopped and resumable; one whose owner may be alive is not loaded. */
+function restoreInterruptedRun(run) {
+    if (!ownerConfirmedDead(run))
+        return undefined;
+    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 && fs.existsSync(sessionFile) ? { sessionFile } : {}),
+            };
+        }),
+    };
+}
+/** State text for a remembered child; a child cut off by a Pi exit names the resume target. */
+export function foregroundChildStateLabel(run, child) {
+    if (child.status !== "stopped" || child.error !== FOREGROUND_OWNER_EXITED_STOP_ERROR)
+        return child.status;
+    // Without a transcript there is nothing to resume from.
+    return child.sessionFile ? `interrupted when Pi exited · resume ${run.runId}` : "interrupted when Pi exited";
 }
 export function restoreForegroundRunHistory(state, options = {}) {
     const sessionId = options.sessionId ?? state.currentSessionId;
     if (!sessionId)
         return 0;
-    const index = readIndex(options.resultsDir ?? DIRS.results);
-    const runs = sortAndBound(index.runs.filter((run) => run.sessionId === sessionId), options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
+    const dir = historyDir(options.resultsDir ?? DIRS.results);
+    const saved = historyFiles(dir).flatMap((name) => readRunFile(path.join(dir, name)) ?? []);
+    // Other sessions' records that may have been cut off, for a read-only pointer to them.
+    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 ??= new Map();
     let restored = 0;
     for (const run of runs) {
         if (state.foregroundRuns.has(run.runId))
             continue;
-        state.foregroundRuns.set(run.runId, run);
+        const loaded = hasRunningChild(run) ? restoreInterruptedRun(run) : run;
+        if (!loaded)
+            continue;
+        state.foregroundRuns.set(run.runId, loaded);
         restored += 1;
     }
     return restored;

package/src/runs/foreground/subagent-executor.d.ts

@@ -15,6 +15,7 @@ import { steerAsyncRun } from "./async-steering-action.ts";
 import type { ChildRuntimeConfig } from "../shared/child-runtime-config.ts";
 import { type MissionLaunchBinding } from "../../missions/lifecycle.ts";
 import { type WorkflowSteerOptions, type WorkflowSteerResult } from "../../workflows/scripted-workflow.ts";
+import { type PreparedWorkflowResume, type WorkflowResumeRefusalReason } from "../../workflows/workflow-resume.ts";
 import { type AcceptanceInput, type AgentContract, type ControlConfig, type Details, type ExtensionConfig, type IntercomBridgeConfig, type JsonSchemaObject, type MaxOutputConfig, type ResolvedControlConfig, type RunFanoutBudgetDescriptor, type SteeringRecoveryDescriptor, type SingleResult, type ToolBudgetConfig, type UsageBudgetConfig, type SubagentState, type ScheduleOrigin } from "../../shared/types.ts";
 export declare function unknownSubagentActionMessage(action: string, disabled?: DisabledFeatureSurface): string;
 interface TaskParam {
@@ -287,6 +288,14 @@ export declare function resolveRevivalControlConfig(input: {
     requestedControl?: ControlConfig;
     recoveryControlConfig?: ResolvedControlConfig;
 }): ResolvedControlConfig;
+type WorkflowResumeOutcome = {
+    result: AgentToolResult<Details>;
+} & ({
+    launched: true;
+} | {
+    launched: false;
+    refusal: WorkflowResumeRefusalReason;
+});
 export declare function createSubagentExecutor(deps: ExecutorDeps): {
     execute: (id: string, params: SubagentParamsLike, signal: AbortSignal, onUpdate: ((r: AgentToolResult<Details>) => void) | undefined, ctx: ExtensionContext) => Promise<AgentToolResult<Details>>;
     /** Public/model-facing execution boundary. Internal direct launch primitives use execute or executeDelegated. */
@@ -299,6 +308,8 @@ export declare function createSubagentExecutor(deps: ExecutorDeps): {
     executeDelegated: (id: string, params: SubagentParamsLike, signal: AbortSignal, onUpdate: ((r: AgentToolResult<Details>) => void) | undefined, ctx: ExtensionContext) => Promise<AgentToolResult<Details>>;
     /** Scheduled launches retain their owning context without replacing the live active session. */
     executeScheduled: (id: string, params: SubagentParamsLike, signal: AbortSignal, ctx: ExtensionContext) => Promise<AgentToolResult<Details>>;
+    /** Relaunches a stopped workflow claimed by prepareWorkflowResume (resume by id and auto-resume); a launch that did not start gives up its claim. */
+    executeWorkflowResume: (id: string, prepared: PreparedWorkflowResume, signal: AbortSignal, ctx: ExtensionContext) => Promise<WorkflowResumeOutcome>;
     /** Scheduled state visible to the current runtime supervisor owner only. */
     getCurrentSupervisorOwnerStates: () => Iterable<SubagentState>;
 };