pi-cohort 7.2.3 → 7.3.1

package/src/runs/shared/worktree.ts

@@ -18,7 +18,7 @@ interface WorktreeInfo {
 	syntheticPaths: string[];
 }
 
-interface WorktreeDiff {
+export interface WorktreeDiff {
 	index: number;
 	agent: string;
 	branch: string;
@@ -448,11 +448,10 @@ function captureWorktreeDiff(
 	removeSyntheticPathsBeforeDiff(worktree);
 	runGitChecked(worktree.path, ["add", "-A"]);
 	const diffStat = runGitChecked(worktree.path, ["diff", "--cached", "--stat", setup.baseCommit]).trim();
-	const patch = runGitChecked(worktree.path, ["diff", "--cached", setup.baseCommit]);
+	runGitChecked(worktree.path, ["diff", "--cached", "--binary", `--output=${path.resolve(patchPath)}`, setup.baseCommit]);
 	const numstat = runGitChecked(worktree.path, ["diff", "--cached", "--numstat", setup.baseCommit]);
-	fs.writeFileSync(patchPath, patch, "utf-8");
 
-	if (!patch.trim()) {
+	if (fs.statSync(patchPath).size === 0) {
 		return emptyDiff(worktree.index, agent, worktree.branch, patchPath);
 	}
 
@@ -490,6 +489,12 @@ function hasWorktreeChanges(diff: WorktreeDiff): boolean {
 	return diff.filesChanged > 0 || diff.insertions > 0 || diff.deletions > 0 || diff.diffStat.trim().length > 0;
 }
 
+/** The patch a later chain step may reference: only a clean capture with real changes qualifies. */
+export function patchPathForDiff(diff: WorktreeDiff): string | undefined {
+	if (diff.captureError) return undefined;
+	return hasWorktreeChanges(diff) ? diff.patchPath : undefined;
+}
+
 export function createWorktrees(cwd: string, runId: string, count: number, options?: CreateWorktreesOptions): WorktreeSetup {
 	const repo = resolveRepoState(cwd);
 	const setupHook = resolveWorktreeSetupHook(repo.toplevel, options?.setupHook);

package/src/shared/formatters.ts

@@ -4,7 +4,8 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { Usage, SingleResult } from "./types.ts";
+import type { Usage, SingleResult, ChainTaskOutputEntry, StopRecord } from "./types.ts";
+import { formatStopCondition } from "../runs/shared/stop-conditions.ts";
 import type { ChainStep } from "./settings.ts";
 import { isDynamicParallelStep, isParallelStep } from "./settings.ts";
 import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.ts";
@@ -52,15 +53,62 @@ export function formatDuration(ms: number): string {
 	return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
 }
 
+export interface ChainSummaryOptions {
+	stop?: StopRecord;
+	outputs?: ChainTaskOutputEntry[];
+}
+
+function renderTaskHeading(entry: ChainTaskOutputEntry): string {
+	const asPart = entry.as ? `, as ${entry.as}` : "";
+	const base = `#### Task ${entry.taskIndex + 1} (${entry.agent}${asPart})`;
+	if (entry.exitCode === -1) return `${base} - skipped (fail-fast)`;
+	if (entry.exitCode !== 0) return `${base} - failed`;
+	return base;
+}
+
+/** `## Outputs`, grouped by step in execution order; skipped tasks get a heading only, failed tasks their error line. */
+export function buildChainOutputsSection(entries: ChainTaskOutputEntry[]): string {
+	const lines: string[] = ["## Outputs"];
+	let currentStep = -1;
+	for (const entry of entries) {
+		if (entry.stepIndex !== currentStep) {
+			currentStep = entry.stepIndex;
+			lines.push(`### Step ${currentStep + 1}`);
+		}
+		lines.push(renderTaskHeading(entry));
+		if (entry.exitCode === -1) continue;
+		if (entry.exitCode !== 0) {
+			lines.push(entry.error || "failed");
+			continue;
+		}
+		if (entry.text) lines.push(entry.text);
+		if (entry.structured !== undefined) lines.push("```json", JSON.stringify(entry.structured), "```");
+	}
+	return lines.join("\n");
+}
+
+export function buildChainStopSection(stop: StopRecord): string {
+	return `## Stop\n\`\`\`json\n${JSON.stringify(stop, null, 2)}\n\`\`\``;
+}
+
+function appendChainSections(text: string, options: ChainSummaryOptions | undefined): string {
+	if (!options) return text;
+	const sections: string[] = [];
+	if (options.stop) sections.push(buildChainStopSection(options.stop));
+	if (options.outputs) sections.push(buildChainOutputsSection(options.outputs));
+	return sections.length ? `${text}\n\n${sections.join("\n\n")}\n` : text;
+}
+
 /**
- * Build a summary string for a completed/failed chain
+ * Build a summary string for a completed/failed/stopped chain
  */
 export function buildChainSummary(
 	steps: ChainStep[],
 	results: SingleResult[],
 	chainDir: string,
-	status: "completed" | "failed",
+	status: "completed" | "failed" | "stopped",
 	failedStep?: { index: number; error: string },
+	options?: ChainSummaryOptions,
 ): string {
 	const stepNames = steps
 		.map((step) => (isParallelStep(step) ? `parallel[${step.parallel.length}]` : isDynamicParallelStep(step) ? `expand:${step.parallel.agent}` : step.agent))
@@ -77,20 +125,21 @@ export function buildChainSummary(
 	}
 	const skillsLine = allSkills.size > 0 ? `🔧 Skills: ${[...allSkills].join(", ")}` : "";
 
-	if (status === "completed") {
-		const stepWord = results.length === 1 ? "step" : "steps";
-		return `✅ Chain completed: ${stepNames} (${results.length} ${stepWord}, ${durationStr})${skillsLine ? `\n${skillsLine}` : ""}
-
-📋 Progress: ${hasProgress ? progressPath : "(none)"}
-📁 Artifacts: ${chainDir}`;
-	} else {
-		const stepInfo = failedStep ? ` at step ${failedStep.index + 1}` : "";
-		const errorInfo = failedStep?.error ? `: ${failedStep.error}` : "";
-		return `❌ Chain failed${stepInfo}${errorInfo}${skillsLine ? `\n${skillsLine}` : ""}
+	const footer = `\n\n📋 Progress: ${hasProgress ? progressPath : "(none)"}\n📁 Artifacts: ${chainDir}`;
 
-📋 Progress: ${hasProgress ? progressPath : "(none)"}
-📁 Artifacts: ${chainDir}`;
+	if (status === "stopped" && options?.stop) {
+		const header = `⏹ Chain stopped at step ${options.stop.stepIndex + 1}/${steps.length} by condition ${formatStopCondition(options.stop.condition)}`;
+		return appendChainSections(`${header}${skillsLine ? `\n${skillsLine}` : ""}${footer}`, options);
+	}
+	if (status === "completed" || status === "stopped") {
+		const stepWord = results.length === 1 ? "step" : "steps";
+		const header = `✅ Chain completed: ${stepNames} (${results.length} ${stepWord}, ${durationStr})${skillsLine ? `\n${skillsLine}` : ""}`;
+		return appendChainSections(`${header}${footer}`, options);
 	}
+	const stepInfo = failedStep ? ` at step ${failedStep.index + 1}` : "";
+	const errorInfo = failedStep?.error ? `: ${failedStep.error}` : "";
+	const header = `❌ Chain failed${stepInfo}${errorInfo}${skillsLine ? `\n${skillsLine}` : ""}`;
+	return appendChainSections(`${header}${footer}`, options);
 }
 
 /**

package/src/shared/settings.ts

@@ -6,7 +6,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agents.ts";
 import { normalizeSkillInput } from "../agents/skills.ts";
-import { CHAIN_RUNS_DIR, type AcceptanceInput, type JsonSchemaObject, type OutputMode } from "./types.ts";
+import { CHAIN_RUNS_DIR, type AcceptanceInput, type JsonSchemaObject, type OutputMode, type StopCondition } from "./types.ts";
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
 const INITIAL_PROGRESS_CONTENT = "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n";
 
@@ -56,6 +56,7 @@ export interface SequentialStep {
 	skill?: string | string[] | false;
 	model?: string;
 	acceptance?: AcceptanceInput;
+	stopOn?: StopCondition;
 }
 
 /** Parallel task item within a parallel step */
@@ -104,6 +105,7 @@ export interface DynamicParallelStep {
 	phase?: string;
 	label?: string;
 	acceptance?: AcceptanceInput;
+	stopOn?: StopCondition;
 }
 
 /** Parallel step: multiple agents running concurrently */
@@ -113,6 +115,7 @@ export interface ParallelStep {
 	failFast?: boolean;
 	worktree?: boolean;
 	cwd?: string;
+	stopOn?: StopCondition;
 }
 
 /** Union type for chain steps */

package/src/shared/types.ts

@@ -23,11 +23,47 @@ export type OutputMode = "inline" | "file-only";
 
 export type JsonSchemaObject = Record<string, unknown>;
 
+export interface StopCondition {
+	path: string;
+	in: string[];
+}
+
+export interface StopMatch {
+	stepIndex: number;
+	taskIndex?: number;
+	as?: string;
+	label?: string;
+	agent: string;
+	value: string;
+}
+
+export interface StopRecord {
+	reason: "condition";
+	stepIndex: number;
+	condition: StopCondition;
+	matches: StopMatch[];
+}
+
+/** One finished task's output as rendered in the chain result's `## Outputs` section. */
+export interface ChainTaskOutputEntry {
+	stepIndex: number;
+	taskIndex: number;
+	agent: string;
+	as?: string;
+	label?: string;
+	text: string;
+	structured?: unknown;
+	exitCode: number | null | undefined;
+	error?: string;
+}
+
 export interface ChainOutputMapEntry {
 	text: string;
 	structured?: unknown;
 	agent: string;
 	stepIndex: number;
+	patchPath?: string;
+	patchError?: string;
 }
 
 export type ChainOutputMap = Record<string, ChainOutputMapEntry>;
@@ -435,6 +471,7 @@ export interface Details {
 	currentStepIndex?: number;   // 0-indexed current step (for running chains)
 	workflowGraph?: WorkflowGraphSnapshot;
 	outputs?: ChainOutputMap;
+	stop?: StopRecord;
 }
 
 // ============================================================================

package/src/slash/slash-commands.ts

@@ -174,6 +174,7 @@ const mapSavedChainSteps = (chain: ChainConfig, worktree = false): ChainStep[] =
 			progress: step.progress,
 			skill: step.skill ?? step.skills,
 			model: step.model,
+			...(step.stopOn ? { stopOn: step.stopOn } : {}),
 		};
 	});
 };