@sayknow-cli/coding-agent 0.3.7 → 0.3.9

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/utils/pasted-image-path.ts

@@ -0,0 +1,170 @@
+/**
+ * Resolve pasted editor text to an image file path.
+ *
+ * Terminals insert a shell-escaped filesystem path when a file is drag-dropped
+ * onto them (e.g. macOS `Screenshot\ 2026-07-07\ at\ 11.06.38 PM.png`, where
+ * the visible "space" before AM/PM is U+202F and stays unescaped). When the
+ * entire paste is a single path to an existing image file, the interactive
+ * editor attaches the image and inserts an `[image N]` placeholder instead of
+ * leaving the raw path in the prompt.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const IMAGE_FILE_EXTENSION_PATTERN = /\.(?:png|jpe?g|gif|webp)$/i;
+
+export interface DecodePastedPathOptions {
+	/**
+	 * Platform whose path semantics apply when decoding (shell unescaping,
+	 * `file://` drive letters / UNC hosts). Defaults to `process.platform`;
+	 * injectable so tests can pin the win32 contract from any host.
+	 */
+	platform?: NodeJS.Platform;
+	/** Home directory for `~/` expansion. Defaults to `os.homedir()`. */
+	homedir?: string;
+}
+
+export interface ResolvePastedImagePathOptions extends DecodePastedPathOptions {
+	/** Base directory for relative paths. Defaults to `process.cwd()`. */
+	cwd?: string;
+}
+
+/**
+ * Convert a `file://` URI to a filesystem path for the given platform, or
+ * `undefined` when the URI is invalid.
+ *
+ * The production path (injected platform === host platform, always true
+ * outside tests) delegates to Node's `fileURLToPath`. When tests inject a
+ * foreign platform, a mirror of `fileURLToPath`'s rules is applied instead —
+ * Bun (1.3) accepts but ignores `fileURLToPath`'s `windows` option, so the
+ * native call cannot emulate a foreign platform.
+ */
+function decodeFileUrl(candidate: string, platform: NodeJS.Platform): string | undefined {
+	let url: URL;
+	try {
+		url = new URL(candidate);
+	} catch {
+		return undefined;
+	}
+	if (url.protocol !== "file:") return undefined;
+
+	if (platform === process.platform) {
+		try {
+			return fileURLToPath(url);
+		} catch {
+			return undefined;
+		}
+	}
+
+	// Foreign-platform mirror of fileURLToPath (tests only).
+	if (/%2f/i.test(url.pathname) || (platform === "win32" && /%5c/i.test(url.pathname))) return undefined;
+	let pathname: string;
+	try {
+		pathname = decodeURIComponent(url.pathname);
+	} catch {
+		return undefined;
+	}
+	if (platform === "win32") {
+		if (url.hostname && url.hostname !== "localhost") {
+			// UNC: file://server/share/img.png -> \\server\share\img.png
+			return `\\\\${url.hostname}${pathname.replaceAll("/", "\\")}`;
+		}
+		// Drive letter required: file:///C:/x -> C:\x
+		if (!/^\/[A-Za-z]:/.test(pathname)) return undefined;
+		return pathname.slice(1).replaceAll("/", "\\");
+	}
+	if (url.hostname && url.hostname !== "localhost") return undefined;
+	return pathname;
+}
+
+/**
+ * Decode pasted text into a filesystem path candidate. No filesystem access.
+ *
+ * Handles terminal drag-drop shell escaping (`\ `, `\(`, ...; skipped on
+ * win32 where `\` is the path separator), quoted paths, `file://` URIs
+ * (drive-letter, `file://localhost`, and UNC forms on win32), and `~/`
+ * expansion. Returns `undefined` when the text is empty, spans multiple
+ * lines, or is an invalid `file://` URI.
+ */
+export function decodePastedPathCandidate(text: string, options?: DecodePastedPathOptions): string | undefined {
+	const platform = options?.platform ?? process.platform;
+	let candidate = text.trim();
+	if (!candidate || /[\r\n]/.test(candidate)) return undefined;
+
+	// Quoted paths (some terminals quote instead of escaping).
+	if (
+		candidate.length >= 2 &&
+		(candidate.startsWith('"') || candidate.startsWith("'")) &&
+		candidate.endsWith(candidate[0])
+	) {
+		candidate = candidate.slice(1, -1);
+	}
+
+	if (candidate.startsWith("file://")) {
+		const decoded = decodeFileUrl(candidate, platform);
+		if (decoded === undefined) return undefined;
+		candidate = decoded;
+	} else if (platform !== "win32") {
+		// Terminal drag-drop escapes shell-special characters (`\ `, `\(`, ...).
+		// Skipped on Windows where `\` is the path separator.
+		candidate = candidate.replace(/\\(.)/g, "$1");
+	}
+
+	if (candidate.startsWith("~/")) {
+		candidate = path.join(options?.homedir ?? os.homedir(), candidate.slice(2));
+	}
+
+	return candidate;
+}
+
+/**
+ * Sniff the file header for a supported image signature (PNG, JPEG, GIF,
+ * WEBP). Prevents existing non-image files with image-looking extensions
+ * (e.g. a text file named `not-image.png`) from being treated as image
+ * candidates — consuming such a paste would lose the raw path when the
+ * image loader later rejects the content.
+ */
+function hasSupportedImageMagic(filePath: string): boolean {
+	let fd: number;
+	try {
+		fd = fs.openSync(filePath, "r");
+	} catch {
+		return false;
+	}
+	try {
+		// Zero-filled; short reads leave trailing zeros so comparisons fail safely.
+		const header = Buffer.alloc(12);
+		fs.readSync(fd, header, 0, 12, 0);
+		if (header[0] === 0x89 && header[1] === 0x50 && header[2] === 0x4e && header[3] === 0x47) return true; // PNG
+		if (header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff) return true; // JPEG
+		const ascii6 = header.toString("latin1", 0, 6);
+		if (ascii6 === "GIF87a" || ascii6 === "GIF89a") return true; // GIF
+		if (header.toString("latin1", 0, 4) === "RIFF" && header.toString("latin1", 8, 12) === "WEBP") return true; // WEBP
+		return false;
+	} catch {
+		return false;
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+
+/**
+ * Returns the resolved path when the whole pasted text is a single path to an
+ * existing image file (verified by extension AND content signature),
+ * otherwise `undefined` (the paste is inserted as text).
+ */
+export function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined {
+	const candidate = decodePastedPathCandidate(text, options);
+	if (!candidate || !IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
+
+	const resolved = path.resolve(options?.cwd ?? process.cwd(), candidate);
+	try {
+		if (!fs.statSync(resolved).isFile()) return undefined;
+	} catch {
+		return undefined;
+	}
+	if (!hasSupportedImageMagic(resolved)) return undefined;
+	return resolved;
+}

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,
 	};
 }