@stupify/cli 0.0.15 → 0.0.16

package/src/doctor.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.ts";
 import { runHookCommand } from "./hooks.ts";
+import type { CliUi } from "./ui.ts";
 
 const execFileAsync = promisify(execFile);
 
@@ -17,7 +18,13 @@ type DoctorCheck = Readonly<{
   required?: boolean;
 }>;
 
-export async function runDoctor(): Promise<Readonly<{ exitCode: number; text: string }>> {
+export type DoctorResult = Readonly<{
+  exitCode: number;
+  text: string;
+  checks: readonly DoctorCheck[];
+}>;
+
+export async function runDoctor(): Promise<DoctorResult> {
   const checks = await Promise.all([
     gitCheck(),
     hookCheck(),
@@ -30,9 +37,28 @@ export async function runDoctor(): Promise<Readonly<{ exitCode: number; text: st
   return {
     exitCode: requiredMissing ? 1 : 0,
     text: renderDoctor(checks),
+    checks,
   };
 }
 
+export function renderDoctorToUi(result: DoctorResult, ui: CliUi): void {
+  const missingRequired = result.checks.filter((check) => check.required && check.status === "missing");
+  if (missingRequired.length > 0) {
+    ui.error(`Doctor found ${missingRequired.length} missing required dependency.`);
+  } else {
+    ui.success("Doctor checks complete.");
+  }
+
+  ui.note(
+    result.checks.map((check) => `${icon(check.status)} ${check.label}: ${check.detail}`).join("\n"),
+    "Doctor",
+  );
+  ui.note(
+    "Local-only. Stupify does not upload source, diffs, filenames, repo URLs, commit messages, author names, or private package names.",
+    "Privacy",
+  );
+}
+
 async function gitCheck(): Promise<DoctorCheck> {
   try {
     const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { maxBuffer: 1024 * 1024 });

package/src/git.ts

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { sourceId, type NetDiff, type NetDiffStats, type SourceRange, type StagedDiff } from "./types.ts";
+import { sourceId, type BlameSummary, type NetDiff, type NetDiffStats, type SourceRange, type StagedDiff } from "./types.ts";
 
 const execFileAsync = promisify(execFile);
 
@@ -106,6 +106,27 @@ export async function gitUserLabel(): Promise<string> {
   return name || email || "working tree";
 }
 
+export async function blameEntity(input: Readonly<{
+  filePath: string;
+  entityName: string;
+  rev: string;
+}>): Promise<BlameSummary | null> {
+  try {
+    const { stdout } = await execFileAsync("git", [
+      "blame",
+      "--line-porcelain",
+      "-L",
+      `:${input.entityName}`,
+      input.rev,
+      "--",
+      input.filePath,
+    ], { maxBuffer: 16 * 1024 * 1024 });
+    return summarizeBlame(stdout);
+  } catch {
+    return null;
+  }
+}
+
 async function netDiff(base: string, target: string, label: string, id?: NetDiff["id"]): Promise<NetDiff> {
   const [text, stats, shortBase, shortTarget] = await Promise.all([
     diff(base, target),
@@ -124,11 +145,12 @@ async function netDiff(base: string, target: string, label: string, id?: NetDiff
 }
 
 async function sourceRange(base: string, target: string, label: string, id?: SourceRange["id"]): Promise<SourceRange> {
-  const [stats, shortBase, shortTarget, committers] = await Promise.all([
+  const [stats, shortBase, shortTarget, committers, commitSubjects] = await Promise.all([
     diffStats(base, target),
     shortCommit(base),
     shortCommit(target),
     committersForRange(base, target),
+    commitSubjectsForRange(base, target),
   ]);
   return {
     id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
@@ -136,6 +158,7 @@ async function sourceRange(base: string, target: string, label: string, id?: Sou
     base,
     target,
     committers,
+    commitSubjects,
     stats,
   };
 }
@@ -160,6 +183,17 @@ async function committersForRange(base: string, target: string): Promise<readonl
   }
 }
 
+async function commitSubjectsForRange(base: string, target: string): Promise<readonly string[]> {
+  try {
+    const { stdout } = await execFileAsync("git", ["log", "--format=%s", `${base}..${target}`], {
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    return uniqueLines(stdout);
+  } catch {
+    return [];
+  }
+}
+
 function uniqueLines(value: string): readonly string[] {
   const seen = new Set<string>();
   const lines: string[] = [];
@@ -304,3 +338,43 @@ async function commitMessage(commit: string): Promise<string> {
 function firstLine(value: string): string {
   return value.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
 }
+
+function summarizeBlame(output: string): BlameSummary | null {
+  const entries = new Map<string, { commit: string; author: string; subject: string; count: number }>();
+  let currentCommit = "";
+  let currentAuthor = "";
+  let currentSubject = "";
+  for (const line of output.split(/\r?\n/)) {
+    const header = /^([0-9a-f]{40})\s+/.exec(line);
+    if (header?.[1]) {
+      currentCommit = header[1];
+      currentAuthor = "";
+      currentSubject = "";
+      continue;
+    }
+    if (line.startsWith("author ")) {
+      currentAuthor = line.slice("author ".length).trim();
+      continue;
+    }
+    if (line.startsWith("summary ")) {
+      currentSubject = line.slice("summary ".length).trim();
+      continue;
+    }
+    if (!line.startsWith("\t") || !currentCommit) continue;
+    const previous = entries.get(currentCommit);
+    entries.set(currentCommit, {
+      commit: currentCommit,
+      author: currentAuthor || previous?.author || "unknown author",
+      subject: currentSubject || previous?.subject || currentCommit.slice(0, 7),
+      count: (previous?.count ?? 0) + 1,
+    });
+  }
+
+  const [best] = [...entries.values()].sort((a, b) => b.count - a.count);
+  if (!best) return null;
+  return {
+    commit: best.commit.slice(0, 7),
+    author: best.author,
+    subject: best.subject,
+  };
+}

package/src/hooks.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { gitPath, gitRoot } from "./git.ts";
 import type { HookAction } from "./types.ts";
+import type { CliUi } from "./ui.ts";
 
 const execFileAsync = promisify(execFile);
 const START = "# stupify hook start";
@@ -16,6 +17,22 @@ export async function runHookCommand(action: HookAction): Promise<string> {
   return uninstallHook();
 }
 
+export function renderHookResultToUi(result: string, ui: CliUi): void {
+  const [firstLine = "Stupify hook: no status returned", ...rest] = result.split(/\r?\n/);
+  if (firstLine.includes("not installed")) {
+    ui.info(firstLine);
+  } else if (firstLine.includes("installed") || firstLine.includes("updated") || firstLine.includes("uninstalled")) {
+    ui.success(firstLine);
+  } else if (firstLine.includes("existing non-Stupify")) {
+    ui.warn(firstLine);
+  } else {
+    ui.info(firstLine);
+  }
+
+  const detail = rest.join("\n").trim();
+  if (detail) ui.note(detail, "Hook");
+}
+
 export function hookSnippet(): string {
   return managedBlock("stupify --staged");
 }

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 });
@@ -117,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,
@@ -160,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,
@@ -214,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,
@@ -276,7 +289,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
       modelCalls += 1;
       matches.push(...withCheckWhy(value, checks));
     }
-    const uniqueMatches = dedupeMatches(matches);
+    const uniqueMatches = await withEntityBlame(dedupeMatches(matches), changeSet.target, command);
 
     return {
       schemaVersion: "search.v1",
@@ -290,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,
@@ -324,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;

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;