pi-crew 0.1.46 → 0.1.49

package/src/runtime/code-summary.ts

@@ -0,0 +1,247 @@
+/**
+ * Structural code summary — regex-based summarizer that elides function bodies,
+ * long arrays, block comments, and import groups, keeping signatures.
+ * Pure TypeScript fallback (no tree-sitter / Rust native dependency).
+ */
+
+// ── Public types ──
+
+export interface SummarySegment {
+	kind: "kept" | "elided";
+	startLine: number;
+	endLine: number;
+	/** Verbatim text for kept segments; absent for elided */
+	text?: string;
+}
+
+export interface SummaryResult {
+	language: string | null;
+	totalLines: number;
+	elided: boolean;
+	segments: SummarySegment[];
+	rendered: string;
+}
+
+export interface SummaryOptions {
+	minBodyLines?: number;    // default 4
+	minCommentLines?: number; // default 6
+}
+
+// ── Language detection ──
+
+const EXT_MAP: ReadonlyMap<string, string> = new Map([
+	[".ts", "typescript"], [".tsx", "typescript"],
+	[".js", "javascript"], [".jsx", "javascript"],
+	[".mjs", "javascript"], [".cjs", "javascript"],
+	[".py", "python"], [".rs", "rust"],
+]);
+
+export function detectLanguage(filePath: string): string | null {
+	const dot = filePath.lastIndexOf(".");
+	if (dot === -1) return null;
+	return EXT_MAP.get(filePath.slice(dot).toLowerCase()) ?? null;
+}
+
+// ── Internal range helpers ──
+
+interface Range { start: number; end: number; }
+
+function mergeRanges(ranges: Range[]): Range[] {
+	if (ranges.length === 0) return [];
+	const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
+	const merged: Range[] = [sorted[0]];
+	for (let i = 1; i < sorted.length; i++) {
+		const last = merged[merged.length - 1];
+		if (sorted[i].start <= last.end + 1) last.end = Math.max(last.end, sorted[i].end);
+		else merged.push({ ...sorted[i] });
+	}
+	return merged;
+}
+
+// ── Brace-based elision (TS/JS/Rust) ──
+// NOTE: This is a regex heuristic, not a parser. Braces inside string literals,
+// template strings, regex, and comments are counted, which can produce incorrect
+// elision for edge cases like `const s = "{...}"` or `${expr}`. Acceptable for
+// summaries; do not use for correctness-sensitive parsing.
+
+function findBraceRanges(lines: string[], openPattern: RegExp, minBody: number): Range[] {
+	const ranges: Range[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		if (!openPattern.test(lines[i])) continue;
+		let depth = 0;
+		let foundOpen = false;
+		const start = i;
+		for (let j = i; j < lines.length; j++) {
+			for (const ch of lines[j]) {
+				if (ch === "{") { depth++; foundOpen = true; }
+				else if (ch === "}") { depth--; }
+			}
+			if (foundOpen && depth <= 0) {
+				if (j - start - 1 >= minBody) ranges.push({ start: start + 1, end: j - 1 });
+				break;
+			}
+		}
+	}
+	return ranges;
+}
+
+// ── TypeScript / JavaScript ──
+
+const TS_FN_SIG =
+	/^\s*(export\s+)?(async\s+)?function\s|^\s*(export\s+)?(static\s+|get\s+|set\s+|private\s+|public\s+|protected\s+|readonly\s+)*\*?\s*\w+\s*[\(<]/;
+const TS_CLASS_SIG = /^\s*(export\s+)?(default\s+)?(abstract\s+)?class\s/;
+const TS_STRUCT_SIG = /^\s*(export\s+)?(default\s+)?(const|let|var)\s+\w+\s*=\s*(\[[\s]*$|\{[\s]*$)/;
+
+function tsRanges(lines: string[], minBody: number): Range[] {
+	return [
+		...findBraceRanges(lines, TS_FN_SIG, minBody),
+		...findBraceRanges(lines, TS_CLASS_SIG, minBody),
+		...findBraceRanges(lines, TS_STRUCT_SIG, minBody),
+	];
+}
+
+// ── Block comments ──
+
+function blockCommentRanges(lines: string[], minComment: number): Range[] {
+	const ranges: Range[] = [];
+	let i = 0;
+	while (i < lines.length) {
+		const idx = lines[i].indexOf("/*");
+		if (idx === -1 || lines[i].includes("*/", idx + 2)) { i++; continue; }
+		const openLine = i;
+		let j = i + 1;
+		while (j < lines.length && !lines[j].includes("*/")) j++;
+		if (j < lines.length && j - openLine - 1 >= minComment)
+			ranges.push({ start: openLine + 1, end: j - 1 });
+		i = j + 1;
+	}
+	return ranges;
+}
+
+// ── Import groups ──
+
+const IMPORT_RE = /^\s*import\s/;
+const PY_IMPORT_RE = /^\s*(import\s|from\s+\S+\s+import\s)/;
+
+function importGroupRanges(lines: string[], pattern: RegExp): Range[] {
+	const groups: Array<{ start: number; end: number }> = [];
+	let gs = -1, last = -1;
+	for (let i = 0; i < lines.length; i++) {
+		if (pattern.test(lines[i])) { if (gs === -1) gs = i; last = i; }
+		else if (gs !== -1 && i > last) { groups.push({ start: gs, end: last }); gs = -1; last = -1; }
+	}
+	if (gs !== -1) groups.push({ start: gs, end: last });
+	const ranges: Range[] = [];
+	for (const g of groups) {
+		if (g.end - g.start >= 2) ranges.push({ start: g.start + 1, end: g.end - 1 });
+	}
+	return ranges;
+}
+
+// ── Python ──
+
+function pythonRanges(lines: string[], minBody: number): Range[] {
+	const ranges: Range[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		const m = /^(\s*)(async\s+)?def\s/.exec(lines[i]) || /^(\s*)class\s/.exec(lines[i]);
+		if (!m) continue;
+		const base = m[1].length;
+		let bs = -1, be = -1;
+		for (let j = i + 1; j < lines.length; j++) {
+			if (lines[j].trim() === "") continue;
+			const indent = lines[j].length - lines[j].trimStart().length;
+			if (indent <= base) break;
+			if (bs === -1) bs = j;
+			be = j;
+		}
+		if (bs !== -1 && be - bs + 1 >= minBody) ranges.push({ start: bs, end: be });
+	}
+	ranges.push(...importGroupRanges(lines, PY_IMPORT_RE));
+	return ranges;
+}
+
+// ── Rust ──
+
+const RS_FN_SIG = /^\s*(pub\s+)?(async\s+)?(unsafe\s+)?fn\s/;
+const RS_STRUCT_SIG = /^\s*(pub\s+)?struct\s+\w+.*\{$/;
+const RS_ENUM_SIG = /^\s*(pub\s+)?enum\s+\w+.*\{$/;
+const RS_MOD_SIG = /^\s*(pub\s+)?mod\s+\w+.*\{$/;
+
+function rustRanges(lines: string[], minBody: number): Range[] {
+	return [
+		...findBraceRanges(lines, RS_FN_SIG, minBody),
+		...findBraceRanges(lines, RS_STRUCT_SIG, minBody),
+		...findBraceRanges(lines, RS_ENUM_SIG, minBody),
+		...findBraceRanges(lines, RS_MOD_SIG, minBody),
+	];
+}
+
+// ── Main entry ──
+
+function fullResult(language: string | null, totalLines: number, code: string): SummaryResult {
+	return {
+		language, totalLines, elided: false,
+		segments: [{ kind: "kept", startLine: 1, endLine: totalLines, text: code }],
+		rendered: code,
+	};
+}
+
+export function summarizeCode(
+	code: string,
+	language: string | null,
+	options?: SummaryOptions,
+): SummaryResult {
+	const minBody = options?.minBodyLines ?? 4;
+	const minComment = options?.minCommentLines ?? 6;
+
+	if (!code || code.trim() === "") {
+		return { language, totalLines: 0, elided: false, segments: [], rendered: "" };
+	}
+
+	const lines = code.split("\n");
+	const totalLines = lines.length;
+
+	if (!language) return fullResult(null, totalLines, code);
+
+	const rawRanges: Range[] = [];
+	switch (language) {
+		case "typescript":
+		case "javascript":
+			rawRanges.push(...tsRanges(lines, minBody), ...blockCommentRanges(lines, minComment), ...importGroupRanges(lines, IMPORT_RE));
+			break;
+		case "python":
+			rawRanges.push(...pythonRanges(lines, minBody));
+			break;
+		case "rust":
+			rawRanges.push(...rustRanges(lines, minBody), ...blockCommentRanges(lines, minComment));
+			break;
+		default:
+			return fullResult(language, totalLines, code);
+	}
+
+	const ranges = mergeRanges(rawRanges);
+	if (ranges.length === 0) return fullResult(language, totalLines, code);
+
+	// Build segments
+	const segments: SummarySegment[] = [];
+	let cursor = 0;
+	for (const r of ranges) {
+		if (cursor < r.start) {
+			segments.push({ kind: "kept", startLine: cursor + 1, endLine: r.start, text: lines.slice(cursor, r.start).join("\n") });
+		}
+		segments.push({ kind: "elided", startLine: r.start + 1, endLine: r.end + 1 });
+		cursor = r.end + 1;
+	}
+	if (cursor < totalLines) {
+		segments.push({ kind: "kept", startLine: cursor + 1, endLine: totalLines, text: lines.slice(cursor).join("\n") });
+	}
+
+	// Render
+	const parts: string[] = [];
+	for (const seg of segments) {
+		if (seg.kind === "kept") parts.push(seg.text ?? "");
+		else parts.push(`  ... ${seg.endLine - seg.startLine + 1} lines elided ...`);
+	}
+
+	return { language, totalLines, elided: true, segments, rendered: parts.join("\n") };
+}

package/src/runtime/completion-guard.ts

@@ -1,190 +1,190 @@
-import * as fs from "node:fs";
-import type { TeamTaskState, TeamRunManifest } from "../state/types.ts";
-
-// ============================================================================
-// Phase 1.2: Completion Mutation Guard — detects tasks that claim success but
-// made no observable mutations. Used by task-runner.ts.
-// ============================================================================
-
-export interface CompletionMutationGuardInput {
-	role: string;
-	taskText?: string;
-	transcriptPath?: string;
-	stdout?: string;
-}
-
-export interface CompletionMutationGuardResult {
-	expectedMutation: boolean;
-	observedMutation: boolean;
-	reason?: "no_mutation_observed";
-	observedTools: string[];
-}
-
-const MUTATING_ROLES = new Set(["executor", "test-engineer"]);
-const MUTATING_TOOLS = new Set(["edit", "write", "multi_edit", "apply_patch", "replace_in_file", "insert", "delete_files", "create_file", "overwrite", "patch"]);
-const READ_ONLY_COMMANDS = /^(pwd|ls|dir|cat|type|sed|grep|rg|find|git\s+(status|diff|log|show|branch|remote|rev-parse|ls-files)|npm\s+(test|run\s+(typecheck|check|lint|test|ci))|node\s+--test)\b/i;
-const MUTATING_COMMANDS = /\b(rm\s+-|del\s+|erase\s+|mv\s+|move\s+|cp\s+|copy\s+|mkdir\b|touch\b|git\s+(add|commit|push|reset|clean|checkout|switch|merge|rebase|stash)|npm\s+(install|i|uninstall|publish|version)|pnpm\s+(add|install|remove)|yarn\s+(add|install|remove)|python\b.*>|node\b.*>|echo\b.*>|Set-Content|Out-File|sed\s+-i|tee\b|dd\b.*of=|wget\b.*-O|curl\b.*-o)\b/i;
-const READ_ONLY_HINTS = /\b(read-only|no edits?|do not edit|không sửa|khong sua|chỉ đọc|chi doc|plan only|chỉ lập plan|review only|audit only)\b/i;
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-
-function commandText(value: unknown): string {
-	const record = asRecord(value);
-	if (!record) return typeof value === "string" ? value : "";
-	for (const key of ["command", "cmd", "script", "input"]) {
-		const raw = record[key];
-		if (typeof raw === "string") return raw;
-	}
-	return JSON.stringify(record);
-}
-
-function isMutatingTool(tool: string, args: unknown): boolean {
-	const normalized = tool.toLowerCase();
-	if (MUTATING_TOOLS.has(normalized)) return true;
-	if (normalized === "bash" || normalized === "shell" || normalized === "powershell") {
-		const command = commandText(args).trim();
-		if (!command) return false;
-		// Check mutating patterns first: sed -i is mutating even though plain sed is read-only.
-		if (MUTATING_COMMANDS.test(command)) return true;
-		if (READ_ONLY_COMMANDS.test(command)) return false;
-		// If the command doesn't match either list, treat unknown bash calls as potentially mutating.
-		return true;
-	}
-	return false;
-}
-
-function collectToolCallsFromEvent(event: unknown): Array<{ tool: string; args?: unknown }> {
-	const record = asRecord(event);
-	if (!record) return [];
-	const calls: Array<{ tool: string; args?: unknown }> = [];
-	const directTool = record.toolName ?? record.name ?? record.tool;
-	if (typeof directTool === "string" && (record.type === "tool_execution_start" || record.type === "toolCall" || record.type === "tool_call")) {
-		calls.push({ tool: directTool, args: record.args ?? record.input });
-	}
-	const content = Array.isArray(record.content) ? record.content : asRecord(record.message)?.content;
-	if (Array.isArray(content)) {
-		for (const part of content) {
-			const item = asRecord(part);
-			if (!item) continue;
-			const tool = item.name ?? item.toolName ?? item.tool;
-			if (typeof tool === "string" && (item.type === "toolCall" || item.type === "tool_call" || item.type === "tool_execution_start")) calls.push({ tool, args: item.input ?? item.args });
-		}
-	}
-	return calls;
-}
-
-function transcriptText(input: CompletionMutationGuardInput): string {
-	if (input.transcriptPath && fs.existsSync(input.transcriptPath)) return fs.readFileSync(input.transcriptPath, "utf-8");
-	return input.stdout ?? "";
-}
-
-export function expectsImplementationMutation(input: Pick<CompletionMutationGuardInput, "role" | "taskText">): boolean {
-	if (!MUTATING_ROLES.has(input.role)) return false;
-	return !READ_ONLY_HINTS.test(input.taskText ?? "");
-}
-
-export function evaluateCompletionMutationGuard(input: CompletionMutationGuardInput): CompletionMutationGuardResult {
-	const expectedMutation = expectsImplementationMutation(input);
-	const observedTools: string[] = [];
-	let observedMutation = false;
-	const text = transcriptText(input);
-	for (const line of text.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		let event: unknown;
-		try { event = JSON.parse(trimmed); } catch { continue; }
-		for (const call of collectToolCallsFromEvent(event)) {
-			observedTools.push(call.tool);
-			if (isMutatingTool(call.tool, call.args)) observedMutation = true;
-		}
-	}
-	return {
-		expectedMutation,
-		observedMutation,
-		observedTools,
-		...(expectedMutation && !observedMutation ? { reason: "no_mutation_observed" as const } : {}),
-	};
-}
-
-// ============================================================================
-// Phase 11a: Artifact-based Completion Verification — a second layer that
-// checks whether a completed task actually produced meaningful artifacts.
-// ============================================================================
-
-/**
- * Guard against false-positive task completions.
- *
- * Checks whether a task that claims success actually produced meaningful output.
- * Returns a verification result with the green level (0-3) and any warnings.
- */
-export interface CompletionVerifyResult {
-	/** 0 = no output, 1 = minimal, 2 = moderate, 3 = strong */
-	greenLevel: number;
-	/** Warnings about potentially incomplete work */
-	warnings: string[];
-}
-
-const MAX_OUTPUT_PREVIEW = 200;
-
-function isTrivialError(error: string | undefined): boolean {
-	if (!error) return false;
-	return error.trim().length === 0;
-}
-
-export function verifyTaskCompletion(
-	task: TeamTaskState,
-	manifest: TeamRunManifest,
-): CompletionVerifyResult {
-	const warnings: string[] = [];
-	let greenLevel = 0;
-
-	// Check 1: Has an error?
-	if (task.error && !isTrivialError(task.error)) {
-		return { greenLevel: 0, warnings: [`Task has error: ${task.error}`] };
-	}
-
-	// Check 2: Has result artifact?
-	if (task.resultArtifact) {
-		greenLevel += 1;
-	}
-
-	// Check 3: Has transcript?
-	if (task.transcriptArtifact) {
-		greenLevel += 1;
-	}
-
-	// Check 4: For implementation tasks, verify artifacts were actually produced
-	const runArtifacts = manifest.artifacts.filter(
-		(a) => a.producer === task.id || a.producer === task.agent,
-	);
-	if (runArtifacts.length > 0) {
-		greenLevel += 1;
-	} else if (greenLevel < 3) {
-		warnings.push("No run-level artifacts produced by this task");
-	}
-
-	// Check 5: Usage tracking — did the task actually consume tokens?
-	if (task.usage) {
-		const totalTokens = (task.usage.input ?? 0) + (task.usage.output ?? 0);
-		if (totalTokens === 0 && greenLevel < 3) {
-			warnings.push("Task reports zero token usage — may not have executed");
-		}
-	}
-
-	return {
-		greenLevel: Math.min(greenLevel, 3),
-		warnings,
-	};
-}
-
-/**
- * Format a preview of task output for diagnostic display.
- */
-export function formatOutputPreview(output: string | undefined): string {
-	if (!output) return "(no output)";
-	const trimmed = output.trim();
-	if (trimmed.length <= MAX_OUTPUT_PREVIEW) return trimmed;
-	return trimmed.slice(0, MAX_OUTPUT_PREVIEW) + "...";
-}
+import * as fs from "node:fs";
+import type { TeamTaskState, TeamRunManifest } from "../state/types.ts";
+
+// ============================================================================
+// Phase 1.2: Completion Mutation Guard — detects tasks that claim success but
+// made no observable mutations. Used by task-runner.ts.
+// ============================================================================
+
+export interface CompletionMutationGuardInput {
+	role: string;
+	taskText?: string;
+	transcriptPath?: string;
+	stdout?: string;
+}
+
+export interface CompletionMutationGuardResult {
+	expectedMutation: boolean;
+	observedMutation: boolean;
+	reason?: "no_mutation_observed";
+	observedTools: string[];
+}
+
+const MUTATING_ROLES = new Set(["executor", "test-engineer"]);
+const MUTATING_TOOLS = new Set(["edit", "write", "multi_edit", "apply_patch", "replace_in_file", "insert", "delete_files", "create_file", "overwrite", "patch"]);
+const READ_ONLY_COMMANDS = /^(pwd|ls|dir|cat|type|sed|grep|rg|find|git\s+(status|diff|log|show|branch|remote|rev-parse|ls-files)|npm\s+(test|run\s+(typecheck|check|lint|test|ci))|node\s+--test)\b/i;
+const MUTATING_COMMANDS = /\b(rm\s+-|del\s+|erase\s+|mv\s+|move\s+|cp\s+|copy\s+|mkdir\b|touch\b|git\s+(add|commit|push|reset|clean|checkout|switch|merge|rebase|stash)|npm\s+(install|i|uninstall|publish|version)|pnpm\s+(add|install|remove)|yarn\s+(add|install|remove)|python\b.*>|node\b.*>|echo\b.*>|Set-Content|Out-File|sed\s+-i|tee\b|dd\b.*of=|wget\b.*-O|curl\b.*-o)\b/i;
+const READ_ONLY_HINTS = /\b(read-only|no edits?|do not edit|không sửa|khong sua|chỉ đọc|chi doc|plan only|chỉ lập plan|review only|audit only)\b/i;
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function commandText(value: unknown): string {
+	const record = asRecord(value);
+	if (!record) return typeof value === "string" ? value : "";
+	for (const key of ["command", "cmd", "script", "input"]) {
+		const raw = record[key];
+		if (typeof raw === "string") return raw;
+	}
+	return JSON.stringify(record);
+}
+
+function isMutatingTool(tool: string, args: unknown): boolean {
+	const normalized = tool.toLowerCase();
+	if (MUTATING_TOOLS.has(normalized)) return true;
+	if (normalized === "bash" || normalized === "shell" || normalized === "powershell") {
+		const command = commandText(args).trim();
+		if (!command) return false;
+		// Check mutating patterns first: sed -i is mutating even though plain sed is read-only.
+		if (MUTATING_COMMANDS.test(command)) return true;
+		if (READ_ONLY_COMMANDS.test(command)) return false;
+		// If the command doesn't match either list, treat unknown bash calls as potentially mutating.
+		return true;
+	}
+	return false;
+}
+
+function collectToolCallsFromEvent(event: unknown): Array<{ tool: string; args?: unknown }> {
+	const record = asRecord(event);
+	if (!record) return [];
+	const calls: Array<{ tool: string; args?: unknown }> = [];
+	const directTool = record.toolName ?? record.name ?? record.tool;
+	if (typeof directTool === "string" && (record.type === "tool_execution_start" || record.type === "toolCall" || record.type === "tool_call")) {
+		calls.push({ tool: directTool, args: record.args ?? record.input });
+	}
+	const content = Array.isArray(record.content) ? record.content : asRecord(record.message)?.content;
+	if (Array.isArray(content)) {
+		for (const part of content) {
+			const item = asRecord(part);
+			if (!item) continue;
+			const tool = item.name ?? item.toolName ?? item.tool;
+			if (typeof tool === "string" && (item.type === "toolCall" || item.type === "tool_call" || item.type === "tool_execution_start")) calls.push({ tool, args: item.input ?? item.args });
+		}
+	}
+	return calls;
+}
+
+function transcriptText(input: CompletionMutationGuardInput): string {
+	if (input.transcriptPath && fs.existsSync(input.transcriptPath)) return fs.readFileSync(input.transcriptPath, "utf-8");
+	return input.stdout ?? "";
+}
+
+export function expectsImplementationMutation(input: Pick<CompletionMutationGuardInput, "role" | "taskText">): boolean {
+	if (!MUTATING_ROLES.has(input.role)) return false;
+	return !READ_ONLY_HINTS.test(input.taskText ?? "");
+}
+
+export function evaluateCompletionMutationGuard(input: CompletionMutationGuardInput): CompletionMutationGuardResult {
+	const expectedMutation = expectsImplementationMutation(input);
+	const observedTools: string[] = [];
+	let observedMutation = false;
+	const text = transcriptText(input);
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		let event: unknown;
+		try { event = JSON.parse(trimmed); } catch { continue; }
+		for (const call of collectToolCallsFromEvent(event)) {
+			observedTools.push(call.tool);
+			if (isMutatingTool(call.tool, call.args)) observedMutation = true;
+		}
+	}
+	return {
+		expectedMutation,
+		observedMutation,
+		observedTools,
+		...(expectedMutation && !observedMutation ? { reason: "no_mutation_observed" as const } : {}),
+	};
+}
+
+// ============================================================================
+// Phase 11a: Artifact-based Completion Verification — a second layer that
+// checks whether a completed task actually produced meaningful artifacts.
+// ============================================================================
+
+/**
+ * Guard against false-positive task completions.
+ *
+ * Checks whether a task that claims success actually produced meaningful output.
+ * Returns a verification result with the green level (0-3) and any warnings.
+ */
+export interface CompletionVerifyResult {
+	/** 0 = no output, 1 = minimal, 2 = moderate, 3 = strong */
+	greenLevel: number;
+	/** Warnings about potentially incomplete work */
+	warnings: string[];
+}
+
+const MAX_OUTPUT_PREVIEW = 200;
+
+function isTrivialError(error: string | undefined): boolean {
+	if (!error) return false;
+	return error.trim().length === 0;
+}
+
+export function verifyTaskCompletion(
+	task: TeamTaskState,
+	manifest: TeamRunManifest,
+): CompletionVerifyResult {
+	const warnings: string[] = [];
+	let greenLevel = 0;
+
+	// Check 1: Has an error?
+	if (task.error && !isTrivialError(task.error)) {
+		return { greenLevel: 0, warnings: [`Task has error: ${task.error}`] };
+	}
+
+	// Check 2: Has result artifact?
+	if (task.resultArtifact) {
+		greenLevel += 1;
+	}
+
+	// Check 3: Has transcript?
+	if (task.transcriptArtifact) {
+		greenLevel += 1;
+	}
+
+	// Check 4: For implementation tasks, verify artifacts were actually produced
+	const runArtifacts = manifest.artifacts.filter(
+		(a) => a.producer === task.id || a.producer === task.agent,
+	);
+	if (runArtifacts.length > 0) {
+		greenLevel += 1;
+	} else if (greenLevel < 3) {
+		warnings.push("No run-level artifacts produced by this task");
+	}
+
+	// Check 5: Usage tracking — did the task actually consume tokens?
+	if (task.usage) {
+		const totalTokens = (task.usage.input ?? 0) + (task.usage.output ?? 0);
+		if (totalTokens === 0 && greenLevel < 3) {
+			warnings.push("Task reports zero token usage — may not have executed");
+		}
+	}
+
+	return {
+		greenLevel: Math.min(greenLevel, 3),
+		warnings,
+	};
+}
+
+/**
+ * Format a preview of task output for diagnostic display.
+ */
+export function formatOutputPreview(output: string | undefined): string {
+	if (!output) return "(no output)";
+	const trimmed = output.trim();
+	if (trimmed.length <= MAX_OUTPUT_PREVIEW) return trimmed;
+	return trimmed.slice(0, MAX_OUTPUT_PREVIEW) + "...";
+}