@usepipr/runtime 0.3.6 → 0.3.7

package/dist/{commands-C6wfO-y7.d.mts → commands-Bcta0T4L.d.mts}

@@ -304,6 +304,19 @@ declare const publicationMetadataSchema: z.ZodObject<{
   validFindings: z.ZodNumber;
   droppedFindings: z.ZodNumber;
   cappedInlineFindings: z.ZodNumber;
+  stats: z.ZodOptional<z.ZodObject<{
+    models: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    agentRuns: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    costUsd: z.ZodNumber;
+    usageStatus: z.ZodEnum<{
+      complete: "complete";
+      partial: "partial";
+      unavailable: "unavailable";
+    }>;
+  }, z.core.$strict>>;
 }, z.core.$strict>;
 type PublicationMetadata = z.infer<typeof publicationMetadataSchema>;
 declare const publicationPlanSchema: z.ZodObject<{
@@ -334,6 +347,19 @@ declare const publicationPlanSchema: z.ZodObject<{
     validFindings: z.ZodNumber;
     droppedFindings: z.ZodNumber;
     cappedInlineFindings: z.ZodNumber;
+    stats: z.ZodOptional<z.ZodObject<{
+      models: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+      agentRuns: z.ZodNumber;
+      durationMs: z.ZodNumber;
+      inputTokens: z.ZodNumber;
+      outputTokens: z.ZodNumber;
+      costUsd: z.ZodNumber;
+      usageStatus: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        unavailable: "unavailable";
+      }>;
+    }, z.core.$strict>>;
   }, z.core.$strict>;
   reviewState: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -872,4 +898,4 @@ declare function runActionCommand(options: ActionCommandOptions): Promise<Action
 declare function runActionCommandWithDependencies(options: ActionCommandDependencyOptions): Promise<ActionCommandResult>;
 //#endregion
 export { PlatformInfo as A, GitHubPublicationClient as C, ChangeRequestRef as D, ChangeRequestEventContext as E, supportedOfficialInitAdapters as F, RepositoryRef as M, RuntimeSettings as N, DiffManifest as O, OfficialInitAdapter as P, ActionLogSink as S, PublicationResult as T, piBuiltinToolNames as _, runInspectCommand as a, piThinkingLevels as b, ActionCommandOptions as c, DryRunCommandResult as d, InitCommandOptions as f, RuntimeCommandOptions as g, LocalReviewCommandResult as h, runInitCommand as i, ProviderConfig as j, PiprConfig as k, ActionCommandResult as l, LocalReviewCommandOptions as m, runActionCommandWithDependencies as n, runLocalReviewCommand as o, InspectCommandResult as p, runDryRunCommand as r, runValidateCommand as s, runActionCommand as t, DryRunCommandOptions as u, piReadOnlyToolNames as v, PublicationError as w, ActionLogRecord as x, piRequiredCliFlags as y };
-//# sourceMappingURL=commands-C6wfO-y7.d.mts.map
+//# sourceMappingURL=commands-Bcta0T4L.d.mts.map

package/dist/commands-Bcta0T4L.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands-Bcta0T4L.d.mts","names":[],"sources":["../src/config/init.ts","../src/types.ts","../src/config/project.ts","../src/review/prior-state.ts","../src/review/comment.ts","../src/review/publication-result.ts","../src/hosts/types.ts","../src/hosts/github/command.ts","../src/hosts/github/publication-client.ts","../src/shared/logging.ts","../src/pi/contract.ts","../src/review/task/task-output.ts","../src/review/task/task-runtime.ts","../src/action/types.ts","../src/action/commands.ts"],"mappings":"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"}

package/dist/{commands-Btw_Ummi.mjs → commands-DM63Wmy0.mjs}

@@ -526,7 +526,7 @@ function compareStableSemver(left, right) {
 }
 //#endregion
 //#region src/shared/version.ts
-const runtimeVersion = "0.3.6";
+const runtimeVersion = "0.3.7";
 //#endregion
 //#region src/config/version-compat.ts
 async function resolveConfigVersionCompatibility(options) {
@@ -3544,8 +3544,8 @@ function isOfficialInitRecipeId(recipe) {
 //#endregion
 //#region src/config/init.ts
 const supportedOfficialInitAdapters = ["github"];
-const defaultWorkflowActionRef = "somus/pipr@v0.3.6";
-const defaultSdkVersion = "0.3.6";
+const defaultWorkflowActionRef = "somus/pipr@v0.3.7";
+const defaultSdkVersion = "0.3.7";
 function resolveOfficialInitAdapters(adapters) {
 	if (adapters === void 0) return [...supportedOfficialInitAdapters];
 	if (adapters.length === 0) return [];
@@ -4746,6 +4746,24 @@ const ignoredWorkspacePaths = /* @__PURE__ */ new Set([
 	".fallow",
 	"coverage"
 ]);
+const eventRecordSchema = z.record(z.string(), z.unknown());
+const tokenCountSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+const assistantMessageEventSchema = z.looseObject({
+	type: z.literal("message_end"),
+	message: z.looseObject({
+		role: z.literal("assistant"),
+		model: z.string().min(1).optional(),
+		responseModel: z.string().min(1).optional()
+	})
+});
+const assistantUsageMessageSchema = z.looseObject({
+	role: z.literal("assistant"),
+	usage: z.looseObject({
+		input: tokenCountSchema,
+		output: tokenCountSchema,
+		cost: z.looseObject({ total: z.number().nonnegative() })
+	})
+});
 async function runPi(options) {
 	const started = Date.now();
 	const sandbox = await createPiRunSandbox(options.workspace);
@@ -4768,10 +4786,13 @@ async function runPi(options) {
 			started,
 			timeoutSeconds: options.timeoutSeconds
 		});
-		return result.exitCode === 0 ? {
+		const events = parsePiJsonEvents(result.stdout);
+		return {
 			...result,
-			stdout: extractAssistantTextFromJsonEvents(result.stdout) ?? result.stdout
-		} : result;
+			...events?.models.length ? { models: events.models } : {},
+			...events?.usage ? { usage: events.usage } : {},
+			stdout: result.exitCode === 0 ? events?.assistantText ?? result.stdout : result.stdout
+		};
 	} finally {
 		await preparedTools?.custom?.close();
 		await chmodRecursive(sandbox.root, 493);
@@ -4893,19 +4914,69 @@ async function chmodRecursive(target, mode) {
 	const entries = await readdir(target, { withFileTypes: true });
 	for (const entry of entries) await chmodRecursive(path.join(target, entry.name), mode);
 }
-function extractAssistantTextFromJsonEvents(stdout) {
+function parsePiJsonEvents(stdout) {
 	const events = [];
 	for (const line of stdout.split(/\r?\n/).map((item) => item.trim()).filter(Boolean)) try {
 		const value = JSON.parse(line);
-		if (!isPlainObject(value)) return;
-		events.push(value);
+		const parsed = eventRecordSchema.safeParse(value);
+		if (!parsed.success) return;
+		events.push(parsed.data);
 	} catch {
 		return;
 	}
 	if (!events.some((event) => typeof event.type === "string")) return;
-	let text;
-	for (const event of events) text = assistantTextFromEvent(event) ?? text;
-	return text;
+	let assistantText;
+	for (const event of events) assistantText = assistantTextFromEvent(event) ?? assistantText;
+	const assistantMessages = assistantMessagesFromEvents(events);
+	const models = assistantModels(assistantMessages);
+	const usage = assistantUsage(assistantMessages);
+	return {
+		...assistantText !== void 0 ? { assistantText } : {},
+		models,
+		...usage ? { usage } : {}
+	};
+}
+function assistantMessagesFromEvents(events) {
+	return events.flatMap((event) => {
+		const parsed = assistantMessageEventSchema.safeParse(event);
+		return parsed.success ? [parsed.data.message] : [];
+	});
+}
+function assistantModels(messages) {
+	const models = [];
+	for (const message of messages) {
+		const model = message.responseModel ?? message.model;
+		if (model && !models.includes(model)) models.push(model);
+	}
+	return models;
+}
+function assistantUsage(messages) {
+	const usageMessages = messages.flatMap((message) => {
+		const parsed = assistantUsageMessageSchema.safeParse(message);
+		return parsed.success ? [parsed.data] : [];
+	});
+	if (usageMessages.length === 0) return;
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let costUsd = 0;
+	let partial = usageMessages.length !== messages.length;
+	for (const message of usageMessages) {
+		const nextInputTokens = inputTokens + message.usage.input;
+		if (Number.isSafeInteger(nextInputTokens)) inputTokens = nextInputTokens;
+		else partial = true;
+		const nextOutputTokens = outputTokens + message.usage.output;
+		if (Number.isSafeInteger(nextOutputTokens)) outputTokens = nextOutputTokens;
+		else partial = true;
+		const nextCostUsd = costUsd + message.usage.cost.total;
+		if (Number.isFinite(nextCostUsd)) costUsd = nextCostUsd;
+		else partial = true;
+	}
+	return {
+		status: partial ? "partial" : "complete",
+		inputTokens,
+		outputTokens,
+		costUsd
+	};
 }
 function assistantTextFromEvent(event) {
 	if (event.type === "message_end" || event.type === "turn_end") return assistantMessageText(event.message);
@@ -5521,16 +5592,27 @@ async function runPiForPrompt(options, provider, prompt) {
 	const customTools = customToolsForRun(options);
 	const timeoutSeconds = promptTimeoutSeconds(options);
 	logPiStart(options, provider, prompt, builtinTools, runtimeTools, customTools);
-	const result = await (options.runtime.piRunner ?? runPi)({
-		workspace: options.runtime.workspace,
-		provider,
-		prompt,
-		env: options.runtime.env,
-		piExecutable: options.runtime.piExecutable,
-		builtinTools,
-		runtimeTools,
-		customTools,
-		timeoutSeconds
+	let result;
+	try {
+		result = await (options.runtime.piRunner ?? runPi)({
+			workspace: options.runtime.workspace,
+			provider,
+			prompt,
+			env: options.runtime.env,
+			piExecutable: options.runtime.piExecutable,
+			builtinTools,
+			runtimeTools,
+			customTools,
+			timeoutSeconds
+		});
+	} catch (error) {
+		options.runtime.piRunSink?.({ models: [provider.model] });
+		throw error;
+	}
+	const reportedModels = result.models?.map((model) => model.trim()).filter(Boolean);
+	options.runtime.piRunSink?.({
+		models: reportedModels?.length ? reportedModels : [provider.model],
+		...result.usage ? { usage: result.usage } : {}
 	});
 	logPiResult(options, provider, result, timeoutSeconds);
 	assertSuccessfulPiResult(result, options.runtime.log);
@@ -5674,6 +5756,8 @@ const mainCommentTitles = /* @__PURE__ */ new Set([
 	"# Pipr Review",
 	mainCommentTitle
 ]);
+const reviewStatsStartMarker = "<!-- pipr:stats:start -->";
+const reviewStatsEndMarker = "<!-- pipr:stats:end -->";
 const escapedRepositoryUrl = piprRepositoryUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const mainCommentAttributionPattern = new RegExp(`^<sub>Review generated by \\[Pipr\\]\\(${escapedRepositoryUrl}\\) for commit \`[^\`]+\`\\.(?: Config SDK \\d+\\.\\d+\\.\\d+ is behind (?:Pipr \\d+\\.\\d+\\.\\d+|\\[Pipr \\d+\\.\\d+\\.\\d+\\]\\(${escapedRepositoryUrl}/releases/tag/v\\d+\\.\\d+\\.\\d+\\))\\.)?</sub>$`);
 //#endregion
@@ -5933,6 +6017,29 @@ function parseAttrs(input) {
 function hashParts(parts) {
 	return new Bun.CryptoHasher("sha256").update(parts.join("\n")).digest("hex").slice(0, 16);
 }
+const maxReviewStatsModelLength = 200;
+const credentialLikeModelPattern = /(?:(?:AKIA|ASIA)[0-9A-Z]{16}|AIza[0-9A-Za-z_-]{35}|(?:sk|rk)_live_[A-Za-z0-9]{16,}|sk-(?:proj-)?[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{16,}|glpat-[A-Za-z0-9_-]{16,}|npm_[A-Za-z0-9]{16,}|xox[baprs]-[A-Za-z0-9-]{16,})/i;
+const highEntropyModelSegmentPattern = /[A-Za-z0-9]{24,}/;
+const reviewStatsModelSchema = z.string().min(1).max(maxReviewStatsModelLength).transform((model) => sanitizeReviewStatsModel(model) ?? "[invalid model]");
+const reviewStatsSchema = z.strictObject({
+	models: z.array(reviewStatsModelSchema).min(1).max(20),
+	agentRuns: z.number().int().positive(),
+	durationMs: z.number().int().nonnegative(),
+	inputTokens: z.number().int().nonnegative(),
+	outputTokens: z.number().int().nonnegative(),
+	costUsd: z.number().nonnegative(),
+	usageStatus: z.enum([
+		"complete",
+		"partial",
+		"unavailable"
+	])
+});
+function sanitizeReviewStatsModel(model) {
+	const normalized = model.replace(/\s+/g, " ").trim();
+	if (credentialLikeModelPattern.test(normalized) || highEntropyModelSegmentPattern.test(normalized)) return "[redacted credential]";
+	const sanitized = redactPotentialSecrets(normalized);
+	return sanitized ? sanitized.slice(0, maxReviewStatsModelLength) : void 0;
+}
 //#endregion
 //#region src/review/comment.ts
 const inlinePublicationItemSchema = z.strictObject({
@@ -5990,7 +6097,8 @@ const publicationMetadataSchema = z.strictObject({
 	failedTasks: z.array(z.string().min(1)),
 	validFindings: z.number().int().min(0),
 	droppedFindings: z.number().int().min(0),
-	cappedInlineFindings: z.number().int().min(0)
+	cappedInlineFindings: z.number().int().min(0),
+	stats: reviewStatsSchema.optional()
 });
 const publicationPlanSchema = z.strictObject({
 	mainComment: z.string().min(1),
@@ -6106,10 +6214,54 @@ function renderMainComment(options) {
 		...options.metadata.validFindings > 0 ? [`**Findings:** ${options.metadata.validFindings}`, ""] : [],
 		redactPotentialSecrets(options.main),
 		"",
+		...options.metadata.stats ? [renderReviewStats(options.metadata.stats), ""] : [],
 		renderMainCommentAttribution(options.metadata),
 		""
 	].join("\n");
 }
+function renderReviewStats(stats) {
+	const usageSuffix = stats.usageStatus === "partial" ? " (reported)" : "";
+	const usageUnavailable = stats.usageStatus === "unavailable";
+	return [
+		reviewStatsStartMarker,
+		"<details>",
+		"<summary>Review stats</summary>",
+		"",
+		"| Metric | Total |",
+		"| --- | ---: |",
+		`| Models | ${stats.models.map(formatModel).join(", ")} |`,
+		`| Agent runs | ${stats.agentRuns} |`,
+		`| Elapsed | ${formatDuration(stats.durationMs)} |`,
+		`| Input tokens | ${usageUnavailable ? "Unavailable" : `${formatInteger(stats.inputTokens)}${usageSuffix}`} |`,
+		`| Output tokens | ${usageUnavailable ? "Unavailable" : `${formatInteger(stats.outputTokens)}${usageSuffix}`} |`,
+		`| Cost (USD) | ${usageUnavailable ? "Unavailable" : `${formatCost(stats.costUsd)}${usageSuffix}`} |`,
+		"",
+		"</details>",
+		reviewStatsEndMarker
+	].join("\n");
+}
+function formatModel(model) {
+	return `<code>${model.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\|/g, "&#124;")}</code>`;
+}
+function formatInteger(value) {
+	return value.toLocaleString("en-US");
+}
+function formatDuration(durationMs) {
+	if (durationMs < 1e3) return `${durationMs}ms`;
+	const totalSeconds = durationMs / 1e3;
+	if (totalSeconds < 60) return `${formatTenths(totalSeconds)}s`;
+	const minutes = Math.floor(totalSeconds / 60);
+	return `${minutes}m ${formatTenths(totalSeconds - minutes * 60)}s`;
+}
+function formatTenths(value) {
+	return value.toFixed(1).replace(/\.0$/, "");
+}
+function formatCost(costUsd) {
+	if (costUsd === 0) return "$0.00";
+	if (costUsd < 1e-4) return `$${costUsd.toFixed(6)}`;
+	if (costUsd < .01) return `$${costUsd.toFixed(4)}`;
+	return `$${costUsd.toFixed(2)}`;
+}
 function renderMainCommentAttribution(metadata) {
 	const configNotice = configVersionNotice(metadata);
 	return `<sub>Review generated by [Pipr](${piprRepositoryUrl}) for commit \`${metadata.reviewedHeadSha.slice(0, 7)}\`.${configNotice}</sub>`;
@@ -6266,7 +6418,8 @@ async function runInternalVerifier(options) {
 				piExecutable: options.piExecutable,
 				piRunner: options.piRunner,
 				runId: options.runId,
-				log: options.log
+				log: options.log,
+				...options.piRunSink ? { piRunSink: options.piRunSink } : {}
 			}
 		});
 		return applyVerifierOutput(options, candidates, verifierOutputSchema.parse(result.value), result.providerModels);
@@ -6438,6 +6591,20 @@ function boundedVerifierText(value) {
 //#endregion
 //#region src/review/task/task-output.ts
 const agentInlineFindingsOutputSchema = z.custom((value) => z.looseObject({ inlineFindings: z.array(reviewFindingSchema) }).safeParse(value).success);
+const generatedReviewStatsShape = [
+	/^$/,
+	/^\| Metric \| Total \|$/,
+	/^\| --- \| ---: \|$/,
+	/^\| Models \| .+ \|$/,
+	/^\| Agent runs \| \d+ \|$/,
+	/^\| Elapsed \| .+ \|$/,
+	/^\| Input tokens \| (?:Unavailable|[\d,]+(?: \(reported\))?) \|$/,
+	/^\| Output tokens \| (?:Unavailable|[\d,]+(?: \(reported\))?) \|$/,
+	/^\| Cost \(USD\) \| (?:Unavailable|\$\d+(?:\.\d+)?(?:e[+-]?\d+)?(?: \(reported\))?) \|$/,
+	/^$/,
+	/^<\/details>$/,
+	/^<!-- pipr:stats:end -->$/
+];
 function createOutputState() {
 	return {
 		findings: [],
@@ -6457,6 +6624,66 @@ function mergeTaskOutputs(results) {
 	}
 	return merged;
 }
+function reviewStatsForRuns(runs, durationMs) {
+	if (runs.length === 0) return;
+	const usage = aggregateReviewUsage(runs);
+	return {
+		models: collectReviewModels(runs),
+		agentRuns: runs.length,
+		durationMs,
+		inputTokens: usage.inputTokens,
+		outputTokens: usage.outputTokens,
+		costUsd: usage.costUsd,
+		usageStatus: usage.status
+	};
+}
+function collectReviewModels(runs) {
+	const models = [];
+	for (const model of runs.flatMap((run) => run.models)) {
+		const sanitized = sanitizeReviewStatsModel(model);
+		if (sanitized && models.length < 20 && !models.includes(sanitized)) models.push(sanitized);
+	}
+	return models.length > 0 ? models : ["[invalid model]"];
+}
+function aggregateReviewUsage(runs) {
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let costUsd = 0;
+	let reportedRuns = 0;
+	let partialUsage = false;
+	for (const run of runs) {
+		if (!run.usage) continue;
+		reportedRuns += 1;
+		const input = addReportedUsage(inputTokens, run.usage.inputTokens, Number.isSafeInteger);
+		const output = addReportedUsage(outputTokens, run.usage.outputTokens, Number.isSafeInteger);
+		const cost = addReportedUsage(costUsd, run.usage.costUsd, Number.isFinite);
+		inputTokens = input.total;
+		outputTokens = output.total;
+		costUsd = cost.total;
+		const sumsComplete = [
+			input,
+			output,
+			cost
+		].every((sum) => sum.complete);
+		partialUsage ||= run.usage.status === "partial" || !sumsComplete;
+	}
+	return {
+		inputTokens,
+		outputTokens,
+		costUsd,
+		status: reportedRuns === 0 ? "unavailable" : reportedRuns < runs.length || partialUsage ? "partial" : "complete"
+	};
+}
+function addReportedUsage(current, reported, isValid) {
+	const next = current + reported;
+	return isValid(next) ? {
+		total: next,
+		complete: true
+	} : {
+		total: current,
+		complete: false
+	};
+}
 function mergeCommentContribution(merged, comment) {
 	if (!comment) return;
 	assertOutputContributionAllowed(merged, "comment", comment.taskName, (existing, next) => `ctx.comment(...) may be called once per selected run; received comments from '${existing}' and '${next}'`);
@@ -6534,12 +6761,37 @@ function priorReviewForTask(priorMainComment, priorReviewState) {
 	};
 }
 function visibleMainComment(body) {
-	const lines = body.split("\n").filter((line) => !line.startsWith("<!-- pipr:main-comment ") && !mainCommentAttributionPattern.test(line));
+	const sourceLines = body.split("\n");
+	const statsRange = generatedReviewStatsRange(sourceLines);
+	const lines = sourceLines.filter((line, index) => {
+		return !(statsRange && index >= statsRange.start && index <= statsRange.end) && !line.startsWith("<!-- pipr:main-comment ") && !mainCommentAttributionPattern.test(line);
+	});
 	while (lines[0] === "") lines.shift();
 	if (lines[0] && mainCommentTitles.has(lines[0])) lines.shift();
 	while (lines[0] === "") lines.shift();
 	return lines.join("\n").trim();
 }
+function generatedReviewStatsRange(lines) {
+	const attributionIndex = lines.findLastIndex((line) => mainCommentAttributionPattern.test(line));
+	if (attributionIndex < 0) return;
+	const end = lines.slice(0, attributionIndex).findLastIndex((line) => line !== "");
+	if (end < 0) return;
+	if (lines[end] !== "<!-- pipr:stats:end -->") return;
+	if (lines[end - 1] !== "</details>") return;
+	const start = lines.lastIndexOf(reviewStatsStartMarker, end - 2);
+	if (start < 0) return;
+	if (lines[start + 1] !== "<details>") return;
+	if (lines[start + 2] !== "<summary>Review stats</summary>") return;
+	if (!matchesGeneratedReviewStatsShape(lines, start, end)) return;
+	return {
+		start,
+		end
+	};
+}
+function matchesGeneratedReviewStatsShape(lines, start, end) {
+	const generatedShape = lines.slice(start + 3, end + 1);
+	return generatedShape.length === generatedReviewStatsShape.length && generatedReviewStatsShape.every((pattern, index) => pattern.test(generatedShape[index] ?? ""));
+}
 function collectInlineFindings(state, findings) {
 	if (!findings) return;
 	const arrayScope = state.findingScopes.get(findings);
@@ -6563,6 +6815,7 @@ function collectedReview(output, summaryBody) {
 //#region src/review/task/task-runtime.ts
 const genericTaskFailureSummary = "Task failed; see logs for details.";
 async function runTaskRuntime(options) {
+	const runtimeStarted = Date.now();
 	const config = parsePiprConfig(options.config);
 	const provider = options.providerOverride ? parseProviderConfig(options.providerOverride) : resolveProvider(config, config.defaultProvider);
 	const diffManifest = parseDiffManifest((options.diffManifestBuilder ?? buildDiffManifest)({
@@ -6615,11 +6868,15 @@ async function runTaskRuntime(options) {
 	const loadedPriorReviewState = options.priorReviewState ?? await options.loadPriorReviewState?.();
 	const priorMainComment = options.priorMainComment ?? await options.loadPriorMainComment?.();
 	const priorReviewState = priorReviewStateForSelectedTasks(loadedPriorReviewState, selectedTasks);
+	const piRuns = [];
 	const runtimeOptions = {
 		...options,
 		priorReviewState,
 		priorMainComment,
-		runId
+		runId,
+		piRunSink(run) {
+			piRuns.push(run);
+		}
 	};
 	const manifestCache = /* @__PURE__ */ new Map();
 	const taskResults = await Promise.all(tasks.map(async (task, taskOrder) => {
@@ -6703,8 +6960,10 @@ async function runTaskRuntime(options) {
 		provider,
 		diffManifest,
 		priorReviewState,
-		runId
+		runId,
+		piRunSink: runtimeOptions.piRunSink
 	});
+	const stats = reviewStatsForRuns(piRuns, Date.now() - runtimeStarted);
 	const publishing = buildCommentPublishingPlan({
 		event: options.event,
 		main,
@@ -6723,7 +6982,8 @@ async function runTaskRuntime(options) {
 			selectedTasks,
 			failedTasks: [],
 			validFindings: validated.validFindings.length,
-			droppedFindings: validated.droppedFindings.length
+			droppedFindings: validated.droppedFindings.length,
+			...stats ? { stats } : {}
 		}
 	});
 	const publicationPlan = publishing.publicationPlan;
@@ -6782,7 +7042,8 @@ async function runSynchronizeVerifier(options) {
 		priorReviewState: options.priorReviewState,
 		threadContexts: await options.options.loadInlineThreadContexts?.() ?? [],
 		mode: { kind: "synchronize" },
-		runId: options.runId
+		runId: options.runId,
+		piRunSink: options.piRunSink
 	});
 }
 function createTaskContext(options) {
@@ -6843,7 +7104,8 @@ function createTaskContext(options) {
 				runtime: {
 					...options,
 					taskContext,
-					runId: options.runId
+					runId: options.runId,
+					piRunSink: options.piRunSink
 				}
 			});
 			options.output.providerModels.push(...result.providerModels);
@@ -9167,4 +9429,4 @@ async function runActionCommandWithDependencies(options) {
 //#endregion
 export { runInspectCommand as a, PublicationError as c, supportedOfficialInitRecipes as d, piBuiltinToolNames as f, piThinkingLevels as h, runInitCommand as i, supportedOfficialInitAdapters as l, piRequiredCliFlags as m, runActionCommandWithDependencies as n, runLocalReviewCommand as o, piReadOnlyToolNames as p, runDryRunCommand as r, runValidateCommand as s, runActionCommand as t, listOfficialInitRecipes as u };
 
-//# sourceMappingURL=commands-Btw_Ummi.mjs.map
+//# sourceMappingURL=commands-DM63Wmy0.mjs.map