@stupify/cli 0.0.14 → 0.0.16

package/src/render.ts

@@ -1,20 +1,52 @@
 import { VERSION } from "./constants.ts";
 import type { SearchCommand, SearchRunJson } from "./types.ts";
-import { format } from "./ui.ts";
+import { format, type CliUi } from "./ui.ts";
 
 export function renderSearchRun(run: SearchRunJson, command: SearchCommand): string {
   if (command.json) return JSON.stringify(run, null, 2);
+  return renderSearchHumanText(run, command);
+}
+
+export function renderSearchRunToUi(run: SearchRunJson, command: SearchCommand, ui: CliUi): void {
+  if (command.json) {
+    ui.writeStdout(renderSearchRun(run, command));
+    return;
+  }
 
   if (run.stats.skipped && run.stats.skipReason === "input_too_large") {
-    return `${format.heading("Search input is too large for precise local search.")}
-${format.heading("Size:")}
-~${run.stats.inputTokens ?? "unknown"} tokens
-${format.heading("Limit:")}
-${run.stats.inputTokenCap ?? "unknown"} tokens
-Stupify skipped the search rather than review truncated context.
-Nothing was blocked.
-${format.heading("Try:")}
-rerun with ${sourceHint(command)} --max-search-input-tokens ${Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2)}`;
+    ui.warn("Search skipped: input is too large for precise local search.");
+    ui.note(oversizedText(run, command), "Skipped");
+    ui.outro("Warn-only. Nothing blocked.");
+    return;
+  }
+
+  if (run.stats.skipped && run.stats.skipReason === "no_candidates") {
+    ui.success("Search complete: no search targets found.");
+    ui.note(cleanSummaryText(run), "Summary");
+    ui.outro("No judgment-offload signals found.");
+    return;
+  }
+
+  if (run.matches.length === 0) {
+    ui.success("Search complete: no judgment-offload signals found.");
+    ui.note(cleanSummaryText(run), "Summary");
+    ui.outro("Warn-only. Nothing blocked.");
+    return;
+  }
+
+  ui.warn(format.warn(format.heading("AI SLOP DETECTED")));
+  ui.note(matchSummaryText(run, command), "Summary");
+  for (const group of groupMatchesByFile(run.matches)) {
+    ui.note(renderMatchGroup(group, run), group.filePath);
+  }
+  ui.outro(summaryLine(run));
+}
+
+export function renderSearchHumanText(run: SearchRunJson, command: SearchCommand): string {
+  if (run.stats.skipped && run.stats.skipReason === "input_too_large") {
+    return `${format.heading("Search skipped")}
+${oversizedText(run, command)}
+Warn-only. Nothing blocked.`;
   }
 
   if (run.stats.skipped && run.stats.skipReason === "no_candidates") {
@@ -29,18 +61,12 @@ ${format.label("Patterns:")} ${run.patterns.join(", ")}
 ${format.success("No judgment-offload signals found.")}`;
   }
 
+  const groups = groupMatchesByFile(run.matches);
   return `${slopHeading()}
-${committerLabel(run)} (${sourceLabel(command)})
-
-${run.matches.map((match, index) => `${index + 1}. ${format.label(match.patternId)}
-${match.reason}
-
-\`\`\`
-${match.snapshot ?? match.proof}
-\`\`\`
-${format.muted(match.proof)}
+${matchSummaryText(run, command)}
 
-${match.checkWhy ?? "This pattern may indicate judgment-offload."}`).join("\n\n")}
+${groups.map((group) => `${format.heading(group.filePath)}
+${renderMatchGroup(group, run)}`).join("\n\n")}
 ${format.muted(summaryLine(run))}`;
 }
 
@@ -92,6 +118,151 @@ Not included:
 `;
 }
 
+type MatchGroup = Readonly<{
+  filePath: string;
+  matches: SearchRunJson["matches"];
+}>;
+
+function oversizedText(run: SearchRunJson, command: SearchCommand): string {
+  const targetLimit = Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2);
+  return [
+    `Size: ~${run.stats.inputTokens ?? "unknown"} tokens`,
+    `Limit: ${run.stats.inputTokenCap ?? "unknown"} tokens`,
+    "Stupify skipped the search rather than review truncated context.",
+    `Try: ${sourceHint(command)} --max-search-input-tokens ${targetLimit}`,
+  ].join("\n");
+}
+
+function cleanSummaryText(run: SearchRunJson): string {
+  return [
+    `Patterns: ${run.patterns.join(", ")}`,
+    run.stats.filesChanged === undefined ? null : `Diff: ${run.stats.filesChanged} files, ${run.stats.entitiesScanned ?? 0} changed entities`,
+  ].filter(Boolean).join("\n");
+}
+
+function matchSummaryText(run: SearchRunJson, command: SearchCommand): string {
+  const fileCount = groupMatchesByFile(run.matches).length;
+  const fileNoun = fileCount === 1 ? "file" : "files";
+  return [
+    `${run.matches.length} ${signalNoun(run.matches.length)} across ${fileCount} ${fileNoun}`,
+    `${committerLabel(run)} · ${sourceLabel(command)}`,
+    "Warn-only. Nothing blocked.",
+    "",
+    patternSummaryLine(run),
+  ].filter((line) => line !== null).join("\n");
+}
+
+function patternSummaryLine(run: SearchRunJson): string {
+  const counts = new Map<string, number>();
+  for (const match of run.matches) counts.set(patternLabel(match), (counts.get(patternLabel(match)) ?? 0) + 1);
+  return [...counts.entries()].map(([patternName, count]) => `${patternName} ${count}`).join(" · ");
+}
+
+function groupMatchesByFile(matches: SearchRunJson["matches"]): readonly MatchGroup[] {
+  const groups = new Map<string, SearchRunJson["matches"][number][]>();
+  for (const match of matches) {
+    const filePath = proofFilePath(match.proof);
+    const group = groups.get(filePath) ?? [];
+    group.push(match);
+    groups.set(filePath, group);
+  }
+  return [...groups.entries()].map(([filePath, groupedMatches]) => ({
+    filePath,
+    matches: groupedMatches,
+  }));
+}
+
+function renderMatchGroup(group: MatchGroup, run: SearchRunJson): string {
+  return group.matches.map((match, index) => {
+    const lines = [
+      matchHeadline(match, run, index),
+      match.reason,
+      match.snapshot ? `\n\`\`\`\n${match.snapshot}\n\`\`\`` : null,
+      format.muted(`${proofDetail(match.proof)}${commitSubjectSuffix(run)}`),
+      match.checkWhy ?? "This pattern may indicate judgment-offload.",
+    ];
+    return lines.filter(Boolean).join("\n");
+  }).join("\n\n");
+}
+
+function matchHeadline(match: SearchRunJson["matches"][number], run: SearchRunJson, index: number): string {
+  return `${index + 1}. ${format.label(patternLabel(match))}: ${headlineArgs(match)} -- ${matchBlameLabel(match, run)}`;
+}
+
+function patternLabel(match: SearchRunJson["matches"][number]): string {
+  return titleCase(match.patternName ?? match.patternId.replace(/_/g, " "));
+}
+
+function headlineArgs(match: SearchRunJson["matches"][number]): string {
+  const destination = entityNameFromProof(match.proof);
+  const source = firstBacktickedToken(match.reason) ?? firstLikelySource(match.reason, destination);
+  if (source && destination && source !== destination) return `${codeLabel(source)} -> ${codeLabel(destination)}`;
+  if (destination) return codeLabel(destination);
+  return codeLabel(match.targetId);
+}
+
+function matchBlameLabel(match: SearchRunJson["matches"][number], run: SearchRunJson): string {
+  return match.blame ? blameSummaryLabel(match.blame) : runLevelBlameLabel(run);
+}
+
+function blameSummaryLabel(blame: NonNullable<SearchRunJson["matches"][number]["blame"]>): string {
+  return `${blame.author} (${blame.subject})`;
+}
+
+function runLevelBlameLabel(run: SearchRunJson): string {
+  const author = committerLabel(run);
+  const subject = firstHumanSubject(run.stats.commitSubjects ?? []);
+  return subject ? `${author} (${subject})` : author;
+}
+
+function commitSubjectSuffix(run: SearchRunJson): string {
+  const subject = firstHumanSubject(run.stats.commitSubjects ?? []);
+  return subject ? ` · commit: ${subject}` : "";
+}
+
+function firstHumanSubject(subjects: readonly string[]): string | undefined {
+  return subjects.map((subject) => subject.trim()).find(Boolean);
+}
+
+function codeLabel(value: string): string {
+  return `\`${value}\``;
+}
+
+function titleCase(value: string): string {
+  return value.replace(/\b[a-z]/g, (letter) => letter.toUpperCase());
+}
+
+function entityNameFromProof(proof: string): string | undefined {
+  const parts = proof.split("::");
+  return parts[2] || parts[1] || undefined;
+}
+
+function firstBacktickedToken(value: string): string | undefined {
+  const match = /`([^`]+)`/.exec(value);
+  return cleanToken(match?.[1]);
+}
+
+function firstLikelySource(value: string, destination?: string): string | undefined {
+  const tokens = [...value.matchAll(/\b[A-Z][A-Za-z0-9_]*(?:\[[^\]]+\])?\b/g)]
+    .map((match) => cleanToken(match[0]))
+    .filter((token): token is string => Boolean(token));
+  return tokens.find((token) => token !== destination && token !== "The");
+}
+
+function cleanToken(value: string | undefined): string | undefined {
+  const token = value?.trim().replace(/[.,;:]+$/, "");
+  return token || undefined;
+}
+
+function proofFilePath(proof: string): string {
+  return proof.split("::")[0] || proof;
+}
+
+function proofDetail(proof: string): string {
+  const [, ...rest] = proof.split("::");
+  return rest.length > 0 ? `::${rest.join("::")}` : proof;
+}
+
 function sourceHint(command: SearchCommand): string {
   if (command.kind === "staged") return "--staged";
   if (command.kind === "since") return `--since "${command.since}"`;
@@ -149,6 +320,9 @@ function sinceLabel(since: string): string {
 }
 
 function summaryLine(run: SearchRunJson): string {
-  const noun = run.matches.length === 1 ? "signal" : "signals";
-  return `${run.matches.length} ${noun}. Warn-only. Nothing blocked.`;
+  return `${run.matches.length} ${signalNoun(run.matches.length)}. Warn-only. Nothing blocked.`;
+}
+
+function signalNoun(count: number): string {
+  return count === 1 ? "signal" : "signals";
 }

package/src/sem-provider.ts

@@ -65,6 +65,7 @@ function emptyChangeSet(
     base: label,
     target: label,
     committers,
+    commitSubjects: undefined,
     contextCwd: process.cwd(),
     cleanup: async () => undefined,
     changes: [],
@@ -109,9 +110,10 @@ async function semChangeSetFromPatch(
       id: sourceId(label),
       label,
       base: label,
-      target: label,
-      committers,
-      stats: { filesChanged: 0, additions: 0, deletions: 0 },
+    target: label,
+    committers,
+    commitSubjects: undefined,
+    stats: { filesChanged: 0, additions: 0, deletions: 0 },
     }),
     contextCwd: process.cwd(),
     cleanup: async () => undefined,
@@ -240,6 +242,7 @@ function normalizeSemDiff(value: unknown, range: SourceRange): SemChangeSet {
     base: range.base,
     target: range.target,
     committers: range.committers,
+    commitSubjects: range.commitSubjects,
     contextCwd: process.cwd(),
     cleanup: async () => undefined,
     changes,

package/src/stupify.ts

@@ -6,11 +6,12 @@ import { countPromptTokens, runSearch, searchRequest, type SearchRequest } from
 import { searchChecks } from "./checks.ts";
 import { parseCommand } from "./command.ts";
 import { counterScoutPlan } from "./counter-scout.ts";
-import { runDoctor } from "./doctor.ts";
-import { runHookCommand } from "./hooks.ts";
+import { renderDoctorToUi, runDoctor } from "./doctor.ts";
+import { blameEntity } from "./git.ts";
+import { renderHookResultToUi, runHookCommand } from "./hooks.ts";
 import { firstRunModelBootstrap, loadLocalModel } from "./model.ts";
 import { entityContextsFromChanges, emptyContextPack, repomixContextPack, repomixSearchConfig } from "./repomix-provider.ts";
-import { helpText, renderSearchRun } from "./render.ts";
+import { helpText, renderSearchRun, renderSearchRunToUi } from "./render.ts";
 import {
   effectiveMaxCandidates,
   effectiveMaxSearchInputTokens,
@@ -30,27 +31,36 @@ export async function main(argv = process.argv.slice(2)): Promise<number> {
   try {
     const command = parseCommand(argv);
     if (command.kind === "help") {
-      ui.writeStdout(helpText());
+      ui.intro("stupify");
+      ui.note(helpText().trim(), "Help");
+      ui.outro("Local-only. Warn-only.");
       return 0;
     }
     if (command.kind === "hook") {
-      ui.writeStdout(await runHookCommand(command.action));
+      ui.intro("stupify");
+      renderHookResultToUi(await runHookCommand(command.action), ui);
+      ui.outro("Hook mode is warn-only. Commits are not blocked.");
       return 0;
     }
     if (command.kind === "doctor") {
       const result = await runDoctor();
-      ui.writeStdout(result.text);
+      ui.intro("stupify");
+      renderDoctorToUi(result, ui);
+      ui.outro(result.exitCode === 0 ? "Ready." : "Fix missing required dependencies, then rerun doctor.");
       return result.exitCode;
     }
     if (command.kind === "bench-search") {
       const { runSearchBench } = await import("./search-bench.ts");
-      ui.writeStdout(await runSearchBench(command.configPath));
+      ui.intro("stupify");
+      ui.note(await runSearchBench(command.configPath), "Search bench");
+      ui.outro("Bench complete.");
       return 0;
     }
 
     ui = createCliUi({ quiet: command.json });
     const run = await runSearchCommand(command, startedAt, ui);
-    ui.writeStdout(renderSearchRun(run, command));
+    if (command.json) ui.writeStdout(renderSearchRun(run, command));
+    else renderSearchRunToUi(run, command, ui);
     return 0;
   } catch (error) {
     ui.error(error instanceof Error ? error.message : String(error), { force: true });
@@ -59,11 +69,28 @@ export async function main(argv = process.argv.slice(2)): Promise<number> {
 }
 
 export async function runSearchCommand(command: SearchCommand, startedAt: number, ui = createCliUi({ quiet: command.json })): Promise<SearchRunJson> {
+  const activeSpans = new Map<string, ReturnType<CliUi["spinner"]>>();
   const t = createTracer({
     writeLine: () => undefined,
     onEvent: (event) => {
       if (command.json) return;
-      ui.step(formatStep(event.name, event.ms, event.count, event.detail));
+      if (event.phase === "start") {
+        activeSpans.set(event.name, ui.spinner(formatStartStep(event.name, event.detail)));
+        return;
+      }
+
+      const active = activeSpans.get(event.name);
+      activeSpans.delete(event.name);
+      const message = event.phase === "error"
+        ? formatErrorStep(event.name, event.ms)
+        : formatStep(event.name, event.ms, event.count, event.detail);
+      if (!active) {
+        if (event.phase === "error") ui.error(message);
+        else ui.step(message);
+        return;
+      }
+      if (event.phase === "error") active.error(message);
+      else active.stop(message);
     },
   });
 
@@ -100,6 +127,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
           elapsedMs: Date.now() - startedAt,
           modelCalls: 0,
           committers: changeSet.committers,
+          commitSubjects: changeSet.commitSubjects,
           skipped: true,
           skipReason: "no_candidates",
           filesChanged: changeSet.summary.fileCount,
@@ -143,6 +171,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
           elapsedMs: Date.now() - startedAt,
           modelCalls: 0,
           committers: changeSet.committers,
+          commitSubjects: changeSet.commitSubjects,
           skipped: true,
           skipReason: "no_candidates",
           filesChanged: changeSet.summary.fileCount,
@@ -162,17 +191,27 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
     const pack = profile?.context === "sem" || searchContexts.length === contexts.length
       ? initialPack
       : await repomixContextPack(changeSet.contextCwd, searchContexts, changeSet.changes, baseRepomixConfig);
-    const batches = await buildSearchBatches({
-      command,
-      changeSet,
-      contexts: searchContexts,
-      initialPack: pack,
-      checks,
-      profile,
-      includeCounterReasonInPrompt: command.includeCounterReasonInPrompt,
-      maxSearchInputTokens,
-      baseRepomixConfig,
-    });
+    const { value: batches } = await t.trace(
+      "search.batches",
+      () => buildSearchBatches({
+        command,
+        changeSet,
+        contexts: searchContexts,
+        initialPack: pack,
+        checks,
+        profile,
+        includeCounterReasonInPrompt: command.includeCounterReasonInPrompt,
+        maxSearchInputTokens,
+        baseRepomixConfig,
+      }),
+      {
+        startDetail: `${searchContexts.length} targets`,
+        count: (result) => result.batches.length,
+        detail: (result) => result.wasSplit
+          ? `${result.skippedTargets} oversized targets skipped`
+          : `${result.estimatedInputTokens} estimated tokens`,
+      },
+    );
 
     if (batches.batches.length === 0) {
       return {
@@ -187,6 +226,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
           inputTokens: batches.estimatedInputTokens,
           inputTokenCap: maxSearchInputTokens,
           committers: changeSet.committers,
+          commitSubjects: changeSet.commitSubjects,
           skipped: true,
           skipReason: "input_too_large",
           filesChanged: changeSet.summary.fileCount,
@@ -222,7 +262,14 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
     let inputTokens = 0;
     let exactSkippedTargets = batches.skippedTargets;
     for (const batch of batches.batches) {
-      const batchInputTokens = await countPromptTokens(model, batch.request.prompt);
+      const { value: batchInputTokens } = await t.trace(
+        "prompt.tokens",
+        () => countPromptTokens(model, batch.request.prompt),
+        {
+          startDetail: `${batch.contexts.length} targets`,
+          count: (tokens) => tokens,
+        },
+      );
       inputTokens += batchInputTokens;
       if (batchInputTokens > maxSearchInputTokens) {
         exactSkippedTargets += batch.contexts.length;
@@ -234,12 +281,15 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
       const { value } = await t.trace(
         "search.model",
         () => runSearch(model, batch.request),
-        { count: (v) => v.length },
+        {
+          startDetail: `${batch.contexts.length} targets`,
+          count: (v) => v.length,
+        },
       );
       modelCalls += 1;
       matches.push(...withCheckWhy(value, checks));
     }
-    const uniqueMatches = dedupeMatches(matches);
+    const uniqueMatches = await withEntityBlame(dedupeMatches(matches), changeSet.target, command);
 
     return {
       schemaVersion: "search.v1",
@@ -253,6 +303,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
         inputTokens,
         inputTokenCap: maxSearchInputTokens,
         committers: changeSet.committers,
+        commitSubjects: changeSet.commitSubjects,
         filesChanged: changeSet.summary.fileCount,
         entitiesScanned: changeSet.summary.total,
         candidates: contexts.length,
@@ -287,10 +338,29 @@ function withCheckWhy(matches: readonly SearchMatch[], checks: readonly StupifyC
   const checksById = new Map(checks.map((check) => [check.id, check]));
   return matches.map((match) => ({
     ...match,
+    patternName: checksById.get(match.patternId)?.name,
     checkWhy: checksById.get(match.patternId)?.why,
   }));
 }
 
+async function withEntityBlame(
+  matches: readonly SearchMatch[],
+  targetRev: string,
+  command: SearchCommand,
+): Promise<readonly SearchMatch[]> {
+  if (command.kind === "staged" || command.kind === "stdin") return matches;
+
+  return Promise.all(matches.map(async (match) => {
+    if (!match.filePath || !match.entityName) return match;
+    const blame = await blameEntity({
+      filePath: match.filePath,
+      entityName: match.entityName,
+      rev: targetRev,
+    });
+    return blame ? { ...match, blame } : match;
+  }));
+}
+
 type SearchBatch = Readonly<{
   contexts: readonly SemContext[];
   pack: SemContextPack;
@@ -441,13 +511,33 @@ function printRunPlan(
   );
 }
 
+function formatStartStep(name: string, detail?: string): string {
+  if (name === "entity.diff") return "Diff: running sem over the selected git range";
+  if (name === "context.pack") return "Context: packing selected target files with Repomix";
+  if (name === "search.batches") return `Search: preparing token-bounded model batches${detail ? ` for ${detail}` : ""}`;
+  if (name === "prompt.tokens") return `Tokens: counting search prompt${detail ? ` for ${detail}` : ""}`;
+  if (name === "search.model") return `Model: searching selected target/check pairs${detail ? ` (${detail})` : ""}`;
+  return `${name}: working`;
+}
+
 function formatStep(name: string, ms: number, count?: number, detail?: string): string {
   if (name === "entity.diff") return `Diff: ${detail ?? "changed files"}, ${count ?? 0} changed entities (${ms}ms)`;
   if (name === "context.pack") return `Context: ${count ?? 0} files, ${detail ?? "0 tokens"} (${ms}ms)`;
+  if (name === "search.batches") return `Search: ${count ?? 0} model batches, ${detail ?? "0 estimated tokens"} (${ms}ms)`;
+  if (name === "prompt.tokens") return `Tokens: ${count ?? 0} prompt tokens (${ms}ms)`;
   if (name === "search.model") return `Model: ${count ?? 0} matches (${ms}ms)`;
   return `${name}: ${ms}ms`;
 }
 
+function formatErrorStep(name: string, ms: number): string {
+  if (name === "entity.diff") return `Diff failed after ${ms}ms`;
+  if (name === "context.pack") return `Context packing failed after ${ms}ms`;
+  if (name === "search.batches") return `Search batch preparation failed after ${ms}ms`;
+  if (name === "prompt.tokens") return `Token counting failed after ${ms}ms`;
+  if (name === "search.model") return `Model search failed after ${ms}ms`;
+  return `${name} failed after ${ms}ms`;
+}
+
 function scoutPlanLine(plan: CounterScoutPlan, entitiesScanned: number): string {
   if (plan.targets.length === 0) {
     return `Scout: deterministic counters scanned ${entitiesScanned} entities; no target/check pairs selected`;

package/src/trace.ts

@@ -9,6 +9,7 @@ export type Tracer = {
 
 export type SpanTraceEvent = Readonly<{
   name: string;
+  phase: "start" | "end" | "error";
   ms: number;
   count?: number;
   detail?: string;
@@ -16,6 +17,7 @@ export type SpanTraceEvent = Readonly<{
 
 export type SpanTraceOptions<T> = Readonly<{
   fields?: TraceFields;
+  startDetail?: string | (() => string);
   count?: (value: T) => number;
   detail?: (value: T) => string;
 }>;
@@ -53,6 +55,12 @@ export function createTracer(options?: CreateTracerOptions): Tracer {
     options?: SpanTraceOptions<T>,
   ): Promise<{ value: T; ms: number }> | { value: T; ms: number } {
     const startedAtMs = nowMs();
+    onEvent?.({
+      name: span,
+      phase: "start",
+      ms: 0,
+      detail: typeof options?.startDetail === "function" ? options.startDetail() : options?.startDetail,
+    });
     try {
       const out = fn();
       if (isPromiseLike(out)) {
@@ -63,12 +71,21 @@ export function createTracer(options?: CreateTracerOptions): Tracer {
             durationMs = nowMs() - startedAtMs;
             const event: SpanTraceEvent = {
               name: span,
+              phase: "end",
               ms: Math.round(durationMs),
               count: options?.count?.(value),
               detail: options?.detail?.(value),
             };
             onEvent?.(event);
             return { value, ms: event.ms };
+          } catch (error) {
+            durationMs = nowMs() - startedAtMs;
+            onEvent?.({
+              name: span,
+              phase: "error",
+              ms: Math.round(durationMs),
+            });
+            throw error;
           } finally {
             durationMs ??= nowMs() - startedAtMs;
             emit(span, durationMs, options?.fields);
@@ -80,6 +97,7 @@ export function createTracer(options?: CreateTracerOptions): Tracer {
       emit(span, durationMs, options?.fields);
       const event: SpanTraceEvent = {
         name: span,
+        phase: "end",
         ms: Math.round(durationMs),
         count: options?.count?.(out),
         detail: options?.detail?.(out),
@@ -88,6 +106,11 @@ export function createTracer(options?: CreateTracerOptions): Tracer {
       return { value: out, ms: event.ms };
     } catch (error) {
       const durationMs = nowMs() - startedAtMs;
+      onEvent?.({
+        name: span,
+        phase: "error",
+        ms: Math.round(durationMs),
+      });
       emit(span, durationMs, options?.fields);
       throw error;
     }

package/src/types.ts

@@ -78,6 +78,12 @@ export type StagedDiff = Readonly<{
   stats: NetDiffStats;
 }>;
 
+export type BlameSummary = Readonly<{
+  commit: string;
+  author: string;
+  subject: string;
+}>;
+
 export type NetDiff = Readonly<{
   id: SourceId;
   label: string;
@@ -93,6 +99,7 @@ export type SourceRange = Readonly<{
   base: string;
   target: string;
   committers?: readonly string[];
+  commitSubjects?: readonly string[];
   stats: NetDiffStats;
 }>;
 
@@ -122,6 +129,7 @@ export type SemChangeSet = Readonly<{
   base: string;
   target: string;
   committers?: readonly string[];
+  commitSubjects?: readonly string[];
   contextCwd: string;
   cleanup: () => Promise<void>;
   changes: readonly SemChange[];
@@ -195,10 +203,15 @@ export type SearchProfile = Readonly<{
 export type SearchMatch = Readonly<{
   targetId: string;
   patternId: CheckId;
+  patternName?: string;
   checkWhy?: string;
   reason: string;
   proof: string;
   snapshot?: string;
+  filePath?: string;
+  entityName?: string;
+  entityKind?: string;
+  blame?: BlameSummary;
 }>;
 
 export type SearchRunJson = Readonly<{
@@ -215,6 +228,7 @@ export type SearchRunJson = Readonly<{
     skipped?: boolean;
     skipReason?: "input_too_large" | "no_candidates";
     committers?: readonly string[];
+    commitSubjects?: readonly string[];
     filesChanged?: number;
     entitiesScanned?: number;
     candidates?: number;