@agwab/pi-workflow 0.2.1 → 0.4.0

package/node_modules/@agwab/pi-subagent/src/runners/headless-model.ts

@@ -79,6 +79,13 @@ export interface PiJsonParseResult {
 	metadata: Partial<ResultMetadata>;
 }
 
+export interface ContextLengthResolution {
+	rawContextLengthExceeded: boolean;
+	contextLengthExceeded: boolean;
+	contextOverflowRecovered: boolean;
+	recoveredStreamErrors: string[];
+}
+
 const CONTEXT_LENGTH_ERROR_PATTERN =
 	/\bcontext[_ -]?length[_ -]?exceeded\b|\bcontext[_ -]?window[_ -]?(?:exceeded|overflow|exhausted)\b|\b(?:maximum|max)[_ -]?context[_ -]?length\b|\btoo many tokens\b|\b(?:prompt|input|request)[^\n]{0,80}\btoo large\b|\bcontext_length_exceeded\b/i;
 
@@ -94,6 +101,32 @@ export function detectContextLengthExceeded(signals: {
 	return CONTEXT_LENGTH_ERROR_PATTERN.test(text);
 }
 
+export function resolveContextLengthState(
+	parsed: PiJsonParseResult,
+	rawContextLengthExceeded: boolean,
+): ContextLengthResolution {
+	const contextOverflowRecovered =
+		rawContextLengthExceeded && finalAssistantSucceeded(parsed);
+	return {
+		rawContextLengthExceeded,
+		contextLengthExceeded:
+			rawContextLengthExceeded && !contextOverflowRecovered,
+		contextOverflowRecovered,
+		recoveredStreamErrors: contextOverflowRecovered
+			? parsed.errors.filter((error) =>
+					detectContextLengthExceeded({ errors: [error] }),
+				)
+			: [],
+	};
+}
+
+function finalAssistantSucceeded(parsed: PiJsonParseResult): boolean {
+	return (
+		parsed.finalAssistantText.length > 0 &&
+		parsed.metadata.stopReason !== "error"
+	);
+}
+
 function normalizeTimeoutMs(timeoutMs: number | undefined): number | undefined {
 	if (timeoutMs === undefined) return undefined;
 	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
@@ -390,18 +423,29 @@ export function resolvePiJsonOutcome(
 
 export function resultMetadataFromParse(
 	parsed: PiJsonParseResult,
-	contextLengthExceeded: boolean,
+	contextLength: ContextLengthResolution,
 	outcome: ProcessOutcome,
 ): Partial<ResultMetadata> {
 	return {
 		...parsed.metadata,
-		contextLengthExceeded,
+		contextLengthExceeded: contextLength.contextLengthExceeded,
+		...(contextLength.contextOverflowRecovered
+			? { contextOverflowRecovered: true }
+			: {}),
 		...(parsed.errors.length === 0
 			? {}
 			: { streamErrors: parsed.errors.slice(0, MAX_METADATA_ERRORS) }),
 		...(outcome.status === "completed" && parsed.errors.length > 0
 			? { nonFatalStreamErrors: parsed.errors.slice(0, MAX_METADATA_ERRORS) }
 			: {}),
+		...(contextLength.recoveredStreamErrors.length === 0
+			? {}
+			: {
+					recoveredStreamErrors: contextLength.recoveredStreamErrors.slice(
+						0,
+						MAX_METADATA_ERRORS,
+					),
+				}),
 		...(parsed.parseErrors.length === 0
 			? {}
 			: { parseErrors: parsed.parseErrors.slice(0, MAX_METADATA_ERRORS) }),
@@ -774,14 +818,18 @@ export async function runHeadlessModel(
 		stderrText,
 		stderrContextLengthExceeded,
 	} = processResult;
-	const contextLengthExceeded =
+	const rawContextLengthExceeded =
 		stderrContextLengthExceeded ||
 		detectContextLengthExceeded({ stderrText, errors: parsed.errors });
+	const contextLength = resolveContextLengthState(
+		parsed,
+		rawContextLengthExceeded,
+	);
 
 	const outcome = resolvePiJsonOutcome(
 		processOutcome,
 		parsed,
-		contextLengthExceeded,
+		contextLength.contextLengthExceeded,
 	);
 
 	const completedAt = new Date();
@@ -811,7 +859,7 @@ export async function runHeadlessModel(
 		artifacts,
 		correlationId: options.correlationId,
 		metadata: {
-			...resultMetadataFromParse(parsed, contextLengthExceeded, outcome),
+			...resultMetadataFromParse(parsed, contextLength, outcome),
 			...sessionMetadata,
 			...(options.parentSessionId === undefined
 				? {}

package/node_modules/@agwab/pi-subagent/src/runners/tmux.ts

@@ -20,6 +20,7 @@ import {
 	detectContextLengthExceeded,
 	parsePiJsonFile,
 	parsePiJsonLines,
+	resolveContextLengthState,
 	resolvePiJsonOutcome,
 	resultMetadataFromParse,
 	resultSessionMetadata,
@@ -157,9 +158,7 @@ function workerScript(
 	return `import { spawn } from "node:child_process";\nimport { appendFileSync, closeSync, openSync, writeFileSync } from "node:fs";\nconst argv = ${JSON.stringify(argv)};\nconst cwd = ${JSON.stringify(cwd)};\nconst eventPath = ${JSON.stringify(eventPath)};\nconst stderrPath = ${JSON.stringify(stderrPath)};\nconst metaPath = ${JSON.stringify(metaPath)};\nconst messageUpdatePattern = /"type"\\s*:\\s*"message_update"/;\nconst maxStdoutLogLineChars = 64 * 1024 * 1024;\ncloseSync(openSync(eventPath, "w"));\ncloseSync(openSync(stderrPath, "w"));\nlet settled = false;\nlet stdoutBuffer = "";\nlet discardingOversizedLine = false;\nlet omittedMessageUpdates = 0;\nlet omittedMessageUpdateBytes = 0;\nlet omittedOversizedLines = 0;\nlet omittedOversizedBytes = 0;\nfunction writeStdoutLine(line) {\n  if (messageUpdatePattern.test(line)) {\n    omittedMessageUpdates += 1;\n    omittedMessageUpdateBytes += Buffer.byteLength(line, "utf8");\n    return;\n  }\n  appendFileSync(eventPath, line);\n  process.stdout.write(line);\n}\nfunction handleStdoutChunk(chunk) {\n  let text = chunk.toString("utf8");\n  while (text.length > 0) {\n    if (discardingOversizedLine) {\n      const newline = text.indexOf("\\n");\n      omittedOversizedBytes += Buffer.byteLength(newline < 0 ? text : text.slice(0, newline + 1), "utf8");\n      if (newline < 0) return;\n      discardingOversizedLine = false;\n      text = text.slice(newline + 1);\n      continue;\n    }\n    const newline = text.indexOf("\\n");\n    const segment = newline < 0 ? text : text.slice(0, newline + 1);\n    stdoutBuffer += segment;\n    text = newline < 0 ? "" : text.slice(newline + 1);\n    if (stdoutBuffer.length > maxStdoutLogLineChars) {\n      omittedOversizedLines += 1;\n      omittedOversizedBytes += Buffer.byteLength(stdoutBuffer, "utf8");\n      stdoutBuffer = "";\n      discardingOversizedLine = newline < 0;\n      continue;\n    }\n    if (newline >= 0) {\n      writeStdoutLine(stdoutBuffer);\n      stdoutBuffer = "";\n    }\n  }\n}\nfunction finishStdoutFilter() {\n  if (!discardingOversizedLine && stdoutBuffer.length > 0) writeStdoutLine(stdoutBuffer);\n  stdoutBuffer = "";\n  if (omittedMessageUpdates > 0 || omittedOversizedLines > 0) {\n    appendFileSync(eventPath, JSON.stringify({ type: "pi-subagent.stdout_filter", omitted: { messageUpdateEvents: omittedMessageUpdates, messageUpdateBytes: omittedMessageUpdateBytes, oversizedLines: omittedOversizedLines, oversizedBytes: omittedOversizedBytes }, reason: "cumulative message_update snapshots are omitted from durable stdout artifacts; final assistant text is stored in output.log" }) + "\\n");\n  }\n}\nfunction writeMeta(meta) {\n  if (settled) return;\n  settled = true;\n  finishStdoutFilter();\n  writeFileSync(metaPath, JSON.stringify(meta, null, 2) + "\\n");\n}\nconst env = { ...process.env };\ndelete env.TMUX;\nconst child = spawn(argv[0], argv.slice(1), { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"], env });\nchild.stdout?.on("data", handleStdoutChunk);\nchild.stderr?.on("data", (chunk) => { appendFileSync(stderrPath, chunk); process.stderr.write(chunk); });\nchild.on("error", () => { writeMeta({ status: "failed", failureKind: "spawn", exitCode: null, signal: null }); });\nchild.on("close", (exitCode, signal) => {\n  const failureKind = exitCode === 0 ? null : "exit";\n  writeMeta({ status: failureKind === null ? "completed" : "failed", failureKind, exitCode, signal });\n});\n`;
 }
 
-async function runTmuxProcess(
-	options: RunTmuxProcessOptions,
-): Promise<{
+async function runTmuxProcess(options: RunTmuxProcessOptions): Promise<{
 	result: TmuxRunResult | null;
 	store: Awaited<ReturnType<typeof createAttemptArtifactStore>>;
 	cwd: string;
@@ -439,11 +438,19 @@ export async function runTmuxModel(
 		parsePiJsonLines(""),
 	);
 	await unlink(result.eventPath).catch(() => undefined);
-	const contextLengthExceeded = detectContextLengthExceeded({
+	const rawContextLengthExceeded = detectContextLengthExceeded({
 		stderrText,
 		errors: parsed.errors,
 	});
-	const meta = resolvePiJsonOutcome(result.meta, parsed, contextLengthExceeded);
+	const contextLength = resolveContextLengthState(
+		parsed,
+		rawContextLengthExceeded,
+	);
+	const meta = resolvePiJsonOutcome(
+		result.meta,
+		parsed,
+		contextLength.contextLengthExceeded,
+	);
 
 	const outputRef = await store.writeTextArtifact(
 		"output",
@@ -464,7 +471,7 @@ export async function runTmuxModel(
 		tmux: result.tmux,
 		correlationId: options.correlationId,
 		metadata: {
-			...resultMetadataFromParse(parsed, contextLengthExceeded, meta),
+			...resultMetadataFromParse(parsed, contextLength, meta),
 			...sessionMetadata,
 			...(options.parentSessionId === undefined
 				? {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agwab/pi-workflow",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Workflow orchestration for Pi subagents.",
   "private": false,
   "type": "module",
@@ -76,7 +76,7 @@
     "node": ">=22.19.0"
   },
   "dependencies": {
-    "@agwab/pi-subagent": "^0.3.6",
+    "@agwab/pi-subagent": "^0.4.2",
     "pi-web-access": "^0.10.7",
     "typebox": "^1.1.39"
   },

package/skills/workflow-guide/SKILL.md

@@ -29,6 +29,7 @@ Resolve paths relative to this skill directory. Treat those docs as the source o
 - For deterministic local post-processing, declare a `support` object with `support.uses` pointing to a bundle-local `./*.mjs` helper; support is trusted local code, not sandboxed subagent work and does not use a separate `type` value.
 - For bounded iteration, use `loop` with fixed child stages, `maxRounds`, and deterministic `until`.
 - Agent-declared tools are the authority ceiling; workflow `tools` can only narrow them.
+- To reuse agent knowledge across stages, declare top-level `roles` (`fromAgent` extracts safe agent sections; `prompt` appends literal text). Compiled role text is injected as a `# Role Context` block; check the result with `/workflow roles <workflow>`. See "Roles" in `docs/usage.md`.
 - Keep review/research workflows read-only unless the workflow explicitly documents managed-worktree mutation.
 - Write-capable workflows need explicit worktree policy, validation/check stages, and protected-path awareness.
 - In non-git workspaces with `worktreePolicy: "off"`, writes mutate the live directory.

package/src/artifact-graph-runtime.ts

@@ -2,6 +2,8 @@ import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { stringifyPromptJson } from "./prompt-json.js";
+import { compactStrings } from "./strings.js";
 import { loadWorkflowHelper } from "./workflow-helpers.js";
 import {
 	WORKFLOW_ARTIFACT_TOOL_NAME,
@@ -13,7 +15,7 @@ import {
 	type WorkflowSourceManifestSource,
 } from "./workflow-artifact-tool.js";
 import { writeWorkflowTaskArtifactBundle } from "./workflow-output-artifacts.js";
-import { type JsonSchema } from "./json-schema.js";
+import type { JsonSchema } from "./json-schema.js";
 import {
 	buildRunSourceContext,
 	readOutputText,
@@ -29,11 +31,11 @@ import {
 	writeJsonAtomic,
 	writeRunRecord,
 } from "./store.js";
-import {
-	type CompiledTask,
-	type CompiledWorkflow,
-	type WorkflowRunRecord,
-	type WorkflowTaskRunRecord,
+import type {
+	CompiledTask,
+	CompiledWorkflow,
+	WorkflowRunRecord,
+	WorkflowTaskRunRecord,
 } from "./types.js";
 
 export async function executeSupportTask(
@@ -372,7 +374,9 @@ export function normalizeDynamicControllerOutput(value: unknown): {
 		refs: [],
 	};
 }
-export function normalizeSupportControl(value: unknown): Record<string, unknown> {
+export function normalizeSupportControl(
+	value: unknown,
+): Record<string, unknown> {
 	if (value && typeof value === "object" && !Array.isArray(value)) {
 		const record = value as Record<string, unknown>;
 		return {
@@ -474,7 +478,7 @@ export async function prepareDagTask(
 			compiledTask.compiledPrompt,
 			"# Source Stage Context",
 			"Use this deterministic source context packet. Prefer structuredOutput over outputPreview. Do not assume dependencies beyond this explicit packet.",
-			JSON.stringify({ ...context, missingDependencies: missing }, null, 2),
+			stringifyPromptJson({ ...context, missingDependencies: missing }),
 		].join("\n\n"),
 	};
 }
@@ -486,6 +490,10 @@ async function prepareArtifactGraphTask(
 	task: WorkflowTaskRunRecord,
 	contextDependsOn: readonly string[],
 ): Promise<CompiledTask> {
+	if (compiledTask.artifactGraph?.artifactAccess === "none") {
+		return { ...compiledTask, cwd: task.cwd };
+	}
+
 	const taskDir = dirname(fromProjectPath(cwd, task.files.result));
 	const manifestPath = join(taskDir, "source-manifest.json");
 	const ledgerPath = join(taskDir, "read-ledger.jsonl");
@@ -880,7 +888,7 @@ export function formatArtifactGraphSourceContext(
 	return [
 		"# Workflow Artifact Inputs",
 		"Use workflow_artifact to list/read upstream workflow artifacts. Inline controlProjection fields are authoritative for the projected data they contain; use artifact reads for declared requiredReads, missing fields, or debug detail.",
-		"Projected reads must include a JSON path when using maxItems or maxChars, for example {\"action\":\"read\",\"source\":\"plan\",\"artifact\":\"control\",\"path\":\"$.factSlots\",\"maxItems\":8,\"maxChars\":2000}. For a whole artifact read, omit maxItems/maxChars.",
+		'Projected reads must include a JSON path when using maxItems or maxChars, for example {"action":"read","source":"plan","artifact":"control","path":"$.factSlots","maxItems":8,"maxChars":2000}. For a whole artifact read, omit maxItems/maxChars.',
 		requiredReads.length > 0
 			? [
 					"Required reads before final output:",
@@ -888,7 +896,7 @@ export function formatArtifactGraphSourceContext(
 				].join("\n")
 			: "No hard requiredReads are declared for this stage.",
 		"Available sources:",
-		JSON.stringify(
+		stringifyPromptJson(
 			sources.map((source) => ({
 				source: source.source,
 				taskId: source.taskId,
@@ -904,13 +912,11 @@ export function formatArtifactGraphSourceContext(
 				projectionTruncated: source.projectionTruncated,
 				availableArtifacts: Object.keys(source.artifacts),
 			})),
-			null,
-			2,
 		),
 	].join("\n\n");
 }
 function uniqueStrings(values: readonly string[]): string[] {
-	return [...new Set(values.filter((value) => value.trim().length > 0))];
+	return compactStrings(values, { trim: false, dropWhitespaceOnly: true });
 }
 
 export async function readArtifactGraphControl(

package/src/artifact-graph-schema.ts

@@ -1,6 +1,7 @@
 import { isAbsolute } from "node:path";
 
 import { DYNAMIC_OUTPUT_PROFILES } from "./dynamic-profiles.js";
+import { compactStrings } from "./strings.js";
 import {
 	APPROVAL_MODES,
 	FAST_MODES,
@@ -71,10 +72,16 @@ const OUTPUT_KEYS = new Set([
 	"analysis",
 	"refs",
 	"maxDigestChars",
+	"partial",
 ]);
+const OUTPUT_PARTIAL_KEYS = new Set(["paths"]);
 const REQUIRED_FLAG_KEYS = new Set(["required"]);
 const REFS_OUTPUT_KEYS = new Set(["required", "minItems"]);
-const INPUT_POLICY_KEYS = new Set(["requiredReads", "enforcement"]);
+const INPUT_POLICY_KEYS = new Set([
+	"requiredReads",
+	"enforcement",
+	"artifactAccess",
+]);
 const SOURCE_PROJECTION_KEYS = new Set(["include", "maxChars"]);
 const SUPPORT_KEYS = new Set(["uses", "options"]);
 const DYNAMIC_STAGE_FORBIDDEN_KEYS = new Set([
@@ -185,7 +192,8 @@ const UNTIL_KEYS = new Set([
 	"all",
 	"any",
 ]);
-const FOREACH_FROM_KEYS = new Set(["source", "path"]);
+const FOREACH_FROM_KEYS = new Set(["source", "path", "streaming"]);
+const FOREACH_STREAMING_KEYS = new Set(["enabled", "minChunk"]);
 const NORMAL_ARTIFACT_KINDS = new Set<WorkflowArtifactKind>([
 	"control",
 	"analysis",
@@ -296,9 +304,54 @@ function validateStageArray(
 	for (const [index, item] of value.entries()) {
 		validateStage(item, `${path}[${index}]`, ids, sourceIds, issues);
 	}
+	validateStreamingProducerDeclarations(value, path, issues);
 	validateStageDependencyGraph(value, path, issues);
 }
 
+function validateStreamingProducerDeclarations(
+	stages: readonly unknown[],
+	path: string,
+	issues: ValidationIssue[],
+): void {
+	const byId = new Map<string, Record<string, unknown>>();
+	for (const stage of stages) {
+		if (isRecord(stage) && typeof stage.id === "string") {
+			byId.set(stage.id, stage);
+		}
+	}
+	for (const [index, stage] of stages.entries()) {
+		if (!isRecord(stage) || !isRecord(stage.from)) continue;
+		const from = stage.from;
+		if (!isRecord(from.streaming) || from.streaming.enabled !== true) continue;
+		const source = typeof from.source === "string" ? from.source : undefined;
+		const controlPath = typeof from.path === "string" ? from.path : undefined;
+		if (!source || !controlPath) continue;
+		const sourceStage = byId.get(source);
+		const partialPaths = outputPartialPaths(sourceStage);
+		if (!partialPaths.includes(controlPath)) {
+			issues.push({
+				path: `${path}[${index}].from.streaming`,
+				message: `source stage "${source}" must declare output.partial.paths including "${controlPath}" to use streaming`,
+			});
+		}
+	}
+}
+
+function outputPartialPaths(
+	stage: Record<string, unknown> | undefined,
+): string[] {
+	const output = isRecord(stage?.output) ? stage.output : undefined;
+	const partial = isRecord(output?.partial) ? output.partial : undefined;
+	return Array.isArray(partial?.paths)
+		? compactStrings(partial.paths, {
+				trim: false,
+				unique: false,
+				dropEmpty: false,
+				dropWhitespaceOnly: false,
+			})
+		: [];
+}
+
 function validateStageDependencyGraph(
 	stages: readonly unknown[],
 	path: string,
@@ -372,7 +425,12 @@ function extractDependencyRefs(value: unknown): string[] {
 	if (value === undefined) return [];
 	if (typeof value === "string") return [value];
 	if (Array.isArray(value))
-		return value.filter((item): item is string => typeof item === "string");
+		return compactStrings(value, {
+			trim: false,
+			unique: false,
+			dropEmpty: false,
+			dropWhitespaceOnly: false,
+		});
 	if (isRecord(value) && typeof value.source === "string")
 		return [value.source];
 	return [];
@@ -517,6 +575,7 @@ function validateStage(
 		`${path}.inputPolicy`,
 		sourceIds,
 		issues,
+		stage.sourceProjection,
 	);
 	validateOutput(stage.output, `${path}.output`, issues);
 	validateSupportStage(stage, type, path, issues);
@@ -611,6 +670,23 @@ function validateControlPathRef(
 			message: "must be a control JSONPath starting with $.",
 		});
 	}
+	if (value.streaming !== undefined) {
+		validateForeachStreaming(value.streaming, `${path}.streaming`, issues);
+	}
+}
+
+function validateForeachStreaming(
+	value: unknown,
+	path: string,
+	issues: ValidationIssue[],
+): void {
+	const streaming = recordAt(value, path, issues);
+	if (!streaming) return;
+	rejectUnknownKeys(streaming, FOREACH_STREAMING_KEYS, path, issues);
+	if (streaming.enabled !== true) {
+		issues.push({ path: `${path}.enabled`, message: "must be true" });
+	}
+	optionalPositiveInteger(streaming.minChunk, `${path}.minChunk`, issues);
 }
 
 function validateKnownStageRef(
@@ -649,6 +725,42 @@ function validateOutput(
 	);
 	validateRequiredFlagObject(output.analysis, `${path}.analysis`, issues);
 	validateRefsOutputObject(output.refs, `${path}.refs`, issues);
+	validatePartialOutput(output.partial, `${path}.partial`, issues);
+}
+
+function validatePartialOutput(
+	value: unknown,
+	path: string,
+	issues: ValidationIssue[],
+): void {
+	if (value === undefined) return;
+	const partial = recordAt(value, path, issues);
+	if (!partial) return;
+	rejectUnknownKeys(partial, OUTPUT_PARTIAL_KEYS, path, issues);
+	if (!Array.isArray(partial.paths)) {
+		issues.push({ path: `${path}.paths`, message: "must be an array" });
+		return;
+	}
+	if (partial.paths.length === 0) {
+		issues.push({ path: `${path}.paths`, message: "must not be empty" });
+	}
+	const seen = new Set<string>();
+	for (const [index, item] of partial.paths.entries()) {
+		const itemPath = `${path}.paths[${index}]`;
+		if (typeof item !== "string" || item.trim() === "") {
+			issues.push({ path: itemPath, message: "must be a non-empty string" });
+			continue;
+		}
+		if (!item.startsWith("$.")) {
+			issues.push({
+				path: itemPath,
+				message: "must be a control JSONPath starting with $.",
+			});
+		}
+		if (seen.has(item))
+			issues.push({ path: itemPath, message: `duplicate value "${item}"` });
+		seen.add(item);
+	}
 }
 
 function validateControlSchemaRef(
@@ -694,6 +806,7 @@ function validateInputPolicy(
 	path: string,
 	siblingIds: ReadonlySet<string>,
 	issues: ValidationIssue[],
+	sourceProjection: unknown,
 ): void {
 	if (value === undefined) return;
 	const policy = recordAt(value, path, issues);
@@ -708,6 +821,33 @@ function validateInputPolicy(
 	if (policy.enforcement !== undefined && policy.enforcement !== "fail") {
 		issues.push({ path: `${path}.enforcement`, message: 'must be "fail"' });
 	}
+	if (
+		policy.artifactAccess !== undefined &&
+		policy.artifactAccess !== "enabled" &&
+		policy.artifactAccess !== "none"
+	) {
+		issues.push({
+			path: `${path}.artifactAccess`,
+			message: 'must be "enabled" or "none"',
+		});
+	}
+	if (policy.artifactAccess === "none") {
+		if (
+			Array.isArray(policy.requiredReads) &&
+			policy.requiredReads.length > 0
+		) {
+			issues.push({
+				path: `${path}.requiredReads`,
+				message: 'must be empty when artifactAccess is "none"',
+			});
+		}
+		if (sourceProjection !== undefined) {
+			issues.push({
+				path: `${path}.artifactAccess`,
+				message: 'cannot be "none" when sourceProjection is declared',
+			});
+		}
+	}
 }
 
 function validateRequiredReads(

package/src/cli.mjs

@@ -53,6 +53,7 @@ const tasks = Array.isArray(run.tasks) ? run.tasks : [];
 const selected = options.has("--failures")
   ? tasks.filter((task) => ["failed", "blocked", "interrupted"].includes(task.status))
   : tasks;
+const reliability = summarizeReliability(tasks);
 
 const lines = [
   `runId: ${run.runId}`,
@@ -60,6 +61,8 @@ const lines = [
   `type: ${run.type}`,
   `status: ${run.status}`,
   `tasks: ${tasks.length}`,
+  `completion: ${reliability.health}`,
+  `retries: output=${reliability.outputRetries}, launch=${reliability.launchRetries}, resumes=${reliability.resumeEvents}, contextLimitFailures=${reliability.contextLimitFailures}`,
 ];
 
 for (const task of selected) {
@@ -184,3 +187,52 @@ async function readJson(path) {
 function indent(text, prefix) {
   return text.split(/\r?\n/).map((line) => `${prefix}${line}`).join("\n");
 }
+
+function summarizeReliability(tasks) {
+  let outputRetries = 0;
+  let launchRetries = 0;
+  let resumeEvents = 0;
+  let contextLimitFailures = 0;
+  for (const task of tasks) {
+    outputRetries += positiveCount(task.outputRetry?.attempts);
+    launchRetries += positiveCount(task.launchRetry?.attempts);
+    if (hasContextLimitFailure(task)) contextLimitFailures += 1;
+    for (const event of Array.isArray(task.resumeEvents) ? task.resumeEvents : []) {
+      resumeEvents += 1;
+      outputRetries += positiveCount(event.outputRetryAttempts);
+      launchRetries += positiveCount(event.launchRetryAttempts);
+      if (hasContextLimitFailure(event)) contextLimitFailures += 1;
+    }
+  }
+  const allCompleted = tasks.length > 0 && tasks.every((task) => task.status === "completed");
+  const repairEvents = outputRetries + launchRetries + resumeEvents;
+  const health = !allCompleted
+    ? "incomplete"
+    : repairEvents === 0 && contextLimitFailures === 0
+      ? "clean"
+      : "repaired";
+  return { health, outputRetries, launchRetries, resumeEvents, contextLimitFailures };
+}
+
+function positiveCount(value) {
+  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+
+function hasContextLimitFailure(value) {
+  return [
+    value?.statusDetail,
+    value?.fromStatusDetail,
+    value?.lastMessage,
+    value?.outputRetry?.reason,
+    value?.outputRetry?.message,
+    value?.launchRetry?.reason,
+    value?.launchRetry?.message,
+    value?.outputRetryReason,
+    value?.launchRetryReason,
+  ].some(isContextLimitText);
+}
+
+function isContextLimitText(value) {
+  const text = String(value ?? "").toLowerCase();
+  return text.includes("context_or_request_too_large") || /context (window|length)|maximum context|request too large|token limit/.test(text);
+}