@hifullmoon/aicommit 2.4.1 → 2.6.0

package/src/completion.js

@@ -5,6 +5,8 @@ const TOP_LEVEL = [
   'config',
   'policy',
   'completion',
+  'generate',
+  'apply',
   'split',
   '--help',
   '--version',
@@ -16,6 +18,7 @@ const TOP_LEVEL = [
   '--no-reasoning',
   '--dry-run',
   '--yes',
+  '--allow-single-fallback',
   '--output',
   '--debug',
 ];
@@ -32,7 +35,7 @@ _aicommit() {
     config) COMPREPLY=( $(compgen -W "show validate path --provider --model --output --debug" -- "$cur") ); return ;;
     policy) COMPREPLY=( $(compgen -W "template check --file --range --output --debug" -- "$cur") ); return ;;
     completion) COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") ); return ;;
-    split) COMPREPLY=( $(compgen -W "run plan apply resume abort --scope --file --yes --output --debug" -- "$cur") ); return ;;
+    split) COMPREPLY=( $(compgen -W "run plan apply resume abort status --scope --file --yes --allow-single-fallback --output --debug" -- "$cur") ); return ;;
   esac
   case "$prev" in
     --lang|-l) COMPREPLY=( $(compgen -W "zh en" -- "$cur") ); return ;;
@@ -57,7 +60,9 @@ _aicommit() {
     'config:inspect or validate configuration'
     'policy:print or enforce a repository team policy'
     'completion:generate shell completion'
-    'split:run, plan, apply, resume, or abort split commits'
+    'generate:export one commit plan'
+    'apply:apply a validated commit plan'
+    'split:run, plan, apply, resume, abort, or inspect split commits'
   )
   options=(
     '--help[show help]'
@@ -65,13 +70,14 @@ _aicommit() {
     '--lang=[commit language]:language:(zh en)'
     '--provider=[provider name]:provider:'
     '--model=[model name]:model:'
-    '--scope=[split scope]:scope:(staged all)'
-    '--file=[split plan or commit-message file]:path:_files'
+    '--scope=[change scope]:scope:(staged all)'
+    '--file=[commit plan or commit-message file]:path:_files'
     '--range=[Git range for policy check]:revision:'
     '--reasoning=[reasoning effort]:effort:(low medium high xhigh max)'
     '--no-reasoning[disable reasoning]'
     '--dry-run[review without committing]'
     '--yes[accept without prompts]'
+    '--allow-single-fallback[allow non-interactive split to commit one conservative group]'
     '--output=[output mode]:output:(text json)'
     '--debug[show debug details]'
   )
@@ -85,7 +91,7 @@ _aicommit() {
         config) _values 'config action' show validate path ;;
         policy) _values 'policy action' template check ;;
         completion) _values 'shell' bash zsh fish ;;
-        split) _values 'split action' run plan apply resume abort ;;
+        split) _values 'split action' run plan apply resume abort status ;;
       esac
       ;;
   esac
@@ -101,23 +107,26 @@ complete -c aicommit -n '__fish_use_subcommand' -a doctor -d 'Diagnose configura
 complete -c aicommit -n '__fish_use_subcommand' -a config -d 'Inspect or validate configuration'
 complete -c aicommit -n '__fish_use_subcommand' -a policy -d 'Print or enforce a repository team policy'
 complete -c aicommit -n '__fish_use_subcommand' -a completion -d 'Generate shell completion'
+complete -c aicommit -n '__fish_use_subcommand' -a generate -d 'Export one commit plan'
+complete -c aicommit -n '__fish_use_subcommand' -a apply -d 'Apply a validated commit plan'
 complete -c aicommit -n '__fish_use_subcommand' -a split -d 'Run, plan, apply, resume, or abort split commits'
 complete -c aicommit -n '__fish_seen_subcommand_from config' -a 'show validate path'
 complete -c aicommit -n '__fish_seen_subcommand_from policy' -a 'template check'
 complete -c aicommit -n '__fish_seen_subcommand_from completion' -a 'bash zsh fish'
-complete -c aicommit -n '__fish_seen_subcommand_from split' -a 'run plan apply resume abort'
+complete -c aicommit -n '__fish_seen_subcommand_from split' -a 'run plan apply resume abort status'
 complete -c aicommit -s h -l help -d 'Show help'
 complete -c aicommit -s v -l version -d 'Show version'
 complete -c aicommit -s l -l lang -x -a 'zh en' -d 'Commit language'
 complete -c aicommit -s p -l provider -x -d 'Provider name'
 complete -c aicommit -s m -l model -x -d 'Model name'
-complete -c aicommit -l scope -x -a 'staged all' -d 'Split plan scope'
-complete -c aicommit -l file -r -d 'Split plan file'
+complete -c aicommit -l scope -x -a 'staged all' -d 'Change scope'
+complete -c aicommit -l file -r -d 'Commit plan file'
 complete -c aicommit -l range -r -d 'Git range for policy check'
 complete -c aicommit -l reasoning -x -a 'low medium high xhigh max' -d 'Reasoning effort'
 complete -c aicommit -l no-reasoning -d 'Disable reasoning'
 complete -c aicommit -l dry-run -d 'Review without committing'
 complete -c aicommit -s y -l yes -d 'Accept without prompts'
+complete -c aicommit -l allow-single-fallback -d 'Allow non-interactive split to commit one conservative group'
 complete -c aicommit -l output -x -a 'text json' -d 'Output mode'
 complete -c aicommit -l debug -d 'Show debug details'
 `;

package/src/config.js

@@ -420,7 +420,11 @@ function assertUrl(config, key) {
   }
 }
 
-function assertNumber(config, key, { integer = false, min = -Infinity, max = Infinity } = {}) {
+function assertNumber(
+  config,
+  key,
+  { integer = false, min = -Infinity, max = Infinity, label = key } = {},
+) {
   const value = config[key];
   const ok =
     typeof value === 'number' &&
@@ -431,7 +435,7 @@ function assertNumber(config, key, { integer = false, min = -Infinity, max = Inf
   if (!ok) {
     const kind = integer ? 'integer' : 'number';
     const range = Number.isFinite(max) ? ` between ${min} and ${max}` : ` >= ${min}`;
-    throw new Error(`Invalid config "${key}": expected a ${kind}${range}.`);
+    throw new Error(`Invalid config "${label}": expected a ${kind}${range}.`);
   }
 }
 
@@ -449,6 +453,30 @@ export function validateConfig(config) {
     assertNumber(settings, 'concurrency', { integer: true, min: 1, max: 4 });
     if (settings.maxTotalTokens < settings.chunkInputTokens)
       throw new Error('largeChange.maxTotalTokens must cover one input request.');
+    if (!object(settings.cache))
+      throw new Error('Invalid config "largeChange.cache": expected an object.');
+    assertKnownKeys(
+      settings.cache,
+      new Set(Object.keys(DEFAULT_LARGE_CHANGE.cache)),
+      'largeChange.cache',
+    );
+    const cache = { ...DEFAULT_LARGE_CHANGE.cache, ...settings.cache };
+    for (const key of ['enabled', 'allowUnprotected']) {
+      if (typeof cache[key] !== 'boolean')
+        throw new Error(`Invalid config "largeChange.cache.${key}": expected a boolean.`);
+    }
+    assertNumber(cache, 'ttlMs', {
+      integer: true,
+      min: 60_000,
+      max: 7 * 24 * 60 * 60 * 1000,
+      label: 'largeChange.cache.ttlMs',
+    });
+    assertNumber(cache, 'maxBytes', {
+      integer: true,
+      min: 1024 * 1024,
+      max: 256 * 1024 * 1024,
+      label: 'largeChange.cache.maxBytes',
+    });
   }
   assertUrl(config, 'apiUrl');
   assertString(config, 'modelId');

package/src/errors.js

@@ -38,8 +38,13 @@ export class AicommitError extends Error {
     super(message);
     this.name = 'AicommitError';
     this.category = category;
+    this.code = options.code || category;
     this.exitCode = EXIT_CODES[category] ?? EXIT_CODES.internal;
     this.reported = Boolean(options.reported);
+    this.retryable = Boolean(options.retryable);
+    this.nextAction = options.nextAction || null;
+    this.committed = Boolean(options.committed);
+    this.commitState = options.commitState || 'none';
     if (options.data && typeof options.data === 'object' && !Array.isArray(options.data)) {
       this.data = options.data;
     }
@@ -62,11 +67,10 @@ export function classifyError(err) {
   const lower = message.toLowerCase();
   const code = errorCode(err);
   if (
-    err instanceof TypeError ||
     NETWORK_CODES.has(code) ||
     /timed out|fetch failed|socket|network|dns|econn|enotfound/.test(lower)
   ) {
-    return fail(ERROR_CATEGORIES.NETWORK, message, { cause: err });
+    return fail(ERROR_CATEGORIES.NETWORK, message, { cause: err, retryable: true });
   }
   if (/^http \d{3}:|streaming api error|rate limit|provider request/.test(lower)) {
     return fail(ERROR_CATEGORIES.PROVIDER, message, { cause: err });

package/src/generation-ui.js

@@ -18,7 +18,7 @@ export async function runModelTask({
   const spinner = ora({ text: chalk.dim(spinnerText), color: 'cyan' }).start();
   let liveReasoning;
   const stream =
-    reasoning?.mode === 'on' && !machineOutput
+    reasoning && reasoning.mode !== 'off' && !machineOutput
       ? {
           onReasoningDelta(chunk) {
             if (!liveReasoning) {

package/src/git.js

@@ -70,13 +70,24 @@ export function getStagedDiff(cwd, contextLines) {
   return readGit(['diff', unifiedArg(contextLines), '--staged'], cwd).trim();
 }
 
-// Hash the complete staged patch (including binary changes and full object
-// ids) so a long-running AI/review step cannot silently commit a different
-// index from the one used to generate the message.
+// Git's raw staged diff contains the full old/new blob IDs, modes, status,
+// and NUL-delimited paths for every changed entry. Hashing that metadata is
+// equivalent to hashing the staged patch for snapshot identity, including
+// binary changes, without regenerating and spooling the entire patch during
+// every pre/post-model safety check.
 export function getIndexFingerprint(cwd) {
   return updateGitHash(
     createHash('sha256'),
-    ['diff', '--staged', '--binary', '--full-index', '--no-ext-diff'],
+    [
+      'diff',
+      '--raw',
+      '--staged',
+      '--no-renames',
+      '--no-ext-diff',
+      '--no-textconv',
+      '--abbrev=64',
+      '-z',
+    ],
     cwd,
   ).digest('hex');
 }
@@ -263,7 +274,8 @@ export function condenseDiff(diff, maxChars, stat, maxSectionChars = Infinity) {
   }
   const marker = `... (diff truncated — ${diff.length} chars total)`;
   const body = kept ? `${kept}\n${marker}` : marker;
-  return { diff: stat ? `${stat}\n\n${body}` : body, truncated: true };
+  const resolvedStat = typeof stat === 'function' ? stat() : stat;
+  return { diff: resolvedStat ? `${resolvedStat}\n\n${body}` : body, truncated: true };
 }
 
 export function getChangedFiles(cwd) {

package/src/local-analysis.js

@@ -245,27 +245,57 @@ export function analyzeLocally(config, capture, protect, previews) {
       metadataOnlyFiles: capture.manifest.length - overview.sampledFiles,
       failedFiles: 0,
       completedChunks: 0,
+      cachedChunks: 0,
+      requestedChunks: 0,
     },
   };
 }
 
-export function localPlanItems(config, facts, cap) {
+export function localPlanBatches(config, facts, cap) {
   const error = () =>
-    fail(
+    fail(ERROR_CATEGORIES.CONFIG, 'A split candidate is too large for one planning request.', {
+      data: { fallbackPlan: true },
+    });
+  const maxItems = config.splitMaxPlanFiles || 100;
+  const batches = [];
+  let batch = [];
+  for (const fact of facts) {
+    const item = {
+      ...summaryOf(fact, false),
+      summary: 'Local candidate only; verify grouping. Content not fully analyzed.',
+    };
+    if (Buffer.byteLength(JSON.stringify([item])) > cap) throw error();
+    const candidate = [...batch, item];
+    if (
+      batch.length &&
+      (candidate.length > maxItems || Buffer.byteLength(JSON.stringify(candidate)) > cap)
+    ) {
+      batches.push(batch);
+      batch = [];
+    }
+    batch.push(item);
+  }
+  if (batch.length) batches.push(batch);
+
+  const factsById = new Map(facts.map((fact) => [fact.id, fact]));
+  for (const items of batches) {
+    for (const item of items) {
+      const evidence = factsById.get(item.id)?.evidence;
+      if (!evidence) continue;
+      item.representativeExcerpt = evidence;
+      if (Buffer.byteLength(JSON.stringify(items)) > cap) delete item.representativeExcerpt;
+    }
+  }
+  return batches;
+}
+
+export function localPlanItems(config, facts, cap) {
+  const batches = localPlanBatches(config, facts, cap);
+  if (batches.length !== 1)
+    throw 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.',
+      'The complete split candidate inventory requires multiple planning requests.',
+      { data: { fallbackPlan: true } },
     );
-  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;
+  return batches[0];
 }

package/src/main.js

@@ -17,6 +17,8 @@ import {
   runGit,
   isGitRepo,
   getIndexFingerprint,
+  hasHead,
+  readGit,
   createIndexTransaction,
   protectSensitiveDiff,
   unifiedArg,
@@ -29,6 +31,7 @@ import {
   summarizeChanges,
 } from './change-analysis.js';
 import { cleanupGitSpools } from './git-spool.js';
+import { createAnalysisCache } from './analysis-cache.js';
 import { generateCommitMessage } from './api.js';
 import {
   statusColor,
@@ -53,8 +56,13 @@ import {
   applySplitPlan,
   resumeSplit,
   splitFlow,
+  splitStatus,
   getStagedChangedFiles,
+  getAllChangedFiles,
+  getSplitStateFingerprint,
+  safeExportPlanPath,
 } from './split.js';
+import { createSplitPlanArtifact, writeSplitPlanArtifact } from './split-plan.js';
 import { runModelTask } from './generation-ui.js';
 import { runSetup } from './setup.js';
 import { detectProviderType } from './providers.js';
@@ -107,9 +115,13 @@ async function runMain() {
     debug,
     split,
     splitCommand,
+    generate,
+    generateScope,
+    previewScope,
     splitPlanFile,
     dryRun,
     yes,
+    allowSingleFallback,
     setup,
     update,
     doctor,
@@ -128,7 +140,15 @@ async function runMain() {
     return { exitReason: 'completion' };
   }
   const machineOutput = output === 'json';
-  if (machineOutput && !yes && !doctor && !configAction && !policyAction && !update) {
+  if (
+    machineOutput &&
+    !yes &&
+    !doctor &&
+    !configAction &&
+    !policyAction &&
+    !update &&
+    splitCommand !== 'status'
+  ) {
     throw fail(ERROR_CATEGORIES.CONFIG, '--output=json requires --yes for commit and split flows.');
   }
 
@@ -176,13 +196,14 @@ async function runMain() {
   console.log('  ' + chalk.dim('─'.repeat(45)));
   console.log('  ' + chalk.dim(`Working directory: ${sanitizeTerminalText(process.cwd())}`));
 
-  if (['apply', 'resume', 'abort'].includes(splitCommand)) {
+  if (['apply', 'resume', 'abort', 'status'].includes(splitCommand)) {
     const projectRoot = getProjectRoot();
     if (!isGitRepo(projectRoot)) {
       throw fail(ERROR_CATEGORIES.GIT_STATE, `Not a git repository: ${process.cwd()}`);
     }
     if (splitCommand === 'resume') return resumeSplit(projectRoot, { yes, machineOutput });
     if (splitCommand === 'abort') return abortSplit(projectRoot, { yes, machineOutput });
+    if (splitCommand === 'status') return splitStatus(projectRoot);
     return applySplitPlan(projectRoot, splitPlanFile, { yes, machineOutput });
   }
 
@@ -291,6 +312,7 @@ async function runMain() {
     console.log(chalk.dim(`  split:        ${split}`));
     console.log(chalk.dim(`  dryRun:       ${dryRun}`));
     console.log(chalk.dim(`  yes:          ${yes}`));
+    console.log(chalk.dim(`  singleFallback: ${allowSingleFallback}`));
     console.log(chalk.dim('  final config:'));
     for (const [key, value] of Object.entries(config)) {
       const display =
@@ -321,6 +343,7 @@ async function runMain() {
       scope: split,
       dryRun,
       yes,
+      allowSingleFallback,
       machineOutput,
       provider: selectedProvider,
       exportPlanPath: splitCommand === 'plan' ? splitPlanFile : null,
@@ -336,6 +359,35 @@ async function runMain() {
   // All git commands run at the repo root (projectRoot), even when aicommit
   // is invoked from a subdirectory.
   let indexTransaction = null;
+  const effectiveScope = generate ? generateScope : previewScope;
+  let stagedAllForPreview = false;
+  const generateSnapshot = generate
+    ? (() => {
+        const changes =
+          generateScope === 'staged'
+            ? getStagedChangedFiles(projectRoot)
+            : getAllChangedFiles(projectRoot);
+        if (!changes.length) {
+          throw fail(
+            ERROR_CATEGORIES.GIT_STATE,
+            `No ${generateScope} changes to generate a plan for.`,
+          );
+        }
+        return {
+          changes,
+          baseHead: hasHead(projectRoot)
+            ? readGit(['rev-parse', 'HEAD'], projectRoot).trim()
+            : null,
+          fingerprint: getSplitStateFingerprint(
+            projectRoot,
+            hasHead(projectRoot),
+            changes,
+            generateScope,
+          ),
+          file: safeExportPlanPath(projectRoot, splitPlanFile),
+        };
+      })()
+    : null;
   const finishCancelled = ({
     notice = 'Commit cancelled.',
     message = null,
@@ -370,6 +422,20 @@ async function runMain() {
     indexTransaction ||= createIndexTransaction(projectRoot);
     return indexTransaction;
   };
+  if (effectiveScope === 'all') {
+    try {
+      beginIndexTransaction();
+      runGit(['add', '-A'], projectRoot);
+      indexTransaction.markOwned();
+      stagedAllForPreview = true;
+    } catch (err) {
+      indexTransaction?.restore({ force: true });
+      indexTransaction = null;
+      throw fail(ERROR_CATEGORIES.GIT_STATE, `Failed to stage plan snapshot: ${err.message}`, {
+        cause: err,
+      });
+    }
+  }
   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
@@ -386,6 +452,10 @@ async function runMain() {
       throw fail(ERROR_CATEGORIES.GIT_STATE, 'No changes to commit.', { reported: true });
     }
 
+    if (effectiveScope === 'staged' || generate) {
+      throw fail(ERROR_CATEGORIES.GIT_STATE, `No ${effectiveScope} changes to preview.`);
+    }
+
     console.log('\n  ' + chalk.yellow(`✗ No staged changes — ${tips.join(', ')}.`));
     printChangeList(withUntrackedFiles(unstaged, untracked));
     console.log('');
@@ -527,6 +597,13 @@ async function runMain() {
   let diffForModel = diff;
   let protectAnalysis = true;
   if (protectedInput.findings.length) {
+    if (generate && generateScope === 'all' && yes) {
+      throw fail(
+        ERROR_CATEGORIES.SENSITIVE_DATA,
+        'Non-interactive generate --scope=all refuses sensitive content; review and stage intended files explicitly.',
+        { code: 'sensitive_all_scope' },
+      );
+    }
     warnings.push('Sensitive data was detected and protected before the provider request.');
     console.log('\n  ' + chalk.yellow.bold('⚠ Potential sensitive data detected:'));
     for (const finding of protectedInput.findings) {
@@ -567,14 +644,30 @@ async function runMain() {
     : condenseDiff(
         strippedDiff,
         config.maxDiffChars,
-        getDiffStat(projectRoot),
+        () => getDiffStat(projectRoot),
         config.maxFileDiffChars,
       );
   let analysis;
   let analyzedFacts;
+  let persistentAnalysisCache = null;
   let generationConfig = config;
   if (large) {
     generationConfig = analysisConfig(config);
+    persistentAnalysisCache = createAnalysisCache({
+      projectRoot,
+      snapshotFingerprint: plannedIndexFingerprint,
+      config: generationConfig,
+      protect: protectAnalysis,
+    });
+    if (
+      generationConfig.largeChange?.strategy === 'deep' &&
+      generationConfig.largeChange.cache?.enabled &&
+      !protectAnalysis &&
+      !generationConfig.largeChange.cache.allowUnprotected
+    ) {
+      warnings.push('Deep-analysis recovery cache was disabled for unprotected input.');
+      console.log(chalk.dim('  Recovery cache: disabled for unprotected input.'));
+    }
     console.log(
       chalk.dim(
         generationConfig.largeChange?.strategy === 'deep'
@@ -622,8 +715,11 @@ async function runMain() {
               captured,
               protectAnalysis,
               null,
-              ({ completedChunks }) =>
-                console.error(`  Analysis: ${completedChunks} chunks completed`),
+              ({ completedChunks, cachedChunks }) =>
+                console.error(
+                  `  Analysis: ${completedChunks} chunks completed${cachedChunks ? ` (${cachedChunks} cached)` : ''}`,
+                ),
+              persistentAnalysisCache,
             );
             modelDiff =
               analyzedFacts.summary ||
@@ -691,6 +787,8 @@ async function runMain() {
         reported: true,
       });
     }
+    persistentAnalysisCache?.clear();
+    persistentAnalysisCache = null;
 
     // ── 4. User action ─────────────────────────────────────────────────
 
@@ -698,7 +796,7 @@ async function runMain() {
       ? 'use'
       : await confirmAction(
           message,
-          reasoningEnabled
+          reasoningEnabled || reasoningText
             ? {
                 text: reasoningText,
                 maxChars: config.reasoning.maxDisplayChars,
@@ -748,14 +846,51 @@ async function runMain() {
   console.log('');
 
   if (dryRun) {
+    stagedAllForPreview ||= Boolean(indexTransaction);
     const restored = indexTransaction ? indexTransaction.restore() : true;
     indexTransaction = null;
     if (!restored) {
+      if (generate) {
+        throw fail(
+          ERROR_CATEGORIES.CONCURRENT_MODIFICATION,
+          'The Git index changed while generating a commit plan; no plan was written.',
+        );
+      }
       warnings.push('The Git index changed during the run and was left untouched.');
       console.log(
         '  ' + chalk.yellow('⚠ The Git index changed during the run and was left untouched.'),
       );
     }
+    let plan = null;
+    let planFile = null;
+    if (generate) {
+      const fingerprint = getSplitStateFingerprint(
+        projectRoot,
+        hasHead(projectRoot),
+        undefined,
+        generateScope,
+      );
+      const baseHead = hasHead(projectRoot)
+        ? readGit(['rev-parse', 'HEAD'], projectRoot).trim()
+        : null;
+      if (fingerprint !== generateSnapshot.fingerprint || baseHead !== generateSnapshot.baseHead) {
+        throw fail(
+          ERROR_CATEGORIES.CONCURRENT_MODIFICATION,
+          'Repository changes changed while generating a commit plan; no plan was written.',
+        );
+      }
+      plan = [{ message, files: generateSnapshot.changes.map((change) => change.path) }];
+      const artifact = createSplitPlanArtifact({
+        scope: generateScope,
+        baseHead,
+        fingerprint,
+        language: config.language,
+        commitPolicy: config.commitPolicy,
+        changes: generateSnapshot.changes,
+        groups: plan,
+      });
+      planFile = await writeSplitPlanArtifact(generateSnapshot.file, artifact);
+    }
     console.log(
       '  ' +
         chalk.green.bold(
@@ -764,6 +899,10 @@ async function runMain() {
     );
     return {
       message,
+      plan,
+      planFile,
+      scope: effectiveScope || (stagedAllForPreview || indexTransaction ? 'all' : 'staged'),
+      changeCount: generate ? generateSnapshot.changes.length : changedFiles.length,
       provider: selectedProvider,
       model: config.modelId,
       latencyMs: elapsed,
@@ -810,6 +949,9 @@ async function runMain() {
     console.log('\n  ' + chalk.green.bold('✓ Done!\n'));
     return {
       message,
+      commitSha: readGit(['rev-parse', 'HEAD'], projectRoot).trim(),
+      scope: 'staged',
+      changeCount: changedFiles.length,
       provider: selectedProvider,
       model: config.modelId,
       latencyMs: elapsed,

package/src/output.js

@@ -1,6 +1,10 @@
 import { classifyError, EXIT_CODES } from './errors.js';
 
-export const OUTPUT_SCHEMA_VERSION = '1.0';
+export const OUTPUT_SCHEMA_VERSION = '1.1';
+
+function safeString(value) {
+  return typeof value === 'string' && value ? value : null;
+}
 
 function normalizedUsage(usage) {
   if (!usage) return null;
@@ -43,6 +47,11 @@ export function successOutput(result = {}) {
     warnings: Array.isArray(result.warnings) ? result.warnings.map(String) : [],
     exitReason: result.exitReason || 'success',
     committed: Boolean(result.committed),
+    commitState: result.commitState || (result.committed ? 'complete' : 'none'),
+    commitSha: safeString(result.commitSha),
+    planFile: safeString(result.planFile),
+    scope: safeString(result.scope),
+    changeCount: Number.isInteger(result.changeCount) ? result.changeCount : null,
     error: null,
   };
   if (result.data && typeof result.data === 'object' && !Array.isArray(result.data)) {
@@ -64,10 +73,18 @@ export function errorOutput(err) {
     usage: null,
     warnings: [],
     exitReason: classified.category,
-    committed: false,
+    committed: classified.committed,
+    commitState: classified.commitState,
+    commitSha: null,
+    planFile: null,
+    scope: null,
+    changeCount: null,
     error: {
       category: classified.category,
+      code: classified.code,
       message: classified.message,
+      retryable: classified.retryable,
+      nextAction: classified.nextAction,
     },
   };
   if (classified.data && typeof classified.data === 'object' && !Array.isArray(classified.data)) {