@sayknow-cli/coding-agent 0.3.7 → 0.3.8

package/src/tools/ultragoal-ask-guard.ts

@@ -10,6 +10,29 @@ const ULTRAGOAL_ASK_GUARD = Symbol.for("sayknow-cli.ultragoalAskGuard");
 
 type GuardedTool = AgentTool & { [ULTRAGOAL_ASK_GUARD]?: true };
 
+export interface UltragoalAskGuardContext {
+	activeSkillState?: { skill?: string; session_id?: string } | null;
+	sessionId?: string | null;
+}
+
+const UPSTREAM_PLANNING_ASK_SKILLS = new Set(["deep-interview", "ralplan"]);
+
+function normalizedActiveSkill(context?: UltragoalAskGuardContext): string | undefined {
+	const skill = context?.activeSkillState?.skill?.trim();
+	return skill || undefined;
+}
+
+function sessionScopedAskGuardId(
+	context: UltragoalAskGuardContext,
+	activeSkill: string | undefined,
+): string | undefined {
+	if (activeSkill !== "ultragoal" && !UPSTREAM_PLANNING_ASK_SKILLS.has(activeSkill ?? "")) return undefined;
+	const activeSessionId = context.activeSkillState?.session_id?.trim();
+	if (activeSessionId) return activeSessionId;
+	const sessionId = context.sessionId?.trim();
+	return sessionId || undefined;
+}
+
 export function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiagnostic): string {
 	return [
 		diagnostic.message,
@@ -18,15 +41,26 @@ export function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiag
 	].join("\n");
 }
 
-export async function assertUltragoalAskAllowed(cwd: string): Promise<void> {
-	const diagnostic = await isUltragoalAskBlocked(cwd);
+export async function assertUltragoalAskAllowed(cwd: string, context: UltragoalAskGuardContext = {}): Promise<void> {
+	const activeSkill = normalizedActiveSkill(context);
+	// Deep-interview and ralplan are upstream planning workflows whose core gates
+	// are `ask` calls. Scope their Ultragoal check to the current session so stale
+	// or ambiguous Ultragoal durable state from another session cannot hijack those
+	// prompts; same-session active Ultragoal state still falls through to the
+	// blocker/nudge checks below.
+	const sessionId = sessionScopedAskGuardId(context, activeSkill);
+	const diagnostic = await isUltragoalAskBlocked(cwd, { sessionId });
 	if (!diagnostic.active) return;
-	const nudge = await consumeUltragoalAskNudge(cwd);
+	const nudge = await consumeUltragoalAskNudge(cwd, sessionId);
 	if (nudge.nudged) throw new ToolError(nudge.message);
 	throw new ToolError(formatUltragoalAskBlockMessage(diagnostic));
 }
 
-export function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: () => string): T {
+export function guardToolForUltragoalAsk<T extends AgentTool>(
+	tool: T,
+	getCwd: () => string,
+	getContext: () => UltragoalAskGuardContext = () => ({}),
+): T {
 	if (tool.name !== "ask") return tool;
 	const candidate = tool as GuardedTool;
 	if (candidate[ULTRAGOAL_ASK_GUARD]) return tool;
@@ -35,7 +69,7 @@ export function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: (
 			if (prop === ULTRAGOAL_ASK_GUARD) return true;
 			if (prop !== "execute") return Reflect.get(target, prop, receiver);
 			return async (...args: unknown[]): Promise<unknown> => {
-				await assertUltragoalAskAllowed(getCwd());
+				await assertUltragoalAskAllowed(getCwd(), getContext());
 				return Reflect.apply(target.execute, target, args);
 			};
 		},

package/src/utils/file-mentions.ts

@@ -159,24 +159,32 @@ async function resolveMentionPath(
 	return best?.candidate.path ?? null;
 }
 
-function buildTextOutput(textContent: string): { output: string; lineCount: number } {
+/**
+ * Default inline cap for auto-read file mentions, deliberately below the
+ * read-tool cap (`DEFAULT_MAX_BYTES`, 50KB) so an incidental `@path` mention
+ * injects a smaller snippet than an explicit `read`. Overridable per call.
+ */
+export const DEFAULT_FILE_MENTION_INLINE_BYTES = 20 * 1024;
+
+function buildTextOutput(textContent: string, maxInlineBytes?: number): { output: string; lineCount: number } {
+	const cap = maxInlineBytes && maxInlineBytes > 0 ? maxInlineBytes : DEFAULT_FILE_MENTION_INLINE_BYTES;
 	const allLines = textContent.split("\n");
 	const totalFileLines = allLines.length;
-	const truncation = truncateHead(textContent);
+	const truncation = truncateHead(textContent, { maxBytes: cap });
 
 	if (truncation.firstLineExceedsLimit) {
 		const firstLine = allLines[0] ?? "";
 		const firstLineBytes = Buffer.byteLength(firstLine, "utf-8");
-		const snippet = truncateHeadBytes(firstLine, DEFAULT_MAX_BYTES);
+		const snippet = truncateHeadBytes(firstLine, cap);
 		let outputText = snippet.text;
 
 		if (outputText.length > 0) {
 			outputText += `\n\n[Line 1 is ${formatBytes(firstLineBytes)}, exceeds ${formatBytes(
-				DEFAULT_MAX_BYTES,
+				cap,
 			)} limit. Showing first ${formatBytes(snippet.bytes)} of the line.]`;
 		} else {
 			outputText = `[Line 1 is ${formatBytes(firstLineBytes)}, exceeds ${formatBytes(
-				DEFAULT_MAX_BYTES,
+				cap,
 			)} limit. Unable to display a valid UTF-8 snippet.]`;
 		}
 
@@ -277,7 +285,18 @@ export function extractFileMentions(text: string): string[] {
 export async function generateFileMentionMessages(
 	filePaths: string[],
 	cwd: string,
-	options?: { autoResizeImages?: boolean; useHashLines?: boolean },
+	options?: {
+		autoResizeImages?: boolean;
+		useHashLines?: boolean;
+		/** Inline byte cap for auto-read text. Default: DEFAULT_FILE_MENTION_INLINE_BYTES. */
+		maxInlineBytes?: number;
+		/**
+		 * Resolved paths already shown (read or mentioned) recently in the
+		 * conversation. A mention of one of these emits a compact duplicate note
+		 * instead of re-injecting the full body.
+		 */
+		recentlyShownPaths?: ReadonlySet<string>;
+	},
 ): Promise<AgentMessage[]> {
 	if (filePaths.length === 0) return [];
 
@@ -290,12 +309,25 @@ export async function generateFileMentionMessages(
 		return mentionCandidatesPromise;
 	};
 
+	const shownInBatch = new Set<string>();
 	for (const filePath of filePaths) {
 		const resolvedPath = await resolveMentionPath(filePath, cwd, getMentionCandidates);
 		if (!resolvedPath) {
 			continue;
 		}
 		const absolutePath = resolveReadPath(resolvedPath, cwd);
+		// Duplicate suppression, keyed by absolute path: same path shown earlier this
+		// batch or recently in the conversation → compact note, no re-read (the path
+		// stays referenced so the model can re-fetch via the read tool).
+		if (shownInBatch.has(absolutePath) || options?.recentlyShownPaths?.has(absolutePath)) {
+			files.push({
+				path: resolvedPath,
+				content: `(already shown in this conversation; not re-read — use the read tool to fetch \`${resolvedPath}\` again)`,
+				duplicate: true,
+			});
+			continue;
+		}
+		shownInBatch.add(absolutePath);
 		try {
 			const stat = await Bun.file(absolutePath).stat();
 			if (stat.isDirectory()) {
@@ -354,7 +386,7 @@ export async function generateFileMentionMessages(
 			}
 
 			const content = await Bun.file(absolutePath).text();
-			let { output, lineCount } = buildTextOutput(content);
+			let { output, lineCount } = buildTextOutput(content, options?.maxInlineBytes);
 			if (options?.useHashLines) {
 				output = formatHashLines(output);
 			}

package/src/utils/git.ts

@@ -1317,6 +1317,79 @@ export async function clean(
 	await runEffect(cwd, args, { signal: options.signal });
 }
 
+// ════════════════════════════════════════════════════════════════════════════
+// API: bisect
+// ════════════════════════════════════════════════════════════════════════════
+
+export interface BisectCommitInfo {
+	sha: string;
+	author: string;
+	date: string;
+	subject: string;
+	stat: string;
+}
+
+/**
+ * Thin wrappers over `git bisect`. The marking commands (`good`/`bad`/`skip`)
+ * return the raw {@link GitCommandResult} without throwing so callers can both
+ * detect a genuine failure (non-zero exit) and scan the output for the
+ * "<sha> is the first bad commit" conclusion. `reset` is best-effort and never
+ * throws so it is safe to call from a `finally` block to restore the worktree.
+ */
+export const bisect = {
+	/** Begin a bisect session (does not seed good/bad endpoints). */
+	async start(cwd: string, signal?: AbortSignal): Promise<void> {
+		await runEffect(cwd, ["bisect", "start"], { signal });
+	},
+
+	/** Mark a revision (or current HEAD when omitted) good. Returns raw output. */
+	async good(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult> {
+		return runCommand(cwd, ref ? ["bisect", "good", ref] : ["bisect", "good"], { signal });
+	},
+
+	/** Mark a revision (or current HEAD when omitted) bad. Returns raw output. */
+	async bad(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult> {
+		return runCommand(cwd, ref ? ["bisect", "bad", ref] : ["bisect", "bad"], { signal });
+	},
+
+	/** Skip the current (untestable) revision. Returns raw output. */
+	async skip(cwd: string, signal?: AbortSignal): Promise<GitCommandResult> {
+		return runCommand(cwd, ["bisect", "skip"], { signal });
+	},
+
+	/** Read the replayable bisect log for the current session. */
+	async log(cwd: string, signal?: AbortSignal): Promise<string> {
+		return runText(cwd, ["bisect", "log"], { signal });
+	},
+
+	/** End the bisect session, restoring the original HEAD. Never throws. */
+	async reset(cwd: string, signal?: AbortSignal): Promise<void> {
+		await runCommand(cwd, ["bisect", "reset"], { signal });
+	},
+
+	/** True when `ancestor` is a first-parent-or-merge ancestor of `descendant`. */
+	async isAncestor(cwd: string, ancestor: string, descendant: string, signal?: AbortSignal): Promise<boolean> {
+		const result = await runCommand(cwd, ["merge-base", "--is-ancestor", ancestor, descendant], {
+			readOnly: true,
+			signal,
+		});
+		return result.exitCode === 0;
+	},
+
+	/** Resolve author/date/subject and a diffstat for a commit (for the receipt). */
+	async describe(cwd: string, sha: string, signal?: AbortSignal): Promise<BisectCommitInfo> {
+		// Newline-delimited so the format string carries no NUL byte (argv cannot
+		// contain NUL); %s is already a single line, so the four fields never wrap.
+		const meta = await runText(cwd, ["show", "-s", "--format=%H%n%an <%ae>%n%aI%n%s", sha], {
+			readOnly: true,
+			signal,
+		});
+		const [resolvedSha = sha, author = "", date = "", subject = ""] = meta.split("\n");
+		const stat = await runText(cwd, ["show", "--stat", "--format=", sha], { readOnly: true, signal });
+		return { sha: resolvedSha, author, date, subject, stat: stat.trim() };
+	},
+};
+
 // ════════════════════════════════════════════════════════════════════════════
 // API: ls
 // ════════════════════════════════════════════════════════════════════════════

package/src/web/scrapers/youtube.ts

@@ -10,44 +10,56 @@ import { extractWithParallel, findParallelApiKey, getParallelExtractContent } fr
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, formatMediaDuration, formatNumber } from "./types";
 
-interface YouTubeUrl {
+export interface YouTubeUrl {
 	videoId: string;
 	playlistId?: string;
 }
 
+const YOUTUBE_VIDEO_ID_PATTERN = /^[a-zA-Z0-9_-]{11}$/;
+
+function isYouTubeHost(hostname: string): boolean {
+	return hostname === "youtube.com" || hostname === "m.youtube.com" || hostname === "music.youtube.com";
+}
+
+function isYouTubeEmbedHost(hostname: string): boolean {
+	return isYouTubeHost(hostname) || hostname === "youtube-nocookie.com";
+}
+
 /**
  * Parse YouTube URL into components
  */
-function parseYouTubeUrl(url: string): YouTubeUrl | null {
+export function parseYouTubeUrl(url: string): YouTubeUrl | null {
 	try {
 		const parsed = new URL(url);
 		const hostname = parsed.hostname.replace(/^www\./, "");
 
-		// youtube.com/watch?v=VIDEO_ID
-		if ((hostname === "youtube.com" || hostname === "m.youtube.com") && parsed.pathname === "/watch") {
+		// youtube.com/watch?v=VIDEO_ID and music.youtube.com/watch?v=VIDEO_ID
+		if (isYouTubeHost(hostname) && parsed.pathname === "/watch") {
 			const videoId = parsed.searchParams.get("v");
 			const playlistId = parsed.searchParams.get("list") || undefined;
-			if (videoId) return { videoId, playlistId };
+			if (videoId && YOUTUBE_VIDEO_ID_PATTERN.test(videoId)) return { videoId, playlistId };
 		}
 
-		// youtube.com/v/VIDEO_ID or youtube.com/embed/VIDEO_ID
-		if (hostname === "youtube.com" || hostname === "m.youtube.com") {
-			const match = parsed.pathname.match(/^\/(v|embed)\/([a-zA-Z0-9_-]{11})/);
+		// youtube.com/v/VIDEO_ID, youtube.com/embed/VIDEO_ID, youtube.com/live/VIDEO_ID,
+		// and youtube-nocookie.com/embed/VIDEO_ID. Require the id segment to end
+		// before matching so malformed overlong ids are not silently truncated.
+		if (isYouTubeEmbedHost(hostname)) {
+			const match = parsed.pathname.match(/^\/(v|embed|live)\/([a-zA-Z0-9_-]{11})(?:$|\/)/);
 			if (match) return { videoId: match[2] };
 		}
 
 		// youtu.be/VIDEO_ID
 		if (hostname === "youtu.be") {
 			const videoId = parsed.pathname.slice(1).split("/")[0];
-			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+			if (videoId && YOUTUBE_VIDEO_ID_PATTERN.test(videoId)) {
 				return { videoId };
 			}
 		}
 
-		// youtube.com/shorts/VIDEO_ID
-		if (hostname === "youtube.com" && parsed.pathname.startsWith("/shorts/")) {
+		// youtube.com/shorts/VIDEO_ID and m.youtube.com/shorts/VIDEO_ID
+		if (isYouTubeHost(hostname) && parsed.pathname.startsWith("/shorts/")) {
 			const videoId = parsed.pathname.replace("/shorts/", "").split("/")[0];
-			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+			if (videoId && YOUTUBE_VIDEO_ID_PATTERN.test(videoId)) {
 				return { videoId };
 			}
 		}

package/src/workflow/workflow-intent-diff.ts

@@ -1,6 +1,15 @@
+import {
+	buildWorkflowIntentReport,
+	type WorkflowClaimsLedger,
+	type WorkflowConsensusReport,
+} from "./workflow-intent-report";
+
 export const WORKFLOW_INTENT_DIFF_CUSTOM_TYPE = "workflow-intent-diff";
+export const WORKFLOW_INTENT_ROUTES = ["direct", "deep-interview", "ralplan", "ultragoal", "team"] as const;
+export const WORKFLOW_ESCALATION_ROUTES = ["deep-interview", "ralplan", "ultragoal", "team"] as const;
 
-export type WorkflowIntentRoute = "direct" | "deep-interview" | "ralplan" | "ultragoal" | "team";
+export type WorkflowIntentRoute = (typeof WORKFLOW_INTENT_ROUTES)[number];
+export type WorkflowEscalationRoute = (typeof WORKFLOW_ESCALATION_ROUTES)[number];
 export type DirectTrackingMode = "custom-entry-only" | "not-direct";
 export type RootCausePhaseStatus = "active" | "inactive";
 
@@ -9,13 +18,15 @@ export interface WorkflowIntentDiff {
 	readonly route: WorkflowIntentRoute;
 	readonly reason: string;
 	readonly directTracking: DirectTrackingMode;
-	readonly recommendedSkill?: Exclude<WorkflowIntentRoute, "direct">;
+	readonly recommendedSkill?: WorkflowEscalationRoute;
 	readonly recommendedInvocation?: string;
 	readonly triggers: readonly string[];
 	readonly rootCausePhase: {
 		readonly status: RootCausePhaseStatus;
 		readonly triggers: readonly string[];
 	};
+	readonly claimsLedger: WorkflowClaimsLedger;
+	readonly consensusReport: WorkflowConsensusReport;
 	readonly promptPreview: string;
 }
 
@@ -182,6 +193,19 @@ export function buildWorkflowIntentDiff(text: string): WorkflowIntentDiff | null
 	const rootCauseTriggers = collectRootCauseTriggers(text);
 	const rootCauseActive = rootCauseTriggers.length > 0;
 	const direct = route.route === "direct";
+	const rootCauseStatus: RootCausePhaseStatus = rootCauseActive ? "active" : "inactive";
+	const rootCausePhase = {
+		status: rootCauseStatus,
+		triggers: rootCauseTriggers,
+	};
+	const report = buildWorkflowIntentReport({
+		route: route.route,
+		reason: route.reason,
+		direct,
+		recommendedInvocation: route.recommendedInvocation,
+		triggers: route.triggers,
+		rootCausePhase,
+	});
 
 	return {
 		version: 1,
@@ -190,10 +214,9 @@ export function buildWorkflowIntentDiff(text: string): WorkflowIntentDiff | null
 		directTracking: direct ? "custom-entry-only" : "not-direct",
 		...(direct ? {} : { recommendedSkill: route.route, recommendedInvocation: route.recommendedInvocation }),
 		triggers: route.triggers,
-		rootCausePhase: {
-			status: rootCauseActive ? "active" : "inactive",
-			triggers: rootCauseTriggers,
-		},
+		rootCausePhase,
+		claimsLedger: report.claimsLedger,
+		consensusReport: report.consensusReport,
 		promptPreview,
 	};
 }

package/src/workflow/workflow-intent-report-consumer.ts

@@ -0,0 +1,221 @@
+import type { SessionEntry } from "../session/session-manager";
+import {
+	WORKFLOW_INTENT_DIFF_CUSTOM_TYPE,
+	WORKFLOW_INTENT_ROUTES,
+	type WorkflowIntentDiff,
+	type WorkflowIntentRoute,
+} from "./workflow-intent-diff";
+import type { WorkflowSignalObserver } from "./workflow-intent-report";
+import { parseWorkflowIntentDiffPayload } from "./workflow-intent-report-schema";
+
+export type WorkflowConsumerConfidence = "none" | "low" | "medium" | "high";
+
+export interface WorkflowRouteCounts {
+	readonly direct: number;
+	readonly "deep-interview": number;
+	readonly ralplan: number;
+	readonly ultragoal: number;
+	readonly team: number;
+}
+
+export interface WorkflowIntentReportEntry {
+	readonly entryId: string;
+	readonly timestamp: string;
+	readonly intent: WorkflowIntentDiff;
+}
+
+export interface WorkflowIntentReportTotals {
+	readonly total: number;
+	readonly byRoute: WorkflowRouteCounts;
+	readonly escalationRequired: number;
+	readonly rootCauseActive: number;
+}
+
+export interface WorkflowIntentReportCollection {
+	readonly entries: readonly WorkflowIntentReportEntry[];
+	readonly latest: WorkflowIntentReportEntry | undefined;
+	readonly totals: WorkflowIntentReportTotals;
+}
+
+export interface WorkflowObserverSignalSummary {
+	readonly observer: WorkflowSignalObserver;
+	readonly conclusion: string;
+	readonly count: number;
+}
+
+export interface WorkflowConsensusSummary {
+	readonly total: number;
+	readonly dominantRoute: WorkflowIntentRoute | undefined;
+	readonly confidence: WorkflowConsumerConfidence;
+	readonly escalationGate: {
+		readonly required: boolean;
+		readonly count: number;
+		readonly latestReason: string | undefined;
+	};
+	readonly rootCausePhase: {
+		readonly active: boolean;
+		readonly count: number;
+		readonly triggers: readonly string[];
+	};
+	readonly observerSignals: readonly WorkflowObserverSignalSummary[];
+}
+
+function emptyRouteCounts(): WorkflowRouteCounts {
+	return {
+		direct: 0,
+		"deep-interview": 0,
+		ralplan: 0,
+		ultragoal: 0,
+		team: 0,
+	};
+}
+
+function parseWorkflowIntentDiffEntry(entry: SessionEntry): WorkflowIntentReportEntry | undefined {
+	if (entry.type !== "custom" || entry.customType !== WORKFLOW_INTENT_DIFF_CUSTOM_TYPE) return undefined;
+	const intent = parseWorkflowIntentDiffPayload(entry.data);
+	if (!intent) return undefined;
+	return { entryId: entry.id, timestamp: entry.timestamp, intent };
+}
+
+function incrementRoute(counts: WorkflowRouteCounts, route: WorkflowIntentRoute): WorkflowRouteCounts {
+	switch (route) {
+		case "direct":
+			return { ...counts, direct: counts.direct + 1 };
+		case "deep-interview":
+			return { ...counts, "deep-interview": counts["deep-interview"] + 1 };
+		case "ralplan":
+			return { ...counts, ralplan: counts.ralplan + 1 };
+		case "ultragoal":
+			return { ...counts, ultragoal: counts.ultragoal + 1 };
+		case "team":
+			return { ...counts, team: counts.team + 1 };
+	}
+}
+
+function routeCount(counts: WorkflowRouteCounts, route: WorkflowIntentRoute): number {
+	switch (route) {
+		case "direct":
+			return counts.direct;
+		case "deep-interview":
+			return counts["deep-interview"];
+		case "ralplan":
+			return counts.ralplan;
+		case "ultragoal":
+			return counts.ultragoal;
+		case "team":
+			return counts.team;
+	}
+}
+
+export function collectWorkflowIntentReports(entries: readonly SessionEntry[]): WorkflowIntentReportCollection {
+	const reports: WorkflowIntentReportEntry[] = [];
+	let byRoute = emptyRouteCounts();
+	let escalationRequired = 0;
+	let rootCauseActive = 0;
+
+	for (const entry of entries) {
+		const report = parseWorkflowIntentDiffEntry(entry);
+		if (!report) continue;
+		reports.push(report);
+		byRoute = incrementRoute(byRoute, report.intent.route);
+		if (report.intent.consensusReport.escalationGate.status === "required") escalationRequired += 1;
+		if (report.intent.rootCausePhase.status === "active") rootCauseActive += 1;
+	}
+
+	return {
+		entries: reports,
+		latest: reports[reports.length - 1],
+		totals: {
+			total: reports.length,
+			byRoute,
+			escalationRequired,
+			rootCauseActive,
+		},
+	};
+}
+
+function dominantRouteFor(counts: WorkflowRouteCounts, total: number): WorkflowIntentRoute | undefined {
+	if (total === 0) return undefined;
+	let dominant: WorkflowIntentRoute | undefined;
+	let dominantCount = 0;
+	let tied = false;
+
+	for (const route of WORKFLOW_INTENT_ROUTES) {
+		const count = routeCount(counts, route);
+		if (count > dominantCount) {
+			dominant = route;
+			dominantCount = count;
+			tied = false;
+			continue;
+		}
+		if (count === dominantCount && count > 0) tied = true;
+	}
+
+	return tied ? undefined : dominant;
+}
+
+function confidenceFor(
+	total: number,
+	dominantCount: number,
+	dominantRoute: WorkflowIntentRoute | undefined,
+): WorkflowConsumerConfidence {
+	if (total === 0) return "none";
+	if (!dominantRoute) return "low";
+	const ratio = dominantCount / total;
+	if (ratio === 1) return "high";
+	if (ratio >= 0.5) return "medium";
+	return "low";
+}
+
+export function summarizeWorkflowConsensus(intents: readonly WorkflowIntentDiff[]): WorkflowConsensusSummary {
+	let byRoute = emptyRouteCounts();
+	let escalationCount = 0;
+	let latestEscalationReason: string | undefined;
+	let activeRootCauseCount = 0;
+	const rootCauseTriggers: string[] = [];
+	const observerSignalCounts = new Map<string, WorkflowObserverSignalSummary>();
+
+	for (const intent of intents) {
+		byRoute = incrementRoute(byRoute, intent.route);
+		if (intent.consensusReport.escalationGate.status === "required") {
+			escalationCount += 1;
+			latestEscalationReason = intent.consensusReport.escalationGate.reason;
+		}
+		if (intent.rootCausePhase.status === "active") {
+			activeRootCauseCount += 1;
+			for (const trigger of intent.rootCausePhase.triggers) {
+				if (!rootCauseTriggers.includes(trigger)) rootCauseTriggers.push(trigger);
+			}
+		}
+		for (const signal of intent.consensusReport.observerSignals) {
+			const key = `${signal.observer}\u0000${signal.conclusion}`;
+			const existing = observerSignalCounts.get(key);
+			observerSignalCounts.set(key, {
+				observer: signal.observer,
+				conclusion: signal.conclusion,
+				count: existing ? existing.count + 1 : 1,
+			});
+		}
+	}
+
+	const total = intents.length;
+	const dominantRoute = dominantRouteFor(byRoute, total);
+	const dominantCount = dominantRoute ? routeCount(byRoute, dominantRoute) : 0;
+
+	return {
+		total,
+		dominantRoute,
+		confidence: confidenceFor(total, dominantCount, dominantRoute),
+		escalationGate: {
+			required: escalationCount > 0,
+			count: escalationCount,
+			latestReason: latestEscalationReason,
+		},
+		rootCausePhase: {
+			active: activeRootCauseCount > 0,
+			count: activeRootCauseCount,
+			triggers: rootCauseTriggers,
+		},
+		observerSignals: Array.from(observerSignalCounts.values()),
+	};
+}