@hifullmoon/aicommit 2.3.0 → 2.4.1

package/src/git-spool.js

@@ -0,0 +1,108 @@
+import { execFileSync } from 'node:child_process';
+import { closeSync, fstatSync, mkdtempSync, openSync, readSync, rmSync, writeSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const active = new Set();
+export function cleanupGitSpools() {
+  for (const source of active) source.dispose();
+}
+process.once('exit', cleanupGitSpools);
+
+// Git writes directly to a private temporary file, never to a Node stdout
+// buffer. Consumers scan the captured bytes without reopening the worktree.
+export function spoolGit(commands, cwd) {
+  const dir = mkdtempSync(join(tmpdir(), 'aicommit-diff-'));
+  const path = join(dir, 'patch');
+  let fd;
+  try {
+    fd = openSync(path, 'wx+', 0o600);
+    for (const args of commands) {
+      execFileSync('git', ['--no-pager', ...args], {
+        cwd,
+        stdio: ['ignore', fd, 'pipe'],
+        timeout: 120000,
+        maxBuffer: 1024 * 1024,
+      });
+    }
+    let size = fstatSync(fd).size;
+    closeSync(fd);
+    fd = undefined;
+    const source = {
+      get size() {
+        return size;
+      },
+      append(buffer) {
+        const output = openSync(path, 'r+');
+        try {
+          let written = 0;
+          while (written < buffer.length)
+            written += writeSync(output, buffer, written, buffer.length - written, size + written);
+          size += written;
+        } finally {
+          closeSync(output);
+        }
+      },
+      *buffers() {
+        const input = openSync(path, 'r');
+        const buffer = Buffer.alloc(64 * 1024);
+        let offset = 0;
+        try {
+          while (offset < size) {
+            const count = readSync(input, buffer, 0, buffer.length, offset);
+            if (!count) throw new Error('Captured Git patch was truncated.');
+            offset += count;
+            yield buffer.subarray(0, count);
+          }
+        } finally {
+          closeSync(input);
+        }
+      },
+      *lines(maxLineBytes = 1024 * 1024) {
+        let pending = Buffer.alloc(0);
+        for (const buffer of this.buffers()) {
+          const data = Buffer.concat([pending, buffer]);
+          let start = 0;
+          for (let end = data.indexOf(10); end !== -1; end = data.indexOf(10, start)) {
+            if (end - start > maxLineBytes)
+              throw new Error(
+                'Diff line exceeds the safe analysis limit (1 MiB); split the change before retrying.',
+              );
+            yield data.subarray(start, end + 1).toString('utf8');
+            start = end + 1;
+          }
+          pending = Buffer.from(data.subarray(start));
+          if (pending.length > maxLineBytes)
+            throw new Error(
+              'Diff line exceeds the safe analysis limit (1 MiB); split the change before retrying.',
+            );
+        }
+        if (pending.length) yield pending.toString('utf8');
+      },
+      text(limit) {
+        if (size > limit) return null;
+        return [...this.lines()].join('').trim();
+      },
+      dispose() {
+        if (!active.delete(source)) return;
+        rmSync(dir, { recursive: true, force: true });
+      },
+    };
+    active.add(source);
+    return source;
+  } catch (err) {
+    if (fd !== undefined) closeSync(fd);
+    rmSync(dir, { recursive: true, force: true });
+    throw new Error(`Failed to capture Git patch: ${err.message}`, { cause: err });
+  }
+}
+
+export function updateGitHash(hash, args, cwd) {
+  const source = spoolGit([args], cwd);
+  try {
+    for (const buffer of source.buffers()) hash.update(buffer);
+  } finally {
+    source.dispose();
+  }
+  return hash;
+}

package/src/git.js

@@ -3,6 +3,7 @@ import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync
 import { createHash } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { updateGitHash } from './git-spool.js';
 
 // Big repos can produce multi-MB diffs; raise the default 1MB child-process
 // buffer and surface a contextual error if the explicit limit is exceeded.
@@ -73,8 +74,11 @@ export function getStagedDiff(cwd, contextLines) {
 // ids) so a long-running AI/review step cannot silently commit a different
 // index from the one used to generate the message.
 export function getIndexFingerprint(cwd) {
-  const patch = readGit(['diff', '--staged', '--binary', '--full-index', '--no-ext-diff'], cwd);
-  return createHash('sha256').update(patch).digest('hex');
+  return updateGitHash(
+    createHash('sha256'),
+    ['diff', '--staged', '--binary', '--full-index', '--no-ext-diff'],
+    cwd,
+  ).digest('hex');
 }
 
 function hashFileOrMissing(path) {
@@ -428,7 +432,7 @@ export function protectSensitiveDiff(diff) {
   return { diff: out.join(''), findings: [...new Set(findings)] };
 }
 
-export function runGit(args, projectRoot, inherit = false) {
+export function runGit(args, projectRoot, inherit = false, input = undefined) {
   try {
     const stdio =
       inherit === 'stderr'
@@ -436,7 +440,7 @@ export function runGit(args, projectRoot, inherit = false) {
         : inherit
           ? 'inherit'
           : 'pipe';
-    execFileSync('git', args, { cwd: projectRoot, stdio });
+    execFileSync('git', args, { cwd: projectRoot, stdio, input });
   } catch (err) {
     const detail =
       typeof err.stderr === 'string' ? err.stderr.trim() : err.stderr?.toString('utf-8').trim();
@@ -445,6 +449,23 @@ export function runGit(args, projectRoot, inherit = false) {
   }
 }
 
+export function pathBatches(paths, limit = 6000) {
+  const batches = [];
+  let batch = [];
+  let size = 0;
+  for (const path of paths) {
+    if (batch.length && size + path.length * 2 + 4 > limit) {
+      batches.push(batch);
+      batch = [];
+      size = 0;
+    }
+    batch.push(path);
+    size += path.length * 2 + 4;
+  }
+  if (batch.length) batches.push(batch);
+  return batches;
+}
+
 export function hasHead(projectRoot) {
   try {
     execFileSync('git', ['rev-parse', '--verify', 'HEAD'], {

package/src/local-analysis.js

@@ -0,0 +1,271 @@
+import { createHash } from 'node:crypto';
+import { isLockFile, matchStripPattern } from './git.js';
+import { ERROR_CATEGORIES, fail } from './errors.js';
+
+// These are evidence-selection rules, not exclusions from Git or secret scans.
+export function isGeneratedFile(path) {
+  return (
+    /(?:^|\/)(?:dist|build|coverage|vendor|node_modules)\//.test(path) ||
+    /(?:\.min\.(?:js|css)|\.map|\.snap|\.generated\.[^/]+)$/.test(path)
+  );
+}
+
+export function isDeepAnalysis(config) {
+  return config.largeChange?.strategy === 'deep';
+}
+
+function clip(text, bytes) {
+  if (Buffer.byteLength(text) <= bytes) return text;
+  let result = '';
+  let size = 0;
+  for (const char of text) {
+    size += Buffer.byteLength(char);
+    if (size > Math.max(0, bytes - 3)) break;
+    result += char;
+  }
+  return result + '…';
+}
+
+function category(file, config) {
+  if (isLockFile(file.path)) return 'lockfile';
+  if (matchStripPattern(file.path, config.stripFiles)) return 'excluded';
+  if (isGeneratedFile(file.path)) return 'generated';
+  if (/(?:^|\/)(?:test|tests|__tests__)\/|\.(?:test|spec)\./.test(file.path)) return 'test';
+  if (/\.(?:md|rst|txt)$/.test(file.path)) return 'documentation';
+  if (/(?:^|\/)(?:[^/]*config[^/]*|package\.json)$|\.(?:ya?ml|toml)$/.test(file.path))
+    return 'configuration';
+  return 'source';
+}
+
+function moduleOf(path) {
+  const parts = path.split('/');
+  return parts.length === 1 ? '.' : parts.slice(0, Math.min(parts.length - 1, 2)).join('/');
+}
+
+export function localInputBytes(config) {
+  // UTF-8 bytes also bound non-ASCII input. Leave space for JSON escaping,
+  // repository context, policy, and the provider's message envelope.
+  return Math.max(
+    256,
+    Math.min(
+      config.maxDiffChars || 30000,
+      Math.floor((config.analysisBudget?.limits.chunkInputTokens || 12000) * 0.6),
+    ),
+  );
+}
+
+function summaryOf(fact, evidence = true) {
+  return {
+    id: fact.id,
+    kind: fact.kind,
+    status: fact.status,
+    module: clip(fact.module, 160),
+    fileCount: fact.files.length,
+    additions: fact.additions,
+    deletions: fact.deletions,
+    ...(fact.modeChange ? { modeChange: fact.modeChange } : {}),
+    ...(fact.binary ? { binary: true } : {}),
+    examples: fact.files.slice(0, 2).map((path) => clip(path, 180)),
+    ...(evidence && fact.evidence ? { representativeExcerpt: fact.evidence } : {}),
+  };
+}
+
+const SAMPLE_NOTICE =
+  'Local change inventory with selected excerpts, not complete semantic analysis. ' +
+  'Counts cover every file. Excerpts are partial; omitted content and paths are not evidence of unchanged behavior. ' +
+  'Identical textual edits are grouped within a module. Describe supported changes conservatively; do not infer intent.';
+
+function ranked(facts) {
+  const priority = { source: 0, configuration: 1, test: 2, documentation: 3 };
+  return [...facts].sort(
+    (a, b) =>
+      (priority[a.kind] ?? 4) - (priority[b.kind] ?? 4) ||
+      b.files.length - a.files.length ||
+      a.id.localeCompare(b.id),
+  );
+}
+
+export function localOverview(config, facts) {
+  const kinds = {};
+  const statuses = {};
+  let totalFiles = 0;
+  let additions = 0;
+  let deletions = 0;
+  let modeChangedFiles = 0;
+  let binaryFiles = 0;
+  for (const fact of facts) {
+    totalFiles += fact.files.length;
+    additions += fact.additions;
+    deletions += fact.deletions;
+    if (fact.modeChange) modeChangedFiles += fact.files.length;
+    if (fact.binary) binaryFiles += fact.files.length;
+    kinds[fact.kind] = (kinds[fact.kind] || 0) + fact.files.length;
+    statuses[fact.status] = (statuses[fact.status] || 0) + fact.files.length;
+  }
+  const data = {
+    notice: SAMPLE_NOTICE,
+    totalFiles,
+    additions,
+    deletions,
+    modeChangedFiles,
+    binaryFiles,
+    lineCounts: 'tracked diff only',
+    kinds,
+    statuses,
+    totalGroups: facts.length,
+    omittedGroups: facts.length,
+    samples: [],
+  };
+  const cap = localInputBytes(config);
+  let sampledFiles = 0;
+  const seen = new Set();
+  const ordered = ranked(facts);
+  // First cover distinct modules/categories, then use remaining space for detail.
+  const diverse = [];
+  const rest = [];
+  for (const fact of ordered) {
+    const key = JSON.stringify([fact.module, fact.kind]);
+    if (seen.has(key)) rest.push(fact);
+    else {
+      seen.add(key);
+      diverse.push(fact);
+    }
+  }
+  const firstKinds = new Set();
+  const first = [];
+  const remaining = [];
+  for (const fact of diverse) {
+    if (firstKinds.has(fact.kind)) remaining.push(fact);
+    else {
+      firstKinds.add(fact.kind);
+      first.push(fact);
+    }
+  }
+  for (const fact of [...first, ...remaining, ...rest]) {
+    if (data.samples.length >= 16) break;
+    const sample = summaryOf(fact);
+    data.samples.push(sample);
+    if (Buffer.byteLength(JSON.stringify(data)) > cap) {
+      data.samples.pop();
+      continue;
+    }
+    if (fact.evidence) sampledFiles++;
+    data.omittedGroups--;
+  }
+  // A tiny configured budget may not even fit aggregate metadata. Fail before
+  // sending rather than silently slicing JSON or dropping the uncertainty notice.
+  const text = JSON.stringify(data);
+  if (Buffer.byteLength(text) > cap)
+    throw fail(
+      ERROR_CATEGORIES.CONFIG,
+      'Local change inventory does not fit the input budget. Increase largeChange.chunkInputTokens or maxDiffChars.',
+    );
+  return { text, sampledFiles };
+}
+
+export function analyzeLocally(config, capture, protect, previews) {
+  const records = new Map(
+    capture.manifest.map((file) => [
+      file.id,
+      {
+        file,
+        hash: createHash('sha256'),
+        evidence: '',
+        textual: false,
+      },
+    ]),
+  );
+  for (const unit of capture.units(protect, previews)) {
+    if (unit.metadataOnly) continue;
+    const record = records.get(unit.fileId);
+    // Tracked fragments carry Git headers; untracked fragments are plain text.
+    const section = unit.id.match(/S\d+(?=P\d+$)/)?.[0];
+    if (section && section !== record.section) {
+      record.section = section;
+      record.inHunk = false;
+    }
+    for (const line of unit.text.split(/(?<=\n)/)) {
+      if (section) {
+        if (line.startsWith('@@')) record.inHunk = true;
+        if (!record.inHunk || !/^[+-]/.test(line)) continue;
+      }
+      record.hash.update(line);
+      record.textual = true;
+      const remaining = 900 - Buffer.byteLength(record.evidence);
+      if (remaining > 3) record.evidence += clip(line, remaining);
+    }
+  }
+  const grouped = new Map();
+  for (const { file, hash, evidence, textual } of records.values()) {
+    const kind = category(file, config);
+    const module = moduleOf(file.addPaths?.at(-1) || file.path);
+    const status = file.status.replace(/\d+$/, '');
+    const metadata = ['lockfile', 'excluded', 'generated'].includes(kind);
+    const modeChange =
+      file.oldMode && file.newMode && file.oldMode !== file.newMode
+        ? `${file.oldMode} -> ${file.newMode}`
+        : null;
+    // Unknown/binary changes and renames stay independent for split safety.
+    const identity = metadata
+      ? 'metadata'
+      : textual && !status.startsWith('R')
+        ? hash.digest('hex')
+        : file.id;
+    const key = JSON.stringify([kind, module, status, identity, modeChange, !!file.binary]);
+    let fact = grouped.get(key);
+    if (!fact) {
+      fact = {
+        id: file.id,
+        kind,
+        module,
+        status,
+        files: [],
+        additions: 0,
+        deletions: 0,
+        modeChange,
+        binary: !!file.binary,
+        evidence: metadata ? '' : evidence,
+      };
+      grouped.set(key, fact);
+    }
+    fact.files.push(file.path);
+    fact.additions += file.additions;
+    fact.deletions += file.deletions;
+  }
+  const facts = [...grouped.values()];
+  const overview = localOverview(config, facts);
+  return {
+    facts,
+    summary: overview.text,
+    coverage: {
+      strategy: 'auto',
+      totalFiles: capture.manifest.length,
+      analyzedFiles: 0,
+      sampledFiles: overview.sampledFiles,
+      metadataOnlyFiles: capture.manifest.length - overview.sampledFiles,
+      failedFiles: 0,
+      completedChunks: 0,
+    },
+  };
+}
+
+export function localPlanItems(config, facts, cap) {
+  const error = () =>
+    fail(
+      ERROR_CATEGORIES.CONFIG,
+      'The complete split candidate inventory does not fit one request. Stage a smaller logical change or explicitly set personal largeChange.strategy to deep. No planning request was sent.',
+    );
+  if (facts.length > (config.splitMaxPlanFiles || 100)) throw error();
+  const items = facts.map((fact) => ({
+    ...summaryOf(fact, false),
+    summary: 'Local candidate only; verify grouping. Content not fully analyzed.',
+  }));
+  if (Buffer.byteLength(JSON.stringify(items)) > cap) throw error();
+  for (const fact of ranked(facts)) {
+    if (!fact.evidence) continue;
+    const item = items.find((item) => item.id === fact.id);
+    item.representativeExcerpt = fact.evidence;
+    if (Buffer.byteLength(JSON.stringify(items)) > cap) delete item.representativeExcerpt;
+  }
+  return items;
+}

package/src/main.js

@@ -6,9 +6,7 @@ import chalk from 'chalk';
 import { parseArgs } from './cli.js';
 import { getProjectRoot, loadConfig } from './config.js';
 import {
-  getStagedDiff,
   getChangedFiles,
-  getDiffStats,
   getBranch,
   gitCommit,
   stripLockFileContent,
@@ -21,7 +19,16 @@ import {
   getIndexFingerprint,
   createIndexTransaction,
   protectSensitiveDiff,
+  unifiedArg,
 } from './git.js';
+import {
+  captureChanges,
+  needsAnalysis,
+  analysisConfig,
+  analyzeChanges,
+  summarizeChanges,
+} from './change-analysis.js';
+import { cleanupGitSpools } from './git-spool.js';
 import { generateCommitMessage } from './api.js';
 import {
   statusColor,
@@ -41,7 +48,13 @@ import {
   stringifyConfigRedacted,
   redactSensitiveUrl,
 } from './utils.js';
-import { abortSplit, applySplitPlan, resumeSplit, splitFlow } from './split.js';
+import {
+  abortSplit,
+  applySplitPlan,
+  resumeSplit,
+  splitFlow,
+  getStagedChangedFiles,
+} from './split.js';
 import { runModelTask } from './generation-ui.js';
 import { runSetup } from './setup.js';
 import { detectProviderType } from './providers.js';
@@ -357,8 +370,7 @@ async function runMain() {
     indexTransaction ||= createIndexTransaction(projectRoot);
     return indexTransaction;
   };
-  let diff = getStagedDiff(projectRoot, config.diffContextLines);
-  if (!diff) {
+  if (!getChangedFiles(projectRoot).length) {
     // Nothing staged. But git diff --staged is also empty for unstaged work
     // and untracked files — surface what git status actually shows instead of
     // falsely claiming there's nothing to commit.
@@ -429,7 +441,14 @@ async function runMain() {
 
     try {
       beginIndexTransaction();
-      runGit(toStage ? ['add', '--', ...toStage] : ['add', '-A'], projectRoot);
+      runGit(
+        toStage
+          ? ['--literal-pathspecs', 'add', '--pathspec-from-file=-', '--pathspec-file-nul']
+          : ['add', '-A'],
+        projectRoot,
+        false,
+        toStage ? toStage.join('\0') + '\0' : undefined,
+      );
       indexTransaction.markOwned();
     } catch (err) {
       indexTransaction?.restore({ force: true });
@@ -443,8 +462,7 @@ async function runMain() {
       });
     }
 
-    diff = getStagedDiff(projectRoot, config.diffContextLines);
-    if (!diff) {
+    if (!getChangedFiles(projectRoot).length) {
       console.log('\n  ' + chalk.yellow('✗ Nothing staged — no diff to commit.\n'));
       throw fail(ERROR_CATEGORIES.GIT_STATE, 'Nothing staged; no diff to commit.', {
         reported: true,
@@ -455,7 +473,14 @@ async function runMain() {
   // Re-read the final diff between two complete-index fingerprints so the
   // prompt is guaranteed to describe one stable staged snapshot.
   const plannedIndexFingerprint = getIndexFingerprint(projectRoot);
-  diff = getStagedDiff(projectRoot, config.diffContextLines);
+  const changedFiles = getChangedFiles(projectRoot);
+  const captured = captureChanges(
+    [['diff', unifiedArg(config.diffContextLines), '--staged']],
+    projectRoot,
+    getStagedChangedFiles(projectRoot),
+    config,
+  );
+  const diff = captured.diff || '';
   if (getIndexFingerprint(projectRoot) !== plannedIndexFingerprint) {
     console.log(
       '\n  ' + chalk.red('✗ The staged changes are being modified concurrently; commit aborted.\n'),
@@ -467,8 +492,7 @@ async function runMain() {
     );
   }
 
-  const stats = getDiffStats(diff);
-  const changedFiles = getChangedFiles(projectRoot);
+  const stats = captured.stats;
   const branch = getBranch(projectRoot);
   const stageIcon = chalk.green('staged');
   const changeStr = chalk.green(`+${stats.additions}`) + '  ' + chalk.red(`-${stats.deletions}`);
@@ -499,7 +523,9 @@ async function runMain() {
   // Protect common secrets before any repository content leaves the machine.
   // The protected diff affects only the model request, never the actual index.
   const protectedInput = protectSensitiveDiff(diff);
+  protectedInput.findings = [...new Set([...protectedInput.findings, ...captured.findings])];
   let diffForModel = diff;
+  let protectAnalysis = true;
   if (protectedInput.findings.length) {
     warnings.push('Sensitive data was detected and protected before the provider request.');
     console.log('\n  ' + chalk.yellow.bold('⚠ Potential sensitive data detected:'));
@@ -529,21 +555,35 @@ async function runMain() {
       return finishCancelled();
     }
     if (sensitiveAction === 'protect') diffForModel = protectedInput.diff;
+    if (sensitiveAction === 'original') protectAnalysis = false;
   }
 
-  // Prepare the diff the model sees (computed once — it doesn't change across
-  // regenerations): lock-file and stripFiles contents are stubbed (they carry
-  // no commit intent) and oversized diffs are condensed to a --stat summary
-  // plus truncated hunks, so token spend stays proportional to what the
-  // model needs.
+  // Small changes keep the existing prompt. Large changes use a local
+  // inventory by default; exhaustive model analysis is an explicit opt-in.
+  const large = needsAnalysis(captured, config);
   const strippedDiff = stripLockFileContent(diffForModel, config.stripFiles);
-  const { diff: modelDiff, truncated } = condenseDiff(
-    strippedDiff,
-    config.maxDiffChars,
-    getDiffStat(projectRoot),
-    config.maxFileDiffChars,
-  );
-  if (truncated) {
+  let { diff: modelDiff, truncated } = large
+    ? { diff: '', truncated: false }
+    : condenseDiff(
+        strippedDiff,
+        config.maxDiffChars,
+        getDiffStat(projectRoot),
+        config.maxFileDiffChars,
+      );
+  let analysis;
+  let analyzedFacts;
+  let generationConfig = config;
+  if (large) {
+    generationConfig = analysisConfig(config);
+    console.log(
+      chalk.dim(
+        generationConfig.largeChange?.strategy === 'deep'
+          ? `  Large change: analyzing all ${changedFiles.length} files in bounded chunks.`
+          : `  Large change: building a local inventory of ${changedFiles.length} files with bounded excerpts.`,
+      ),
+    );
+  }
+  if (truncated && !large) {
     warnings.push('The diff was condensed to fit the configured provider input limit.');
     console.log(
       chalk.dim(
@@ -575,8 +615,41 @@ async function runMain() {
         machineOutput,
         cancelMessage: 'Commit cancelled.',
         failureMessage: 'API call failed',
-        task: (stream) =>
-          generateCommitMessage(config, modelDiff, regenerateCount, message, stream),
+        task: async (stream) => {
+          if (large && !analysis) {
+            analyzedFacts ||= await analyzeChanges(
+              generationConfig,
+              captured,
+              protectAnalysis,
+              null,
+              ({ completedChunks }) =>
+                console.error(`  Analysis: ${completedChunks} chunks completed`),
+            );
+            modelDiff =
+              analyzedFacts.summary ||
+              (await summarizeChanges(generationConfig, analyzedFacts.facts));
+            analysis = analyzedFacts;
+            console.error(
+              `  Coverage: ${analysis.coverage.analyzedFiles} files analyzed; ${analysis.coverage.sampledFiles || 0} representative excerpts; ${analysis.coverage.metadataOnlyFiles} metadata only.`,
+            );
+            if (analysis.coverage.strategy === 'auto')
+              warnings.push(
+                'Large changes were summarized locally with selected excerpts; content was not fully analyzed.',
+              );
+          }
+          const result = await generateCommitMessage(
+            generationConfig,
+            modelDiff,
+            regenerateCount,
+            message,
+            stream,
+          );
+          if (large) {
+            result.usage = generationConfig.analysisBudget.snapshot().usage;
+            result.elapsed = generationConfig.analysisBudget.snapshot().elapsedMs;
+          }
+          return result;
+        },
         successMessage(result) {
           let done = `Generated in ${chalk.bold(formatMs(result.elapsed))}`;
           if (result.usage) done += chalk.dim(`  · tokens: ${formatUsage(result.usage)}`);
@@ -697,6 +770,13 @@ async function runMain() {
       usage,
       warnings,
       exitReason: 'dry_run',
+      ...(analysis
+        ? {
+            data: {
+              analysis: { ...analysis.coverage, ...generationConfig.analysisBudget.snapshot() },
+            },
+          }
+        : {}),
       committed: false,
       edited: wasEdited,
       rewrites: regenerateCount + automaticCorrectionCount,
@@ -736,6 +816,13 @@ async function runMain() {
       usage,
       warnings,
       exitReason: 'success',
+      ...(analysis
+        ? {
+            data: {
+              analysis: { ...analysis.coverage, ...generationConfig.analysisBudget.snapshot() },
+            },
+          }
+        : {}),
       committed: true,
       edited: wasEdited,
       rewrites: regenerateCount + automaticCorrectionCount,
@@ -767,5 +854,7 @@ export async function main() {
       edited: false,
       rewrites: 0,
     };
+  } finally {
+    cleanupGitSpools();
   }
 }