happy-stacks 0.6.12 → 0.6.13

package/scripts/review.mjs

@@ -12,16 +12,20 @@ import { createHeadSliceCommits, getChangedOps } from './utils/review/head_slice
 import { runWithConcurrencyLimit } from './utils/proc/parallel.mjs';
 import { runCodeRabbitReview } from './utils/review/runners/coderabbit.mjs';
 import { extractCodexReviewFromJsonl, runCodexReview } from './utils/review/runners/codex.mjs';
+import { detectAugmentAuthError, runAugmentReview } from './utils/review/runners/augment.mjs';
 import { formatTriageMarkdown, parseCodeRabbitPlainOutput, parseCodexReviewText } from './utils/review/findings.mjs';
+import { runSlicedJobs } from './utils/review/sliced_runner.mjs';
+import { seedAugmentHomeFromRealHome, seedCodeRabbitHomeFromRealHome, seedCodexHomeFromRealHome } from './utils/review/tool_home_seed.mjs';
 import { join } from 'node:path';
 import { ensureDir } from './utils/fs/ops.mjs';
 import { copyFile, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { runCapture } from './utils/proc/proc.mjs';
+import { withDetachedWorktree } from './utils/review/detached_worktree.mjs';
 
 const DEFAULT_COMPONENTS = ['happy', 'happy-cli', 'happy-server-light', 'happy-server'];
 const VALID_COMPONENTS = DEFAULT_COMPONENTS;
-const VALID_REVIEWERS = ['coderabbit', 'codex'];
+const VALID_REVIEWERS = ['coderabbit', 'codex', 'augment'];
 const VALID_DEPTHS = ['deep', 'normal'];
 const DEFAULT_REVIEW_MAX_FILES = 50;
 
@@ -42,7 +46,7 @@ function normalizeReviewers(list) {
 function usage() {
   return [
     '[review] usage:',
-    '  happys review [component...] [--reviewers=coderabbit,codex] [--base-remote=<remote>] [--base-branch=<branch>] [--base-ref=<ref>] [--concurrency=N] [--depth=deep|normal] [--chunks|--no-chunks] [--chunking=auto|head-slice|commit-window] [--chunk-max-files=N] [--coderabbit-type=committed|uncommitted|all] [--coderabbit-max-files=N] [--coderabbit-chunks|--no-coderabbit-chunks] [--codex-chunks|--no-codex-chunks] [--run-label=<label>] [--no-stream] [--json]',
+    '  happys review [component...] [--reviewers=coderabbit,codex,augment] [--base-remote=<remote>] [--base-branch=<branch>] [--base-ref=<ref>] [--concurrency=N] [--depth=deep|normal] [--chunks|--no-chunks] [--chunking=auto|head-slice|commit-window] [--chunk-max-files=N] [--coderabbit-type=committed|uncommitted|all] [--coderabbit-max-files=N] [--coderabbit-chunks|--no-coderabbit-chunks] [--codex-chunks|--no-codex-chunks] [--augment-chunks|--no-augment-chunks] [--augment-model=<id>] [--augment-max-turns=N] [--run-label=<label>] [--no-stream] [--json]',
     '',
     'components:',
     `  ${VALID_COMPONENTS.join(' | ')}`,
@@ -90,6 +94,16 @@ function tailLines(text, n) {
   return lines;
 }
 
+function detectCodeRabbitAuthError({ stdout, stderr }) {
+  const combined = `${stdout ?? ''}\n${stderr ?? ''}`;
+  return combined.includes('Authentication required') && combined.includes("coderabbit auth login");
+}
+
+function detectCodexUsageLimit({ stdout, stderr }) {
+  const combined = `${stdout ?? ''}\n${stderr ?? ''}`.toLowerCase();
+  return combined.includes('usage limit') || combined.includes('http 429') || combined.includes('status code: 429');
+}
+
 function printReviewOperatorGuidance() {
   // Guidance for the human/LLM running the review (not the reviewer model itself).
   // eslint-disable-next-line no-console
@@ -153,6 +167,35 @@ function buildCodexDeepPrompt({ component, baseRef }) {
   ].join('\n');
 }
 
+function buildCodexMonorepoDeepPrompt({ baseRef }) {
+  const diffCmd = `cd \"$(git rev-parse --show-toplevel)\" && git diff ${baseRef}...HEAD`;
+  return [
+    'Run a deep, long-form code review on the monorepo.',
+    '',
+    `Base for review: ${baseRef}`,
+    'Scope: full repo',
+    '',
+    'Instructions:',
+    `- Use: ${diffCmd}`,
+    '- You may inspect any file in the repo for cross-references (server/cli/ui).',
+    '- Focus on correctness, edge cases, reliability, performance, and security.',
+    '- Prefer unified/coherent fixes; avoid duplication.',
+    '- Avoid brittle tests that assert on wording/phrasing/config; test real behavior and observable outcomes.',
+    '- Ensure i18n coverage is complete: do not introduce hardcoded user-visible strings; add translation keys across locales as needed.',
+    '- Treat every recommendation as a suggestion: validate it against best practices and this codebase’s existing patterns. Do not propose changes that violate project invariants.',
+    '- Be exhaustive: list all findings you notice, not only the highest-signal ones.',
+    '- Clearly mark any item that is uncertain, has tradeoffs, or needs product/UX decisions as "needs discussion".',
+    '',
+    'Output format:',
+    '- Start with a short overall verdict.',
+    '- Then list findings as bullets with severity (blocker/major/minor/nit) and a concrete fix suggestion.',
+    '',
+    'Machine-readable output (required):',
+    '- After your review, output a JSON array of findings preceded by a line containing exactly: ===FINDINGS_JSON===',
+    '- Each finding should include: severity, file, (optional) lines, title, description, recommendation, needsDiscussion (boolean).',
+  ].join('\n');
+}
+
 function buildCodexMonorepoSlicePrompt({ sliceLabel, baseCommit, baseRef }) {
   const diffCmd = `cd \"$(git rev-parse --show-toplevel)\" && git diff ${baseCommit}...HEAD`;
   return [
@@ -215,32 +258,6 @@ async function listCommitsBetween({ cwd, base, head, env }) {
   return await gitLines({ cwd, env, args: ['rev-list', '--reverse', `${base}..${head}`] });
 }
 
-async function withDetachedWorktree({ repoDir, headCommit, label, env }, fn) {
-  const root = (await runCapture('git', ['rev-parse', '--show-toplevel'], { cwd: repoDir, env })).toString().trim();
-  if (!root) throw new Error('[review] failed to resolve git toplevel');
-
-  const safeLabel = String(label ?? 'worktree')
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  const short = String(headCommit).slice(0, 12);
-  const dir = join(root, '.project', 'review-worktrees', `${safeLabel}-${short}`);
-
-  await ensureDir(join(root, '.project', 'review-worktrees'));
-
-  try {
-    await runCapture('git', ['worktree', 'add', '--detach', dir, headCommit], { cwd: repoDir, env });
-    return await fn(dir);
-  } finally {
-    try {
-      await runCapture('git', ['worktree', 'remove', '--force', dir], { cwd: repoDir, env });
-      await runCapture('git', ['worktree', 'prune'], { cwd: repoDir, env });
-    } catch {
-      // best-effort cleanup; leave an orphaned worktree if needed
-    }
-  }
-}
-
 async function pickCoderabbitBaseCommitForMaxFiles({ cwd, baseRef, maxFiles, env }) {
   const commits = await gitLines({ cwd, env, args: ['rev-list', '--reverse', `${baseRef}..HEAD`] });
   if (!commits.length) return null;
@@ -297,6 +314,7 @@ async function main() {
     git: true,
     coderabbit: reviewers.includes('coderabbit'),
     codex: reviewers.includes('codex'),
+    augment: reviewers.includes('augment'),
   });
 
   const inferred = positionals.length === 0 ? resolveComponentFromCwdOrNull({ rootDir, invokedCwd }) : null;
@@ -336,6 +354,8 @@ async function main() {
   const depth = (kv.get('--depth') ?? 'deep').toString().trim().toLowerCase();
   const coderabbitType = (kv.get('--coderabbit-type') ?? 'committed').toString().trim().toLowerCase();
   const chunkingMode = (kv.get('--chunking') ?? 'auto').toString().trim().toLowerCase();
+  const augmentModelFlag = (kv.get('--augment-model') ?? '').toString().trim();
+  const augmentMaxTurnsFlag = (kv.get('--augment-max-turns') ?? '').toString().trim();
   const chunkMaxFilesRaw = (kv.get('--chunk-max-files') ?? '').toString().trim();
   const coderabbitMaxFilesRaw = (kv.get('--coderabbit-max-files') ?? '').toString().trim();
   const coderabbitMaxFiles = coderabbitMaxFilesRaw ? Number(coderabbitMaxFilesRaw) : DEFAULT_REVIEW_MAX_FILES;
@@ -347,6 +367,7 @@ async function main() {
       ? false
       : null;
   const codexChunksOverride = flags.has('--codex-chunks') ? true : flags.has('--no-codex-chunks') ? false : null;
+  const augmentChunksOverride = flags.has('--augment-chunks') ? true : flags.has('--no-augment-chunks') ? false : null;
   if (!VALID_DEPTHS.includes(depth)) {
     throw new Error(`[review] invalid --depth=${depth} (expected: ${VALID_DEPTHS.join(' | ')})`);
   }
@@ -354,6 +375,9 @@ async function main() {
     throw new Error('[review] invalid --chunking (expected: auto|head-slice|commit-window)');
   }
 
+  if (augmentModelFlag) process.env.HAPPY_STACKS_AUGMENT_MODEL = augmentModelFlag;
+  if (augmentMaxTurnsFlag) process.env.HAPPY_STACKS_AUGMENT_MAX_TURNS = augmentMaxTurnsFlag;
+
   const deepInstructionsPath = join(rootDir, 'scripts', 'utils', 'review', 'instructions', 'deep.md');
   const coderabbitConfigFiles = depth === 'deep' ? [deepInstructionsPath] : [];
 
@@ -363,6 +387,18 @@ async function main() {
       process.env[coderabbitHomeKey] = join(rootDir, '.project', 'coderabbit-home');
     }
     await ensureDir(process.env[coderabbitHomeKey]);
+
+    // Seed CodeRabbit auth/config into the isolated home dir so review runs can be non-interactive.
+    // We never print or inspect auth contents.
+    try {
+      const realHome = (process.env.HOME ?? '').toString().trim();
+      const overrideHome = (process.env[coderabbitHomeKey] ?? '').toString().trim();
+      if (realHome && overrideHome && realHome !== overrideHome) {
+        await seedCodeRabbitHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: overrideHome });
+      }
+    } catch {
+      // ignore (coderabbit will surface auth issues if seeding fails)
+    }
   }
 
   if (reviewers.includes('codex')) {
@@ -382,18 +418,33 @@ async function main() {
       const realHome = (process.env.HOME ?? '').toString().trim();
       const overrideHome = process.env[codexHomeKey];
       if (realHome && overrideHome && realHome !== overrideHome) {
-        const srcAuth = join(realHome, '.codex', 'auth.json');
-        const srcCfg = join(realHome, '.codex', 'config.toml');
-        const destAuth = join(overrideHome, 'auth.json');
-        const destCfg = join(overrideHome, 'config.toml');
-        if (existsSync(srcAuth) && !existsSync(destAuth)) await copyFile(srcAuth, destAuth);
-        if (existsSync(srcCfg) && !existsSync(destCfg)) await copyFile(srcCfg, destCfg);
+        await seedCodexHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: overrideHome });
       }
     } catch {
       // ignore (codex will surface auth issues if seeding fails)
     }
   }
 
+  if (reviewers.includes('augment')) {
+    const augmentHomeKey = 'HAPPY_STACKS_AUGMENT_CACHE_DIR';
+    if (!(process.env[augmentHomeKey] ?? '').toString().trim()) {
+      process.env[augmentHomeKey] = join(rootDir, '.project', 'augment-home');
+    }
+    await ensureDir(process.env[augmentHomeKey]);
+
+    // Seed Auggie auth/config into the isolated cache dir so review runs can be non-interactive.
+    // We never print or inspect auth contents.
+    try {
+      const realHome = (process.env.HOME ?? '').toString().trim();
+      const overrideHome = process.env[augmentHomeKey];
+      if (realHome && overrideHome && realHome !== overrideHome) {
+        await seedAugmentHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: overrideHome });
+      }
+    } catch {
+      // ignore (auggie will surface auth issues if seeding fails)
+    }
+  }
+
   if (stream) {
     // eslint-disable-next-line no-console
     console.log('[review] note: this can take a long time (up to 60+ minutes per reviewer). No timeout is enforced.');
@@ -445,13 +496,17 @@ async function main() {
       });
 
       const maxFiles = Number.isFinite(chunkMaxFiles) && chunkMaxFiles > 0 ? chunkMaxFiles : 300;
+      const sliceConcurrency = Math.max(1, Math.floor(limit / Math.max(1, reviewers.length)));
       const wantChunksCoderabbit = coderabbitChunksOverride ?? globalChunks;
       const wantChunksCodex = codexChunksOverride ?? globalChunks;
+      const wantChunksAugment = augmentChunksOverride ?? globalChunks;
       const effectiveChunking = chunkingMode === 'auto' ? (monorepo ? 'head-slice' : 'commit-window') : chunkingMode;
 
       if (monorepo && stream) {
         // eslint-disable-next-line no-console
-        console.log(`[review] monorepo detected at ${repoDir}; running a single unified review (chunking=${effectiveChunking}).`);
+        console.log(
+          `[review] monorepo detected at ${repoDir}; running a single unified review (chunking=${effectiveChunking}, concurrency=${sliceConcurrency}).`
+        );
       }
 
       const perReviewer = await Promise.all(
@@ -470,49 +525,58 @@ async function main() {
               const ops = await getChangedOps({ cwd: repoDir, baseRef: baseCommit, headRef: headCommit, env: process.env });
               const slices = planPathSlices({ changedPaths: Array.from(ops.all), maxFiles });
 
-              const sliceResults = [];
-              for (let i = 0; i < slices.length; i += 1) {
-                const slice = slices[i];
-                const logFile = join(runDir, 'raw', `coderabbit-slice-${i + 1}-of-${slices.length}-${sanitizeLabel(slice.label)}.log`);
-                // eslint-disable-next-line no-await-in-loop
-                const rr = await withDetachedWorktree(
-                  { repoDir, headCommit: baseCommit, label: `coderabbit-${i + 1}-of-${slices.length}`, env: process.env },
-                  async (worktreeDir) => {
-                    const { baseSliceCommit } = await createHeadSliceCommits({
-                      cwd: worktreeDir,
-                      env: process.env,
-                      baseRef: baseCommit,
-                      headCommit,
-                      ops,
-                      slicePaths: slice.paths,
-                      label: slice.label.replace(/\/+$/g, ''),
-                    });
-                    return await runCodeRabbitReview({
-                      repoDir: worktreeDir,
-                      baseRef: null,
-                      baseCommit: baseSliceCommit,
-                      env: process.env,
-                      type: coderabbitType,
-                      configFiles: coderabbitConfigFiles,
-                      streamLabel: stream ? `monorepo:coderabbit:${i + 1}/${slices.length}` : undefined,
-                      teeFile: logFile,
-                      teeLabel: `monorepo:coderabbit:${i + 1}/${slices.length}`,
-                    });
-                  }
-                );
-                sliceResults.push({
-                  index: i + 1,
-                  of: slices.length,
-                  slice: slice.label,
-                  fileCount: slice.paths.length,
-                  logFile,
-                  ok: Boolean(rr.ok),
-                  exitCode: rr.exitCode,
-                  signal: rr.signal,
-                  durationMs: rr.durationMs,
-                  stdout: rr.stdout ?? '',
-                  stderr: rr.stderr ?? '',
-                });
+              const sliceItems = slices.map((slice, i) => ({ slice, index: i + 1, of: slices.length }));
+              const sliceResults = await runSlicedJobs({
+                items: sliceItems,
+                limit: sliceConcurrency,
+                run: async ({ slice, index, of }) => {
+                  const logFile = join(runDir, 'raw', `coderabbit-slice-${index}-of-${of}-${sanitizeLabel(slice.label)}.log`);
+                  const rr = await withDetachedWorktree(
+                    { repoDir, headCommit: baseCommit, label: `coderabbit-${index}-of-${of}`, env: process.env },
+                    async (worktreeDir) => {
+                      const { baseSliceCommit } = await createHeadSliceCommits({
+                        cwd: worktreeDir,
+                        env: process.env,
+                        baseRef: baseCommit,
+                        headCommit,
+                        ops,
+                        slicePaths: slice.paths,
+                        label: slice.label.replace(/\/+$/g, ''),
+                      });
+                      return await runCodeRabbitReview({
+                        repoDir: worktreeDir,
+                        baseRef: null,
+                        baseCommit: baseSliceCommit,
+                        env: process.env,
+                        type: coderabbitType,
+                        configFiles: coderabbitConfigFiles,
+                        streamLabel: stream ? `monorepo:coderabbit:${index}/${of}` : undefined,
+                        teeFile: logFile,
+                        teeLabel: `monorepo:coderabbit:${index}/${of}`,
+                      });
+                    }
+                  );
+                  return {
+                    index,
+                    of,
+                    slice: slice.label,
+                    fileCount: slice.paths.length,
+                    logFile,
+                    ok: Boolean(rr.ok),
+                    exitCode: rr.exitCode,
+                    signal: rr.signal,
+                    durationMs: rr.durationMs,
+                    stdout: rr.stdout ?? '',
+                    stderr: rr.stderr ?? '',
+                  };
+                },
+                shouldAbortEarly: (r) => detectCodeRabbitAuthError({ stdout: r?.stdout, stderr: r?.stderr }),
+              });
+
+              if (sliceResults.length === 1 && detectCodeRabbitAuthError(sliceResults[0])) {
+                const msg = `[review] coderabbit auth required: run 'coderabbit auth login' in an interactive session, then re-run this review.`;
+                // eslint-disable-next-line no-console
+                console.error(msg);
               }
 
               const okAll = sliceResults.every((r) => r.ok);
@@ -658,51 +722,64 @@ async function main() {
               const ops = await getChangedOps({ cwd: repoDir, baseRef: baseCommit, headRef: headCommit, env: process.env });
               const slices = planPathSlices({ changedPaths: Array.from(ops.all), maxFiles });
 
-              const sliceResults = [];
-              for (let i = 0; i < slices.length; i += 1) {
-                const slice = slices[i];
-                const logFile = join(runDir, 'raw', `codex-slice-${i + 1}-of-${slices.length}-${sanitizeLabel(slice.label)}.log`);
-                // eslint-disable-next-line no-await-in-loop
-                const rr = await withDetachedWorktree(
-                  { repoDir, headCommit: baseCommit, label: `codex-${i + 1}-of-${slices.length}`, env: process.env },
-                  async (worktreeDir) => {
-                    const { baseSliceCommit } = await createHeadSliceCommits({
-                      cwd: worktreeDir,
-                      env: process.env,
-                      baseRef: baseCommit,
-                      headCommit,
-                      ops,
-                      slicePaths: slice.paths,
-                      label: slice.label.replace(/\/+$/g, ''),
-                    });
-                    const prompt = buildCodexMonorepoSlicePrompt({ sliceLabel: slice.label, baseCommit: baseSliceCommit, baseRef: base.baseRef });
-                    return await runCodexReview({
-                      repoDir: worktreeDir,
-                      baseRef: null,
-                      env: process.env,
-                      jsonMode,
-                      prompt,
-                      streamLabel: stream && !jsonMode ? `monorepo:codex:${i + 1}/${slices.length}` : undefined,
-                      teeFile: logFile,
-                      teeLabel: `monorepo:codex:${i + 1}/${slices.length}`,
-                    });
-                  }
-                );
-                const extracted = jsonMode ? extractCodexReviewFromJsonl(rr.stdout ?? '') : null;
-                sliceResults.push({
-                  index: i + 1,
-                  of: slices.length,
-                  slice: slice.label,
-                  fileCount: slice.paths.length,
-                  logFile,
-                  ok: Boolean(rr.ok),
-                  exitCode: rr.exitCode,
-                  signal: rr.signal,
-                  durationMs: rr.durationMs,
-                  stdout: rr.stdout ?? '',
-                  stderr: rr.stderr ?? '',
-                  review_output: extracted,
-                });
+              const sliceItems = slices.map((slice, i) => ({ slice, index: i + 1, of: slices.length }));
+              const sliceResults = await runSlicedJobs({
+                items: sliceItems,
+                limit: sliceConcurrency,
+                run: async ({ slice, index, of }) => {
+                  const logFile = join(runDir, 'raw', `codex-slice-${index}-of-${of}-${sanitizeLabel(slice.label)}.log`);
+                  const rr = await withDetachedWorktree(
+                    { repoDir, headCommit: baseCommit, label: `codex-${index}-of-${of}`, env: process.env },
+                    async (worktreeDir) => {
+                      const { baseSliceCommit } = await createHeadSliceCommits({
+                        cwd: worktreeDir,
+                        env: process.env,
+                        baseRef: baseCommit,
+                        headCommit,
+                        ops,
+                        slicePaths: slice.paths,
+                        label: slice.label.replace(/\/+$/g, ''),
+                      });
+                      const prompt = buildCodexMonorepoSlicePrompt({
+                        sliceLabel: slice.label,
+                        baseCommit: baseSliceCommit,
+                        baseRef: base.baseRef,
+                      });
+                      return await runCodexReview({
+                        repoDir: worktreeDir,
+                        baseRef: null,
+                        env: process.env,
+                        jsonMode,
+                        prompt,
+                        streamLabel: stream && !jsonMode ? `monorepo:codex:${index}/${of}` : undefined,
+                        teeFile: logFile,
+                        teeLabel: `monorepo:codex:${index}/${of}`,
+                      });
+                    }
+                  );
+                  const extracted = jsonMode ? extractCodexReviewFromJsonl(rr.stdout ?? '') : null;
+                  return {
+                    index,
+                    of,
+                    slice: slice.label,
+                    fileCount: slice.paths.length,
+                    logFile,
+                    ok: Boolean(rr.ok),
+                    exitCode: rr.exitCode,
+                    signal: rr.signal,
+                    durationMs: rr.durationMs,
+                    stdout: rr.stdout ?? '',
+                    stderr: rr.stderr ?? '',
+                    review_output: extracted,
+                  };
+                },
+                shouldAbortEarly: (r) => detectCodexUsageLimit({ stdout: r?.stdout, stderr: r?.stderr }),
+              });
+
+              if (sliceResults.length === 1 && detectCodexUsageLimit(sliceResults[0])) {
+                const msg = `[review] codex usage limit detected; resolve Codex credits/limits, then re-run this review.`;
+                // eslint-disable-next-line no-console
+                console.error(msg);
               }
 
               const okAll = sliceResults.every((r) => r.ok);
@@ -719,7 +796,11 @@ async function main() {
               };
             }
 
-            const prompt = usePromptMode ? buildCodexDeepPrompt({ component, baseRef: base.baseRef }) : '';
+            const prompt = usePromptMode
+              ? monorepo
+                ? buildCodexMonorepoDeepPrompt({ baseRef: base.baseRef })
+                : buildCodexDeepPrompt({ component, baseRef: base.baseRef })
+              : '';
             const logFile = join(runDir, 'raw', `codex-${sanitizeLabel(component)}.log`);
             const res = await runCodexReview({
               repoDir,
@@ -744,6 +825,122 @@ async function main() {
               logFile,
             };
           }
+          if (reviewer === 'augment') {
+            const usePromptMode = depth === 'deep';
+            const fileCount = await countChangedFiles({ cwd: repoDir, env: process.env, base: base.baseRef });
+            const autoChunks = usePromptMode && fileCount > maxFiles;
+            const cacheDir = (process.env.HAPPY_STACKS_AUGMENT_CACHE_DIR ?? '').toString().trim();
+            const model = (process.env.HAPPY_STACKS_AUGMENT_MODEL ?? '').toString().trim();
+            const maxTurnsRaw = (process.env.HAPPY_STACKS_AUGMENT_MAX_TURNS ?? '').toString().trim();
+            const maxTurns = maxTurnsRaw ? Number(maxTurnsRaw) : null;
+
+            if (monorepo && effectiveChunking === 'head-slice' && usePromptMode && (wantChunksAugment ?? autoChunks)) {
+              const headCommit = (await runCapture('git', ['rev-parse', 'HEAD'], { cwd: repoDir, env: process.env })).trim();
+              const baseCommit = (await runCapture('git', ['rev-parse', base.baseRef], { cwd: repoDir, env: process.env })).trim();
+              const ops = await getChangedOps({ cwd: repoDir, baseRef: baseCommit, headRef: headCommit, env: process.env });
+              const slices = planPathSlices({ changedPaths: Array.from(ops.all), maxFiles });
+
+              const sliceItems = slices.map((slice, i) => ({ slice, index: i + 1, of: slices.length }));
+              const sliceResults = await runSlicedJobs({
+                items: sliceItems,
+                limit: sliceConcurrency,
+                run: async ({ slice, index, of }) => {
+                  const logFile = join(runDir, 'raw', `augment-slice-${index}-of-${of}-${sanitizeLabel(slice.label)}.log`);
+                  const rr = await withDetachedWorktree(
+                    { repoDir, headCommit: baseCommit, label: `augment-${index}-of-${of}`, env: process.env },
+                    async (worktreeDir) => {
+                      const { baseSliceCommit } = await createHeadSliceCommits({
+                        cwd: worktreeDir,
+                        env: process.env,
+                        baseRef: baseCommit,
+                        headCommit,
+                        ops,
+                        slicePaths: slice.paths,
+                        label: slice.label.replace(/\/+$/g, ''),
+                      });
+                      const prompt = buildCodexMonorepoSlicePrompt({
+                        sliceLabel: slice.label,
+                        baseCommit: baseSliceCommit,
+                        baseRef: base.baseRef,
+                      });
+                      return await runAugmentReview({
+                        repoDir: worktreeDir,
+                        prompt,
+                        env: process.env,
+                        cacheDir,
+                        model,
+                        maxTurns: Number.isFinite(maxTurns) ? String(maxTurns) : undefined,
+                        streamLabel: stream ? `monorepo:augment:${index}/${of}` : undefined,
+                        teeFile: logFile,
+                        teeLabel: `monorepo:augment:${index}/${of}`,
+                      });
+                    }
+                  );
+                  return {
+                    index,
+                    of,
+                    slice: slice.label,
+                    fileCount: slice.paths.length,
+                    logFile,
+                    ok: Boolean(rr.ok),
+                    exitCode: rr.exitCode,
+                    signal: rr.signal,
+                    durationMs: rr.durationMs,
+                    stdout: rr.stdout ?? '',
+                    stderr: rr.stderr ?? '',
+                  };
+                },
+                shouldAbortEarly: (r) => detectAugmentAuthError({ stdout: r?.stdout, stderr: r?.stderr }),
+              });
+
+              if (sliceResults.length === 1 && detectAugmentAuthError(sliceResults[0])) {
+                const msg = `[review] augment auth required: run 'auggie login' in an interactive session, then re-run this review.`;
+                // eslint-disable-next-line no-console
+                console.error(msg);
+              }
+
+              const okAll = sliceResults.every((r) => r.ok);
+              return {
+                reviewer,
+                ok: okAll,
+                exitCode: okAll ? 0 : 1,
+                signal: null,
+                durationMs: sliceResults.reduce((acc, r) => acc + (r.durationMs ?? 0), 0),
+                stdout: '',
+                stderr: '',
+                note: `monorepo head-slice: ${sliceResults.length} slices (maxFiles=${maxFiles})`,
+                slices: sliceResults,
+              };
+            }
+
+            const prompt = usePromptMode
+              ? monorepo
+                ? buildCodexMonorepoDeepPrompt({ baseRef: base.baseRef })
+                : buildCodexDeepPrompt({ component, baseRef: base.baseRef })
+              : '';
+            const logFile = join(runDir, 'raw', `augment-${sanitizeLabel(component)}.log`);
+            const res = await runAugmentReview({
+              repoDir,
+              prompt,
+              env: process.env,
+              cacheDir,
+              model,
+              maxTurns: Number.isFinite(maxTurns) ? String(maxTurns) : undefined,
+              streamLabel: stream ? `${component}:augment` : undefined,
+              teeFile: logFile,
+              teeLabel: `${component}:augment`,
+            });
+            return {
+              reviewer,
+              ok: Boolean(res.ok),
+              exitCode: res.exitCode,
+              signal: res.signal,
+              durationMs: res.durationMs,
+              stdout: res.stdout ?? '',
+              stderr: res.stderr ?? '',
+              logFile,
+            };
+          }
           return { reviewer, ok: false, exitCode: null, signal: null, durationMs: 0, stdout: '', stderr: 'unknown reviewer\n' };
         })
       );
@@ -771,6 +968,7 @@ async function main() {
     const allFindings = [];
     let cr = 0;
     let cx = 0;
+    let au = 0;
 
     for (const job of jobResults) {
       for (const rr of job.results) {
@@ -831,6 +1029,31 @@ async function main() {
             consumeText(reviewText, null, rr.logFile ?? null);
           }
         }
+
+        if (rr.reviewer === 'augment') {
+          const sliceLike = rr.slices ?? rr.chunks ?? null;
+          const consumeText = (reviewText, slice, sourceLog) => {
+            const parsed = parseCodexReviewText(reviewText).map((f) => ({ ...f, reviewer: 'augment' }));
+            for (const f of parsed) {
+              au += 1;
+              allFindings.push({
+                ...f,
+                id: `AU-${String(au).padStart(3, '0')}`,
+                job: job.component,
+                slice,
+                sourceLog: sourceLog ?? null,
+              });
+            }
+          };
+
+          if (Array.isArray(sliceLike)) {
+            for (const s of sliceLike) {
+              consumeText(s.stdout ?? '', s.slice ?? `${s.index}/${s.of}`, s.logFile ?? null);
+            }
+          } else {
+            consumeText(rr.stdout ?? '', null, rr.logFile ?? null);
+          }
+        }
       }
     }