pi-cohort 7.2.3 → 7.3.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [7.3.0] - 2026-10-18
+
+### Added
+
+- Chain steps accept an optional `stopOn: { path, in }` condition over schema-validated structured output. A match ends the chain after that step as a controlled stop (`isError: false`) with a fixed `## Stop` JSON record naming every matching task and a `## Outputs` section carrying every finished task's text and structured output; a sibling failure in the same step keeps the failed status but still attaches the record and the finished outputs. Accepted on call-time `chain:` items, `.chain.json`, management `config.steps[]`, and `.chain.md` (`stopOn: {"path":"/verdict","in":["FAIL"]}`); rejected before any child starts when the step has no `outputSchema`. Background runs persist `stop` in the result file and the completion notice renders it. Worktree parallel tasks expose their patch to later steps as `{outputs.name.patchPath}`. Chains without `stopOn` are unchanged. (#23)
+
 ## [7.2.3] - 2026-10-18
 
 ### Fixed

package/README.md

@@ -117,6 +117,35 @@ Ask oracle for a second opinion on my current plan.
 Run parallel reviewers: one for correctness, one for tests, and one for unnecessary complexity.
 ```
 
+Run implementers and spec reviewers in the first call, stopping the chain on `FAIL`:
+
+```ts
+subagent({ async: false, chain: [
+  { parallel: [
+      { agent: "implementer", as: "impl_1", task: "Implement task 1", outputSchema: statusSchema },
+      { agent: "implementer", as: "impl_2", task: "Implement task 2", outputSchema: statusSchema },
+    ], worktree: true, stopOn: { path: "/status", in: ["NEEDS_CONTEXT", "BLOCKED"] } },
+  { parallel: [
+      { agent: "spec-reviewer", as: "sr_1", task: "Review {outputs.impl_1.patchPath}", outputSchema: verdictSchema },
+      { agent: "spec-reviewer", as: "sr_2", task: "Review {outputs.impl_2.patchPath}", outputSchema: verdictSchema },
+    ], stopOn: { path: "/verdict", in: ["FAIL"] } },
+]})
+```
+
+The parent applies the accepted patches, runs its tests, and issues a second call for code review over the integrated diff:
+
+```ts
+subagent({ async: false, agent: "code-reviewer", task: "Review the integrated diff" })
+```
+
+A match ends the chain after that step as a controlled stop (not an error): the result carries a `## Stop` JSON record naming every matching task and a `## Outputs` section with every finished task's output. A chain without `stopOn` behaves exactly as before.
+
+In a saved `.chain.md` the condition is one line per step, the object as JSON:
+
+```md
+stopOn: {"path":"/verdict","in":["FAIL"]}
+```
+
 That's the whole surface for day-to-day use. More phrasing patterns: [doc/commands.md](doc/commands.md#prompt-cookbook-appendix).
 
 Review and delivery workflows live in pi-gauntlet; pi-cohort ships delegation primitives plus `/investigate` and `/skill:handoff [--out <path> | --key <stem>]` (the brief lands in `<tmpdir>/pi-handoff/<primary>--<leaf>.md` by default; contract in [doc/handoff-template.md](doc/handoff-template.md)).
@@ -142,7 +171,7 @@ Full reference: agent/chain authoring in [doc/agents-and-chains.md](doc/agents-a
 |---|---|
 | Subagent | A focused child Pi session with one job and (by default) a fresh context. |
 | Agent (persona) | A markdown file with frontmatter defining a specialist: `scout`, `planner`, `worker`, `reviewer`, `context-builder`, `oracle`, `delegate`, `monitor`. Full table: [doc/agents-and-chains.md](doc/agents-and-chains.md#builtin-agents-in-plain-english). |
-| Chain | A saved or inline sequence of agent steps, with fan-out/fan-in support. |
+| Chain | A saved or inline sequence of agent steps, with fan-out/fan-in support and an optional per-step `stopOn` condition that ends the chain when a child's structured output matches (for example a reviewer's `FAIL` verdict). Field reference: [doc/agents-and-chains.md](doc/agents-and-chains.md#stop-conditions-stopon). |
 | Fresh vs. forked context | Fresh = clean slate; forked = a real branch of the parent's session history. |
 | Recursion guard | Depth cap on nested delegation so a child can only fan out if explicitly allowed. |
 | `Σ$` / `cost:external` | The session-wide cost rollup, and the protocol other extensions use to report into it. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cohort",
-  "version": "7.2.3",
+  "version": "7.3.0",
   "description": "Delegate Pi work to focused child agents: code review, scouting, implementation, parallel audits, saved chains, and background jobs.",
   "author": "Jacek Juraszek",
   "license": "MIT",

package/skills/pi-cohort/SKILL.md

@@ -65,6 +65,7 @@ A child saying "done" is evidence, not verification. `reviewed` means a reviewer
 | `cwd` | child working directory; pass the worktree path or the child inherits pi's launch dir |
 | `acceptance` | per-task override, same shape as top-level |
 | `as`, `outputSchema` | the child must call `structured_output` with schema-valid JSON or the step fails; later steps read `{outputs.<as>}` |
+| `stopOn` | Use step-level `{ path, in }` to end the chain after this step when any task's structured output at the JSON Pointer `path` equals a member of `in`; supply `outputSchema` on every task of the step |
 
 ## Control actions
 
@@ -98,6 +99,15 @@ subagent({ async: false, chain: [
   { agent: "worker", task: "Apply accepted fixes from {previous}" }
 ]})
 
+// Run implementers and spec reviewers in the first call (stop on FAIL).
+subagent({ async: false, chain: [
+  { parallel: [ { agent: "implementer", as: "impl_1", task: "...", outputSchema: statusSchema } ], worktree: true, stopOn: { path: "/status", in: ["NEEDS_CONTEXT", "BLOCKED"] } },
+  { parallel: [ { agent: "spec-reviewer", as: "sr_1", task: "Review {outputs.impl_1.patchPath}", outputSchema: verdictSchema } ], stopOn: { path: "/verdict", in: ["FAIL"] } },
+]})
+// Read a controlled match (isError false) in the `## Stop` JSON record and every finished output under `## Outputs`.
+// Apply accepted patches in the parent, run tests, then issue a second call for code review over the integrated diff.
+subagent({ async: false, agent: "code-reviewer", task: "Review the integrated diff" })
+
 // background job, then control (pair long jobs with a monitor - see Control actions)
 subagent({ agent: "worker", async: true, task: "<long job - emit progress lines as you work>" })
 subagent({ action: "status" })

package/skills/pi-cohort/reference/config-fields.md

@@ -53,6 +53,7 @@ Per step:
 | `model` | string | Model override. |
 | `skills` | string[] \| false | Skills to inject into this step's agent (management config, plural); the execution-time `chain[].skill` param is singular. |
 | `progress` | boolean | progress.md tracking. |
+| `stopOn` | `{ path: string, in: string[] }` | End the chain after this step when the structured output at JSON Pointer `path` equals a member of `in`; supply `outputSchema`. Write to `.chain.md` as `stopOn: {"path":"/verdict","in":["FAIL"]}`. |
 
 ### Call-time `control` overrides
 

package/src/agents/agent-management.ts

@@ -20,7 +20,8 @@ import {
 import { serializeAgent } from "./agent-serializer.ts";
 import { serializeChain, serializeJsonChain } from "./chain-serializer.ts";
 import { discoverAvailableSkills } from "./skills.ts";
-import type { Details } from "../shared/types.ts";
+import type { Details, StopCondition } from "../shared/types.ts";
+import { stopConditionShapeError, validateStopConditions } from "../runs/shared/stop-conditions.ts";
 
 type ManagementAction = "list" | "get" | "create" | "update" | "delete";
 type ManagementScope = "user" | "project";
@@ -213,8 +214,15 @@ function parseStepList(raw: unknown): { steps?: ChainStepConfig[]; error?: strin
 			if (typeof s.progress === "boolean") step.progress = s.progress;
 			else return { error: `config.steps[${i}].progress must be a boolean.` };
 		}
+		if (hasKey(s, "stopOn")) {
+			const shapeError = stopConditionShapeError(s.stopOn, `config.steps[${i}].stopOn`);
+			if (shapeError) return { error: shapeError };
+			step.stopOn = s.stopOn as StopCondition;
+		}
 		steps.push(step);
 	}
+	const stopError = validateStopConditions(steps);
+	if (stopError) return { error: stopError };
 	return { steps };
 }
 

package/src/agents/agents.ts

@@ -6,7 +6,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import type { AcceptanceInput, OutputMode } from "../shared/types.ts";
+import type { AcceptanceInput, OutputMode, StopCondition } from "../shared/types.ts";
 import { getAgentDir } from "../shared/utils.ts";
 import { KNOWN_FIELDS } from "./agent-serializer.ts";
 import { parseChain, parseJsonChain } from "./chain-serializer.ts";
@@ -142,6 +142,7 @@ export interface ChainStepConfig {
 	failFast?: boolean;
 	worktree?: boolean;
 	acceptance?: AcceptanceInput;
+	stopOn?: StopCondition;
 }
 
 export interface ChainConfig {

package/src/agents/chain-serializer.ts

@@ -4,6 +4,8 @@ import { parseFrontmatter } from "./frontmatter.ts";
 import { ChainOutputValidationError, validateChainOutputBindings } from "../runs/shared/chain-outputs.ts";
 import { validateAcceptanceInput } from "../runs/shared/acceptance.ts";
 import type { ChainStep } from "../shared/settings.ts";
+import { stopConditionShapeError } from "../runs/shared/stop-conditions.ts";
+import type { StopCondition } from "../shared/types.ts";
 
 function parseStepBody(agent: string, sectionBody: string): ChainStepConfig {
 	const lines = sectionBody.split("\n");
@@ -78,6 +80,17 @@ function parseStepBody(agent: string, sectionBody: string): ChainStepConfig {
 			if (rawValue === "true") step.progress = true;
 			else if (rawValue === "false") step.progress = false;
 		}
+		if (key === "stopon") {
+			const invalid = `stopOn line '${line.trim()}' must be a JSON object {"path": "<json-pointer>", "in": ["<value>", ...]}.`;
+			let parsed: unknown;
+			try {
+				parsed = JSON.parse(rawValue);
+			} catch {
+				throw new Error(invalid);
+			}
+			if (stopConditionShapeError(parsed, "stopOn")) throw new Error(invalid);
+			step.stopOn = parsed as StopCondition;
+		}
 	}
 
 	return step;
@@ -242,6 +255,7 @@ export function serializeChain(config: ChainConfig): string {
 		if (step.skills === false) lines.push("skills: false");
 		else if (Array.isArray(step.skills) && step.skills.length > 0) lines.push(`skills: ${step.skills.join(", ")}`);
 		if (step.progress !== undefined) lines.push(`progress: ${step.progress ? "true" : "false"}`);
+		if (step.stopOn) lines.push(`stopOn: ${JSON.stringify(step.stopOn)}`);
 		lines.push("");
 		lines.push(step.task ?? "");
 		if (i < config.steps.length - 1) lines.push("");

package/src/extension/schemas.ts

@@ -233,6 +233,10 @@ const ChainItem = Type.Object({
 	worktree: Type.Optional(Type.Boolean({
 		description: "Isolated worktree per task."
 	})),
+	stopOn: Type.Optional(Type.Object({
+		path: Type.String({ description: "JSON Pointer into the step's structured output." }),
+		in: Type.Array(Type.String(), { minItems: 1, description: "Stop the chain when the value equals any member." }),
+	}, { additionalProperties: false, description: "Stop after this step when any task's structured output matches; requires outputSchema." })),
 }, {
 	description: "{agent,task?} seq; {parallel:[..]} concurrent; {expand,parallel,collect} fanout.",
 	additionalProperties: false,

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

@@ -519,6 +519,7 @@ export function executeAsyncChain(
 				async: true,
 				dynamic: false,
 			}),
+			...(s.stopOn ? { stopOn: s.stopOn } : {}),
 			...(s.outputSchema ? { structuredOutputSchema: s.outputSchema } : {}),
 			...(s.outputSchema ? { structuredOutput: createStructuredOutputRuntime(s.outputSchema, path.join(asyncDir, "structured-output")) } : {}),
 		};
@@ -566,6 +567,7 @@ export function executeAsyncChain(
 					concurrency: s.concurrency,
 					failFast: s.failFast,
 					worktree: s.worktree,
+					stopOn: s.stopOn,
 				};
 			}
 			if (isDynamicParallelStep(s)) {
@@ -584,6 +586,7 @@ export function executeAsyncChain(
 					failFast: s.failFast,
 					phase: s.phase,
 					label: s.label,
+					stopOn: s.stopOn,
 					effectiveAcceptance: resolveEffectiveAcceptance({
 						explicit: s.acceptance,
 						agentName: s.parallel.agent,

package/src/runs/background/notify.ts

@@ -5,6 +5,8 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
+import { buildChainStopSection } from "../../shared/formatters.ts";
+import type { StopRecord } from "../../shared/types.ts";
 
 interface ChainStepResult {
 	agent: string;
@@ -14,7 +16,7 @@ interface ChainStepResult {
 
 export interface SubagentNotifyDetails {
 	agent: string;
-	status: "completed" | "failed" | "paused";
+	status: "completed" | "failed" | "paused" | "stopped";
 	taskInfo?: string;
 	resultPreview: string;
 	durationMs?: number;
@@ -36,6 +38,7 @@ interface SubagentResult {
 	gistUrl?: string;
 	shareError?: string;
 	results?: ChainStepResult[];
+	stop?: StopRecord;
 	taskIndex?: number;
 	totalTasks?: number;
 }
@@ -57,7 +60,7 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 			|| result.state === "paused"
 			|| summary.startsWith("Paused after interrupt.")
 		);
-		const status = paused ? "paused" : result.success ? "completed" : "failed";
+		const status = paused ? "paused" : result.success ? (result.stop ? "stopped" : "completed") : "failed";
 
 		const taskInfo =
 			result.taskIndex !== undefined && result.totalTasks !== undefined
@@ -73,10 +76,13 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 					: undefined;
 
 		const displaySummary = summary.trim() ? summary : "(no output)";
+		const stopBlock = result.stop ? buildChainStopSection(result.stop) : undefined;
 		const content = [
 			`Background task ${status}: **${agent}**${taskInfo}`,
 			"",
 			displaySummary,
+			stopBlock ? "" : undefined,
+			stopBlock,
 			sessionLine ? "" : undefined,
 			sessionLine,
 		]

package/src/runs/background/subagent-runner.ts

@@ -15,6 +15,7 @@ import {
 	type AsyncParallelGroupStatus,
 	type AsyncStatus,
 	type ChainOutputMap,
+	type StopRecord,
 	type ModelAttempt,
 	type NestedRouteInfo,
 	type ResolvedControlConfig,
@@ -45,7 +46,8 @@ import {
 	MAX_PARALLEL_CONCURRENCY,
 } from "../shared/parallel-utils.ts";
 import { buildPiArgs, cleanupTempDir, runDirEnv } from "../shared/pi-args.ts";
-import { outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/chain-outputs.ts";
+import { ChainOutputValidationError, outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/chain-outputs.ts";
+import { buildStopRecord, evaluateStopCondition } from "../shared/stop-conditions.ts";
 import { createStructuredOutputRuntime, readStructuredOutput } from "../shared/structured-output.ts";
 import { collectDynamicResults, DynamicFanoutError, materializeDynamicParallelStep, validateDynamicCollection } from "../shared/dynamic-fanout.ts";
 import { nestedSummaryFromAsyncStatus, writeNestedEvent } from "../shared/nested-events.ts";
@@ -74,6 +76,8 @@ import {
 	formatWorktreeDiffSummary,
 	formatWorktreeTaskCwdConflict,
 	type WorktreeSetup,
+	type WorktreeDiff,
+	patchPathForDiff,
 } from "../shared/worktree.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { writeInitialProgressFile } from "../../shared/settings.ts";
@@ -633,7 +637,12 @@ export async function runSingleStep(
 		: undefined);
 	const placeholderRegex = new RegExp(ctx.placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
 	let task = step.task.replace(placeholderRegex, () => ctx.previousOutput);
-	task = resolveOutputReferences(task, ctx.outputs ?? {});
+	try {
+		task = resolveOutputReferences(task, ctx.outputs ?? {});
+	} catch (error) {
+		if (!(error instanceof ChainOutputValidationError)) throw error;
+		return { agent: step.agent, output: error.message, exitCode: 1, error: error.message, sessionFile: step.sessionFile };
+	}
 	const taskForCompletionGuard = task;
 	if (step.effectiveAcceptance) {
 		const acceptancePrompt = formatAcceptancePrompt(step.effectiveAcceptance);
@@ -1203,16 +1212,23 @@ function prepareParallelTaskRun(
 	};
 }
 
-function appendParallelWorktreeSummary(
-	previousOutput: string,
+function captureParallelWorktreeDiffs(
 	worktreeSetup: WorktreeSetup | undefined,
 	asyncDir: string,
 	stepIndex: number,
 	group: Extract<RunnerStep, { parallel: SubagentStep[] }>,
-): string {
-	if (!worktreeSetup) return previousOutput;
+): WorktreeDiff[] {
+	if (!worktreeSetup) return [];
 	const diffsDir = path.join(asyncDir, "worktree-diffs", `step-${stepIndex}`);
-	const diffs = diffWorktrees(worktreeSetup, group.parallel.map((task) => task.agent), diffsDir);
+	return diffWorktrees(worktreeSetup, group.parallel.map((task) => task.agent), diffsDir);
+}
+
+function patchInfoForDiff(diff: WorktreeDiff | undefined) {
+	if (!diff) return undefined;
+	return { patchPath: patchPathForDiff(diff), patchError: diff.captureError };
+}
+
+function appendParallelWorktreeSummary(previousOutput: string, diffs: WorktreeDiff[]): string {
 	const diffSummary = formatWorktreeDiffSummary(diffs);
 	if (!diffSummary) return previousOutput;
 	return `${previousOutput}\n\n${diffSummary}`;
@@ -1231,6 +1247,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 	let previousOutput = "";
 	const outputs: ChainOutputMap = {};
 	const results: StepResult[] = [];
+	let stopRecord: StopRecord | undefined;
 	const overallStartTime = Date.now();
 	const shareEnabled = config.share === true;
 	const asyncDir = config.asyncDir;
@@ -1931,16 +1948,22 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			}
 			const collection = collectDynamicResults(step as Parameters<typeof collectDynamicResults>[0], materialized.items, parallelResults);
 			const failures = parallelResults.filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
+			if (!interrupted && step.stopOn) {
+				const matches = evaluateStopCondition(step.stopOn, stepIndex, parallelResults.map((r, i) => ({
+					agent: r.agent, label: materialized.parallel[i]?.label, exitCode: r.exitCode, structuredOutput: r.structuredOutput,
+				})));
+				if (matches.length > 0) stopRecord = buildStopRecord(step.stopOn, stepIndex, matches);
+			}
+			outputs[step.collect.as] = {
+				text: JSON.stringify(collection),
+				structured: collection,
+				agent: step.parallel.agent,
+				stepIndex,
+			};
+			statusPayload.outputs = outputs;
 			if (failures.length === 0) {
 				try {
 					validateDynamicCollection(step.collect.outputSchema, collection);
-					outputs[step.collect.as] = {
-						text: JSON.stringify(collection),
-						structured: collection,
-						agent: step.parallel.agent,
-						stepIndex,
-					};
-					statusPayload.outputs = outputs;
 					const groupAcceptance = step.effectiveAcceptance
 						? await evaluateAcceptance({
 							acceptance: step.effectiveAcceptance,
@@ -1993,7 +2016,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			if (failures.length > 0) markDynamicGraphGroup(stepIndex, "failed", failures[0]?.error ?? "Dynamic fanout child failed.");
 			statusPayload.lastUpdate = Date.now();
 			writeStatusPayload();
-			if (failures.length > 0 || statusPayload.error) break;
+			if (stopRecord || failures.length > 0 || statusPayload.error) break;
 			continue;
 		}
 
@@ -2217,15 +2240,22 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 							executionSurface: pr.executionSurface,
 						});
 					}
+				const diffs = captureParallelWorktreeDiffs(worktreeSetup, asyncDir, stepIndex, group);
 				for (let t = 0; t < group.parallel.length; t++) {
 					const outputName = group.parallel[t]?.outputName;
-					if (outputName) outputs[outputName] = outputEntryFromAsyncResult({
+					if (outputName && parallelResults[t]!.exitCode === 0) outputs[outputName] = outputEntryFromAsyncResult({
 						agent: parallelResults[t]!.agent,
 						output: parallelResults[t]!.output,
 						structuredOutput: parallelResults[t]!.structuredOutput,
-					}, stepIndex);
+					}, stepIndex, patchInfoForDiff(diffs[t]));
 				}
 				statusPayload.outputs = outputs;
+				if (!interrupted && group.stopOn) {
+					const matches = evaluateStopCondition(group.stopOn, stepIndex, parallelResults.map((r, i) => ({
+						agent: r.agent, as: group.parallel[i]?.outputName, label: group.parallel[i]?.label, exitCode: r.exitCode, structuredOutput: r.structuredOutput,
+					})));
+					if (matches.length > 0) stopRecord = buildStopRecord(group.stopOn, stepIndex, matches);
+				}
 
 				previousOutput = aggregateParallelOutputs(
 					parallelResults.map((r) => ({
@@ -2237,7 +2267,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					attemptedModels: r.attemptedModels,
 				})),
 				);
-				previousOutput = appendParallelWorktreeSummary(previousOutput, worktreeSetup, asyncDir, stepIndex, group);
+				previousOutput = appendParallelWorktreeSummary(previousOutput, diffs);
 
 				appendJsonl(eventsPath, JSON.stringify({
 					type: "subagent.parallel.completed",
@@ -2247,7 +2277,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					success: parallelResults.every((r) => r.exitCode === 0 || r.exitCode === -1),
 				}));
 
-				if (parallelResults.some((r) => r.exitCode !== 0 && r.exitCode !== -1)) {
+				if (stopRecord || parallelResults.some((r) => r.exitCode !== 0 && r.exitCode !== -1)) {
 					break;
 				}
 			} finally {
@@ -2382,8 +2412,13 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			}
 
 			flatIndex++;
-			if (singleResult.exitCode !== 0) {
-				break;
+			if (singleResult.exitCode !== 0) break;
+			if (!interrupted && seqStep.stopOn) {
+				const matches = evaluateStopCondition(seqStep.stopOn, stepIndex, [{ agent: singleResult.agent, as: seqStep.outputName, label: seqStep.label, exitCode: singleResult.exitCode, structuredOutput: singleResult.structuredOutput }], { sequential: true });
+				if (matches.length > 0) {
+					stopRecord = buildStopRecord(seqStep.stopOn, stepIndex, matches);
+					break;
+				}
 			}
 		}
 	}
@@ -2509,6 +2544,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				executionSurface: r.executionSurface,
 			})),
 			outputs,
+			...(stopRecord ? { stop: stopRecord } : {}),
 			workflowGraph: statusPayload.workflowGraph,
 			exitCode: interrupted || results.every((r) => r.success) ? 0 : 1,
 			timestamp: runEndedAt,