@agwab/pi-workflow 0.2.1 → 0.4.0

package/node_modules/@agwab/pi-subagent/src/api.ts

@@ -1,10 +1,16 @@
 import { resolve } from "node:path";
 import { loadAgentByName, type AgentDefinition } from "./agents.ts";
-import type { ResultEnvelope } from "./artifacts/index.ts";
+import {
+	appendRunEvent,
+	type ResultEnvelope,
+	type RunEvent,
+} from "./artifacts/index.ts";
 import type {
 	ExecutionMode,
+	FailureKind,
 	ResolveInput,
 	ResolvedBackend,
+	Status,
 } from "./core/constants.ts";
 import { resolveBackend } from "./core/resolver.ts";
 import { validateResolveInput } from "./core/validation.ts";
@@ -22,6 +28,7 @@ import {
 	type ReconcileSubagentRunOptions as ReconcileRunOptions,
 	type ReconcileSubagentRunResult,
 } from "./orchestrate/reconcile.ts";
+import { resolveRunRef } from "./orchestrate/run-ref.ts";
 import {
 	runParallelSubagentTasks,
 	runSubagentTask,
@@ -50,6 +57,16 @@ export type WaitForSubagentOptions = WaitForRunOptions;
 export type InterruptSubagentOptions = InterruptRunOptions;
 export type ReconcileSubagentOptions = ReconcileRunOptions;
 
+export interface RecordSubagentChildEventOptions extends RunStatusRef {
+	event: "started" | "updated" | "completed" | "failed" | "cancelled";
+	childRunId: string;
+	workflowRunId?: string;
+	childTaskId?: string;
+	status?: Status;
+	failureKind?: FailureKind | string | null;
+	message?: string;
+}
+
 export class SubagentValidationError extends Error {
 	readonly failureKind = "validation" as const;
 	readonly backend?: ResolvedBackend;
@@ -269,6 +286,40 @@ export async function reconcileSubagentRun(
 	return await reconcileRun(options);
 }
 
+function defaultChildStatus(
+	event: RecordSubagentChildEventOptions["event"],
+): Status {
+	if (event === "started" || event === "updated") return "running";
+	if (event === "completed") return "completed";
+	if (event === "cancelled") return "cancelled";
+	return "failed";
+}
+
+export async function recordSubagentChildEvent(
+	options: RecordSubagentChildEventOptions,
+): Promise<RunEvent> {
+	const {
+		event,
+		childRunId,
+		workflowRunId,
+		childTaskId,
+		failureKind,
+		message,
+	} = options;
+	const ref = await resolveRunRef(options);
+	return await appendRunEvent(ref, {
+		type: `child.${event}`,
+		status: options.status ?? defaultChildStatus(event),
+		...(message === undefined ? {} : { message }),
+		data: {
+			childRunId,
+			...(workflowRunId === undefined ? {} : { workflowRunId }),
+			...(childTaskId === undefined ? {} : { taskId: childTaskId }),
+			...(failureKind === undefined ? {} : { failureKind }),
+		},
+	});
+}
+
 export type {
 	ArtifactRef,
 	CompletionMetadata,
@@ -294,6 +345,8 @@ export type { InterruptRunResult } from "./orchestrate/interrupt.ts";
 export type { ReconcileSubagentRunResult } from "./orchestrate/reconcile.ts";
 export type { ParallelRunResult } from "./orchestrate/run.ts";
 export type {
+	RunChildFailureSummary,
+	RunChildSummary,
 	RunLogRef,
 	RunLogsSnapshot,
 	RunStatusRef,

package/node_modules/@agwab/pi-subagent/src/artifacts/registry.ts

@@ -18,6 +18,11 @@ export type RunEventType =
   | "run.cancelled"
   | "run.interrupt_requested"
   | "run.mark_background"
+  | "child.started"
+  | "child.updated"
+  | "child.completed"
+  | "child.failed"
+  | "child.cancelled"
   | "attempt.started"
   | "attempt.process_started"
   | "attempt.heartbeat"
@@ -716,11 +721,11 @@ export async function readRunEvents(ref: RunRef, limit = 50): Promise<RunEvent[]
   const paths = runPaths(ref);
   try {
     const text = await readFile(paths.eventsPath, "utf8");
-    return text
+    const lines = text
       .split(/\r?\n/)
-      .filter(Boolean)
-      .slice(-limit)
-      .map((line) => JSON.parse(line) as RunEvent);
+      .filter(Boolean);
+    const selected = Number.isFinite(limit) ? lines.slice(-limit) : lines;
+    return selected.map((line) => JSON.parse(line) as RunEvent);
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return [];
     throw error;

package/node_modules/@agwab/pi-subagent/src/artifacts/result.ts

@@ -80,6 +80,7 @@ export interface ResultSessionMetadata {
 
 export interface ResultMetadata {
 	contextLengthExceeded: boolean;
+	contextOverflowRecovered?: boolean;
 	provider?: string;
 	model?: string;
 	usage?: unknown;
@@ -89,6 +90,7 @@ export interface ResultMetadata {
 	session?: ResultSessionMetadata;
 	streamErrors?: string[];
 	nonFatalStreamErrors?: string[];
+	recoveredStreamErrors?: string[];
 	parseErrors?: string[];
 }
 
@@ -199,6 +201,9 @@ function normalizeMetadata(input: ResultEnvelopeInput): ResultMetadata {
 	const metadata = input.metadata ?? {};
 	return {
 		contextLengthExceeded: metadata.contextLengthExceeded ?? false,
+		...(metadata.contextOverflowRecovered === undefined
+			? {}
+			: { contextOverflowRecovered: metadata.contextOverflowRecovered }),
 		...(metadata.provider === undefined ? {} : { provider: metadata.provider }),
 		...(metadata.model === undefined ? {} : { model: metadata.model }),
 		...(metadata.usage === undefined ? {} : { usage: metadata.usage }),
@@ -218,6 +223,9 @@ function normalizeMetadata(input: ResultEnvelopeInput): ResultMetadata {
 		...(metadata.nonFatalStreamErrors === undefined
 			? {}
 			: { nonFatalStreamErrors: metadata.nonFatalStreamErrors }),
+		...(metadata.recoveredStreamErrors === undefined
+			? {}
+			: { recoveredStreamErrors: metadata.recoveredStreamErrors }),
 		...(metadata.parseErrors === undefined
 			? {}
 			: { parseErrors: metadata.parseErrors }),

package/node_modules/@agwab/pi-subagent/src/core/constants.ts

@@ -16,6 +16,11 @@ export const FAILURE_KINDS = [
 	"sandbox",
 	"rpc",
 	"model",
+	"provider_error",
+	"model_error",
+	"output_schema_error",
+	"guard_failure",
+	"user_cancelled",
 	"tool",
 	"exit",
 	"parse",
@@ -109,6 +114,10 @@ export interface ResolveInput {
 	mode?: ExecutionMode;
 	tasks?: SubagentTaskInput[];
 	concurrency?: number;
+	/** Stop scheduling additional parallel siblings after the first failed result. */
+	failFast?: boolean;
+	/** Abort already-running parallel siblings after the first failed result. Implies fail-fast scheduling. */
+	cancelSiblingsOnFailure?: boolean;
 	asyncDependency?: AsyncDependency;
 	workspace?: WorkspaceInput | WorkspaceMode;
 	worktree?: boolean | string;

package/node_modules/@agwab/pi-subagent/src/core/validation.ts

@@ -572,6 +572,27 @@ export function validateResolveInput(
 		input.concurrency = concurrency;
 	}
 
+	if (raw.failFast !== undefined) {
+		const failFast = validateBoolean(
+			raw.failFast,
+			"failFast",
+			backendForKnownFailure,
+		);
+		if (typeof failFast !== "boolean") return failFast;
+		input.failFast = failFast;
+	}
+
+	if (raw.cancelSiblingsOnFailure !== undefined) {
+		const cancelSiblingsOnFailure = validateBoolean(
+			raw.cancelSiblingsOnFailure,
+			"cancelSiblingsOnFailure",
+			backendForKnownFailure,
+		);
+		if (typeof cancelSiblingsOnFailure !== "boolean")
+			return cancelSiblingsOnFailure;
+		input.cancelSiblingsOnFailure = cancelSiblingsOnFailure;
+	}
+
 	if (raw.chain !== undefined) {
 		return failure(
 			'chain mode is not supported by pi-subagent; use mode:"parallel" for fanout or have the parent orchestrate sequencing.',