pi-subagents 0.68.0 → 0.70.0

package/src/runs/background/auto-drain.ts

@@ -1,92 +0,0 @@
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import { snapshotBackgroundWork } from "../../api/background-work.ts";
-import type { Details, SubagentState } from "../../shared/types.ts";
-import { listAsyncRuns } from "./async-status.ts";
-import type { ReadonlyDrainObservation } from "../shared/readonly-drain-observation.ts";
-import { waitForSubagents, waitRunScopes, type SubagentWaitDeps, type SubagentWaitParams, type WaitEventBus } from "./subagent-wait.ts";
-
-export const DEFAULT_AUTO_DRAIN_TIMEOUT_MS = 30 * 60 * 1000;
-
-export interface AutoDrainDeps extends Pick<SubagentWaitDeps, "asyncDirRoot" | "resultsDir" | "nestedRootRunId"> {
-	state: SubagentState;
-	events?: WaitEventBus;
-	timeoutMs?: number;
-	now?: () => number;
-	wait?: (
-		params: SubagentWaitParams,
-		signal: AbortSignal | undefined,
-		deps: SubagentWaitDeps,
-	) => Promise<AgentToolResult<Details>>;
-	hasWork?: (sessionId: string, nowMs: number) => boolean;
-	hasPendingSupervisorRequest?: () => boolean;
-}
-
-function resultText(value: AgentToolResult<Details>): string {
-	return value.content.map((part) => part.type === "text" ? part.text : "").join(" ").trim();
-}
-
-function hasOutstandingWork(deps: AutoDrainDeps, sessionId: string, nowMs: number, observation?: ReadonlyDrainObservation): boolean {
-	const asyncRuns = waitRunScopes(deps).flatMap(({ asyncDirRoot, resultsDir }) => listAsyncRuns(asyncDirRoot, {
-		states: ["queued", "running"],
-		sessionId,
-		resultsDir,
-		now: () => nowMs,
-		includeNested: false,
-	}, observation?.status));
-	const detachedForeground = [...(deps.state.foregroundRuns?.values() ?? [])].some((run) =>
-		run.sessionId === sessionId && run.children.some((child) => child.status === "detached")
-	);
-	return asyncRuns.length > 0 || snapshotBackgroundWork(sessionId, nowMs).items.length > 0 || detachedForeground;
-}
-
-/** Drain all work owned by the current headless session, including work added while draining. */
-export async function drainOutstandingWork(deps: AutoDrainDeps, observation?: ReadonlyDrainObservation): Promise<void> {
-	const sessionId = deps.state.currentSessionId;
-	observation?.begin(sessionId, !deps.hasWork && !deps.wait && !deps.now && !deps.hasPendingSupervisorRequest);
-	try {
-		if (!sessionId) throw new Error("Cannot auto-drain background work without an active session identity.");
-		const now = deps.now ?? Date.now;
-		const timeoutMs = deps.timeoutMs ?? DEFAULT_AUTO_DRAIN_TIMEOUT_MS;
-		if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error("Auto-drain timeoutMs must be a positive finite number.");
-		const deadlineAt = now() + timeoutMs;
-		const hasWork = deps.hasWork ?? ((id: string, time: number) => hasOutstandingWork(deps, id, time, observation));
-		const wait = deps.wait ?? waitForSubagents;
-
-		while (true) {
-			if (deps.state.currentSessionId !== sessionId) throw new Error("Auto-drain stopped because the active session changed.");
-			if (deps.hasPendingSupervisorRequest?.()) break;
-			const work = hasWork(sessionId, now());
-			observation?.predicate(work);
-			if (!work) break;
-			const remainingMs = deadlineAt - now();
-			if (remainingMs <= 0) {
-				throw new Error(`Auto-drain timed out after ${timeoutMs}ms with background work still active in session '${sessionId}'.`);
-			}
-			const waitResult = await wait(
-				{ all: true, timeoutMs: remainingMs },
-				undefined,
-				{
-					state: deps.state,
-					asyncDirRoot: deps.asyncDirRoot,
-					resultsDir: deps.resultsDir,
-					nestedRootRunId: deps.nestedRootRunId,
-					events: deps.events,
-					now,
-					stopOnAttention: false,
-					failOnFailedRuns: true,
-					failOnAttention: true,
-					hasPendingSupervisorRequest: deps.hasPendingSupervisorRequest,
-				},
-			);
-			if (waitResult.isError) {
-				throw new Error(`Auto-drain failed for session '${sessionId}': ${resultText(waitResult) || "bg_wait returned an error without details"}.`);
-			}
-			if (waitResult.details.wait?.reason === "supervisor_request") break;
-			if (deps.hasPendingSupervisorRequest?.()) break;
-		}
-		observation?.complete();
-	} catch (error) {
-		observation?.deny();
-		throw error;
-	}
-}

package/src/runs/background/binary-bootstrap.ts

@@ -1,38 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as sdk from "@earendil-works/pi-coding-agent";
-import { installRunnerHttpDispatcher } from "./runner-http-dispatcher.ts";
-import { runConfiguredSubagent, type SubagentRunConfig } from "./subagent-runner.ts";
-import { getAgentDir } from "../../shared/utils.ts";
-
-/**
- * Pi's extension loader supplies the embedded SDK. Bare Bun/Node cannot replace
- * it: an apparent import success can be an auto-installed, different SDK.
- * Await the configured runner inside extension initialization so the outer Pi
- * session/RPC loop never starts. Exit only after shared disposal/lease release.
- * Derived from xz-dev's PR #2049, commit 910807bfefcf9ee41d73fa25ec86dcd75ab8f4b2.
- */
-export default async function runBinaryBootstrap(): Promise<never> {
-	const configPath = process.env.PI_SUBAGENT_RUNNER_CONFIG;
-	delete process.env.PI_SUBAGENT_RUNNER_CONFIG;
-	try {
-		if (!configPath || !path.isAbsolute(configPath)) throw new Error("Missing absolute PI_SUBAGENT_RUNNER_CONFIG path");
-		const config = JSON.parse(fs.readFileSync(configPath, "utf8")) as SubagentRunConfig;
-		if (!config || typeof config.id !== "string" || typeof config.asyncDir !== "string" || !Array.isArray(config.steps)) {
-			throw new Error("Invalid binary runner configuration");
-		}
-		try {
-			fs.unlinkSync(configPath);
-		} catch {
-			// Temp-config cleanup is best effort, as in the Node entrypoint.
-		}
-		// Pi applies httpIdleTimeoutMs to its dispatcher only after extension
-		// factories return; this factory never does, so install the runner's own.
-		installRunnerHttpDispatcher({ agentDir: getAgentDir(), cwd: process.cwd() });
-		await runConfiguredSubagent(config, { loadPiCodingAgent: async () => sdk });
-		process.exit(0);
-	} catch (error) {
-		console.error("Subagent binary runner error:", error);
-		process.exit(1);
-	}
-}

package/src/runs/background/chain-append.ts

@@ -1,321 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { writeAtomicJson } from "../../shared/atomic-json.ts";
-import { appendJsonl } from "../../shared/artifacts.ts";
-import type { AsyncStatus, WorkflowGraphNode, WorkflowGraphSnapshot } from "../../shared/types.ts";
-import { PROMPT_REDACTED, readStatus } from "../../shared/utils.ts";
-import { deriveChildSessionName } from "../../shared/child-session-name.ts";
-import type { DynamicRunnerGroup, ParallelStepGroup, RunnerStep, RunnerSubagentStep } from "../shared/parallel-utils.ts";
-import { isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.ts";
-
-const APPEND_REQUESTS_DIR = "append-requests";
-
-export interface ChainAppendRequest {
-	id: string;
-	createdAt: number;
-	steps: RunnerStep[];
-}
-
-export interface ChainAppendResult {
-	request: ChainAppendRequest;
-	pendingCount: number;
-	bookkeepingError?: string;
-}
-
-type StatusStep = NonNullable<AsyncStatus["steps"]>[number];
-
-function appendDir(asyncDir: string): string {
-	return path.join(asyncDir, APPEND_REQUESTS_DIR);
-}
-
-function appendRequestPath(asyncDir: string, request: ChainAppendRequest): string {
-	return path.join(appendDir(asyncDir), `${request.createdAt}-${request.id}.json`);
-}
-
-function listAppendRequestFiles(asyncDir: string): string[] {
-	const dir = appendDir(asyncDir);
-	try {
-		return fs.readdirSync(dir)
-			.filter((entry) => entry.endsWith(".json"))
-			.map((entry) => path.join(dir, entry))
-			.sort();
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw error;
-	}
-}
-
-export function countPendingChainAppendRequests(asyncDir: string): number {
-	return listAppendRequestFiles(asyncDir).length;
-}
-
-export function runnerStepOutputNames(steps: RunnerStep[]): string[] {
-	const names: string[] = [];
-	for (const step of steps) {
-		if (isParallelGroup(step)) {
-			names.push(...step.parallel.map((task) => task.outputName).filter((name): name is string => Boolean(name)));
-		} else if (isDynamicRunnerGroup(step)) {
-			if (step.collect.as) names.push(step.collect.as);
-		} else if (step.outputName) {
-			names.push(step.outputName);
-		}
-	}
-	return names;
-}
-
-export function enqueueChainAppendRequest(input: {
-	asyncDir: string;
-	runId: string;
-	steps: RunnerStep[];
-	now?: number;
-	admit?: (persist: () => void) => void;
-}): ChainAppendResult {
-	const status = readStatus(input.asyncDir);
-	if (!status) throw new Error(`No async run status found for '${input.runId}'.`);
-	if (status.runId !== input.runId) throw new Error(`Async run id mismatch: expected '${input.runId}', found '${status.runId}'.`);
-	if (status.mode !== "chain") throw new Error(`Run '${input.runId}' is ${status.mode}; only active chain runs accept appended steps.`);
-	if (status.state !== "running") throw new Error(`Run '${input.runId}' is ${status.state}; only running chain runs accept appended steps.`);
-	const stillInProgress = (status.steps ?? []).some((step) => step.status === "running" || step.status === "pending") || (status.pendingAppends ?? 0) > 0;
-	if (!stillInProgress) throw new Error(`Run '${input.runId}' has no running or pending chain steps left; append-step must target an in-progress chain.`);
-	if (input.steps.length === 0) throw new Error("append-step requires one chain step.");
-
-	const request: ChainAppendRequest = {
-		id: randomUUID(),
-		createdAt: input.now ?? Date.now(),
-		steps: input.steps,
-	};
-	fs.mkdirSync(appendDir(input.asyncDir), { recursive: true });
-	const persist = () => writeAtomicJson(appendRequestPath(input.asyncDir, request), request);
-	if (input.admit) input.admit(persist);
-	else persist();
-	let pendingCount = 1;
-	const bookkeepingErrors: string[] = [];
-	try {
-		pendingCount = countPendingChainAppendRequests(input.asyncDir);
-	} catch (error) {
-		bookkeepingErrors.push(`pending append count failed: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const statusPath = path.join(input.asyncDir, "status.json");
-	const updatedStatus = { ...status, pendingAppends: pendingCount, lastUpdate: request.createdAt };
-	try {
-		writeAtomicJson(statusPath, updatedStatus);
-	} catch (error) {
-		bookkeepingErrors.push(`status update failed: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	try {
-		appendJsonl(path.join(input.asyncDir, "events.jsonl"), JSON.stringify({
-			type: "subagent.chain.append.requested",
-			ts: request.createdAt,
-			runId: input.runId,
-			requestId: request.id,
-			stepCount: input.steps.length,
-			pendingAppends: pendingCount,
-		}));
-	} catch (error) {
-		bookkeepingErrors.push(`event append failed: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	return { request, pendingCount, ...(bookkeepingErrors.length > 0 ? { bookkeepingError: bookkeepingErrors.join("; ") } : {}) };
-}
-
-function readAppendRequest(filePath: string): ChainAppendRequest | undefined {
-	const raw = JSON.parse(fs.readFileSync(filePath, "utf-8")) as Partial<ChainAppendRequest>;
-	if (!raw.id || typeof raw.id !== "string") return undefined;
-	const createdAt = raw.createdAt;
-	if (typeof createdAt !== "number" || !Number.isFinite(createdAt)) return undefined;
-	if (!Array.isArray(raw.steps) || raw.steps.length === 0) return undefined;
-	return { id: raw.id, createdAt, steps: raw.steps as RunnerStep[] };
-}
-
-export function readPendingChainAppendRequests(asyncDir: string): ChainAppendRequest[] {
-	return listAppendRequestFiles(asyncDir)
-		.map((filePath) => readAppendRequest(filePath))
-		.filter((request): request is ChainAppendRequest => Boolean(request))
-		.sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id));
-}
-
-export function consumeChainAppendRequests(asyncDir: string): ChainAppendRequest[] {
-	const requests: ChainAppendRequest[] = [];
-	for (const filePath of listAppendRequestFiles(asyncDir)) {
-		const request = readAppendRequest(filePath);
-		try {
-			fs.unlinkSync(filePath);
-		} catch {
-			// The runner should not execute a consumed request twice.
-		}
-		if (request) requests.push(request);
-	}
-	return requests.sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id));
-}
-
-const MAX_STATUS_STEP_DESCRIPTION_CHARS = 160;
-
-/** Bounded one-line per-step task description persisted into status.json for fleet display. */
-export function statusStepDescription(task: string | undefined): string | undefined {
-	if (!task?.trim()) return undefined;
-	const description = PROMPT_REDACTED;
-	return description.length > MAX_STATUS_STEP_DESCRIPTION_CHARS
-		? `${description.slice(0, MAX_STATUS_STEP_DESCRIPTION_CHARS - 1)}…`
-		: description;
-}
-
-function statusStepForTask(task: RunnerSubagentStep): StatusStep {
-	const description = statusStepDescription(task.task);
-	const sessionName = task.sessionName ?? deriveChildSessionName({ agent: task.agent, task: task.task, label: task.label });
-	return {
-		agent: task.agent,
-		...(sessionName ? { sessionName } : {}),
-		...(description ? { description } : {}),
-		...(task.context ? { context: task.context } : {}),
-		phase: task.phase,
-		label: task.label,
-		outputName: task.outputName,
-		structured: task.structured,
-		status: "pending",
-		...(task.sessionFile ? { sessionFile: task.sessionFile } : {}),
-		skills: task.skills,
-		model: task.model,
-		...(task.contextLimit !== undefined ? { contextLimit: task.contextLimit } : {}),
-		thinking: task.thinking,
-		requestedModel: task.requestedModel,
-		recentTools: [],
-		recentOutput: [],
-	};
-}
-
-function statusStepsForRunnerStep(step: RunnerStep): StatusStep[] {
-	if (isParallelGroup(step)) return step.parallel.map(statusStepForTask);
-	if (isDynamicRunnerGroup(step)) {
-		return [{
-			agent: `expand:${step.parallel.agent}`,
-			...(step.parallel.context ? { context: step.parallel.context } : {}),
-			phase: step.phase ?? step.parallel.phase,
-			label: step.label ?? step.parallel.label ?? `Dynamic fanout (${step.collect.as})`,
-			outputName: step.collect.as,
-			structured: Boolean(step.collect.outputSchema),
-			...(step.parallel.contextLimit !== undefined ? { contextLimit: step.parallel.contextLimit } : {}),
-			status: "pending",
-			recentTools: [],
-			recentOutput: [],
-		}];
-	}
-	return [statusStepForTask(step)];
-}
-
-function pushPhase(graph: WorkflowGraphSnapshot, phase: string | undefined, nodeId: string): void {
-	if (!phase) return;
-	let group = graph.phases.find((candidate) => candidate.title === phase);
-	if (!group) {
-		group = { title: phase, nodeIds: [] };
-		graph.phases.push(group);
-	}
-	group.nodeIds.push(nodeId);
-}
-
-function graphNodeForSequential(step: RunnerSubagentStep, stepIndex: number, flatIndex: number): WorkflowGraphNode {
-	return {
-		id: `step-${stepIndex}`,
-		kind: "step",
-		agent: step.agent,
-		phase: step.phase,
-		label: step.label?.trim() || step.agent || `Step ${stepIndex + 1}`,
-		status: "pending",
-		flatIndex,
-		stepIndex,
-		outputName: step.outputName,
-		structured: step.structured,
-	};
-}
-
-function graphNodeForParallel(step: ParallelStepGroup, stepIndex: number, flatIndex: number, graph: WorkflowGraphSnapshot): WorkflowGraphNode {
-	const children = step.parallel.map((task, taskIndex) => {
-		const childId = `step-${stepIndex}-agent-${taskIndex}`;
-		pushPhase(graph, task.phase, childId);
-		return {
-			id: childId,
-			kind: "agent" as const,
-			agent: task.agent,
-			phase: task.phase,
-			label: task.label?.trim() || task.agent || `Agent ${taskIndex + 1}`,
-			status: "pending" as const,
-			flatIndex: flatIndex + taskIndex,
-			stepIndex,
-			outputName: task.outputName,
-			structured: task.structured,
-		};
-	});
-	return {
-		id: `step-${stepIndex}`,
-		kind: "parallel-group",
-		label: step.parallel.length === 1 ? "Parallel task" : `Parallel group (${step.parallel.length})`,
-		status: "pending",
-		stepIndex,
-		children,
-	};
-}
-
-function graphNodeForDynamic(step: DynamicRunnerGroup, stepIndex: number): WorkflowGraphNode {
-	return {
-		id: `step-${stepIndex}`,
-		kind: "dynamic-parallel-group",
-		label: step.label?.trim() || step.parallel.label?.trim() || `Dynamic fanout (${step.collect.as})`,
-		status: "pending",
-		stepIndex,
-		outputName: step.collect.as,
-		structured: Boolean(step.collect.outputSchema),
-		dynamic: {
-			sourceOutput: step.expand.from.output,
-			sourcePath: step.expand.from.path,
-			itemName: step.expand.item ?? "item",
-			maxItems: step.expand.maxItems,
-			collectAs: step.collect.as,
-		},
-		children: [],
-	};
-}
-
-function appendWorkflowNode(graph: WorkflowGraphSnapshot | undefined, step: RunnerStep, stepIndex: number, flatIndex: number): void {
-	if (!graph) return;
-	if (isParallelGroup(step)) {
-		graph.nodes.push(graphNodeForParallel(step, stepIndex, flatIndex, graph));
-		return;
-	}
-	if (isDynamicRunnerGroup(step)) {
-		graph.nodes.push(graphNodeForDynamic(step, stepIndex));
-		return;
-	}
-	const node = graphNodeForSequential(step, stepIndex, flatIndex);
-	graph.nodes.push(node);
-	pushPhase(graph, step.phase, node.id);
-}
-
-export function appendRunnerStepsToStatus(input: {
-	status: AsyncStatus;
-	steps: RunnerStep[];
-	now?: number;
-	pendingAppends?: number;
-}): { addedChainSteps: number; addedFlatSteps: number } {
-	let addedChainSteps = 0;
-	let addedFlatSteps = 0;
-	for (const step of input.steps) {
-		const stepIndex = input.status.chainStepCount ?? input.status.steps?.length ?? 0;
-		const flatIndex = input.status.steps?.length ?? 0;
-		const statusSteps = statusStepsForRunnerStep(step);
-		input.status.steps ??= [];
-		input.status.steps.push(...statusSteps);
-		if (isParallelGroup(step)) {
-			input.status.parallelGroups ??= [];
-			input.status.parallelGroups.push({ start: flatIndex, count: step.parallel.length, stepIndex });
-		} else if (isDynamicRunnerGroup(step)) {
-			input.status.parallelGroups ??= [];
-			input.status.parallelGroups.push({ start: flatIndex, count: 1, stepIndex });
-		}
-		appendWorkflowNode(input.status.workflowGraph, step, stepIndex, flatIndex);
-		input.status.chainStepCount = stepIndex + 1;
-		addedChainSteps++;
-		addedFlatSteps += statusSteps.length;
-	}
-	input.status.pendingAppends = input.pendingAppends ?? 0;
-	input.status.lastUpdate = input.now ?? Date.now();
-	return { addedChainSteps, addedFlatSteps };
-}