@happier-dev/stack 0.1.0-preview.5.1

package/scripts/utils/review/runners/augment.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { buildAugmentReviewArgs, detectAugmentAuthError } from './augment.mjs';
+
+test('detectAugmentAuthError matches 401 login guidance', () => {
+  const stdout = "❌ Authentication failed: HTTP error: 401 Unauthorized\n   Run 'auggie login' to authenticate first.";
+  assert.equal(detectAugmentAuthError({ stdout, stderr: '' }), true);
+});
+
+test('detectAugmentAuthError returns false when required markers are incomplete', () => {
+  assert.equal(detectAugmentAuthError({ stdout: 'Authentication failed', stderr: '' }), false);
+  assert.equal(detectAugmentAuthError({ stdout: "Run 'auggie login' to authenticate first.", stderr: '' }), false);
+});
+
+test('buildAugmentReviewArgs builds auggie --print args with optional settings', () => {
+  const args = buildAugmentReviewArgs({
+    prompt: 'Review the code',
+    workspaceRoot: '/repo',
+    cacheDir: '/cache',
+    model: 'gpt-5.2',
+    rulesFiles: ['/rules/a.md', '/rules/b.md'],
+    retryTimeoutSec: 123,
+    maxTurns: 9,
+  });
+
+  assert.equal(args[0], '--print');
+  assert.ok(args.includes('--quiet'));
+  assert.ok(args.includes('--dont-save-session'));
+  assert.ok(args.includes('--ask'));
+  assert.ok(args.includes('--workspace-root'));
+  assert.ok(args.includes('/repo'));
+  assert.ok(args.includes('--augment-cache-dir'));
+  assert.ok(args.includes('/cache'));
+  assert.ok(args.includes('--model'));
+  assert.ok(args.includes('gpt-5.2'));
+  assert.ok(args.includes('--retry-timeout'));
+  assert.ok(args.includes('123'));
+  assert.ok(args.includes('--max-turns'));
+  assert.ok(args.includes('9'));
+
+  const joined = args.join(' ');
+  assert.match(joined, /--rules \/rules\/a\.md/);
+  assert.match(joined, /--rules \/rules\/b\.md/);
+  assert.equal(args.at(-1), 'Review the code');
+});
+
+test('buildAugmentReviewArgs keeps required args and ignores blank option values', () => {
+  const args = buildAugmentReviewArgs({
+    prompt: 'Review now',
+    workspaceRoot: '   ',
+    cacheDir: '',
+    model: null,
+    rulesFiles: 'not-an-array',
+    retryTimeoutSec: undefined,
+    maxTurns: '',
+  });
+
+  assert.deepEqual(args, ['--print', '--quiet', '--dont-save-session', '--ask', '--output-format', 'text', 'Review now']);
+});
+
+test('buildAugmentReviewArgs requires a non-empty prompt', () => {
+  assert.throws(() => buildAugmentReviewArgs({ prompt: '   ' }), /missing prompt/);
+});

package/scripts/utils/review/runners/claude.mjs

@@ -0,0 +1,92 @@
+import { runCaptureResult } from '../../proc/proc.mjs';
+
+export function detectClaudeAuthError({ stdout, stderr }) {
+  const combined = `${stdout ?? ''}\n${stderr ?? ''}`.toLowerCase();
+  const hasAuthHint =
+    combined.includes('authentication required') ||
+    combined.includes('authentication failed') ||
+    combined.includes('invalid api key') ||
+    combined.includes('permission denied') ||
+    combined.includes('claude auth login') ||
+    combined.includes('claude login');
+  const hasRateLimitHint =
+    combined.includes('status code: 429') ||
+    combined.includes('http 429') ||
+    combined.includes('429 too many requests') ||
+    combined.includes('rate_limit_exceeded') ||
+    combined.includes('ratelimiterror');
+  return hasAuthHint || hasRateLimitHint;
+}
+
+const DEFAULT_ALLOWED_TOOLS = [
+  'Bash(git:*)',
+  'Bash(rg:*)',
+  'Bash(cat:*)',
+  'Bash(sed:*)',
+  'Bash(ls:*)',
+  'Bash(wc:*)',
+  'Bash(head:*)',
+  'Bash(tail:*)',
+].join(',');
+
+function parsePositiveInt(raw) {
+  const n = Number(String(raw ?? '').trim());
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+
+function resolveClaudeKeepaliveMs(env) {
+  const specific = parsePositiveInt(env?.HAPPIER_STACK_REVIEW_CLAUDE_KEEPALIVE_MS);
+  if (specific !== null) return specific;
+  const global = parsePositiveInt(env?.HAPPIER_STACK_REVIEW_KEEPALIVE_MS);
+  if (global !== null) return global;
+  return 30_000;
+}
+
+export function buildClaudeReviewArgs({ model, allowedTools } = {}) {
+  const args = [
+    '--print',
+    '--input-format',
+    'text',
+    '--output-format',
+    'text',
+    '--no-session-persistence',
+    '--disable-slash-commands',
+    '--permission-mode',
+    'bypassPermissions',
+  ];
+
+  const m = String(model ?? '').trim();
+  if (m) args.push('--model', m);
+
+  const tools =
+    allowedTools === undefined ? DEFAULT_ALLOWED_TOOLS : String(allowedTools ?? '').trim();
+  if (tools) args.push('--allowed-tools', tools);
+  return args;
+}
+
+export async function runClaudeReview({
+  repoDir,
+  prompt,
+  env,
+  streamLabel,
+  teeFile,
+  teeLabel,
+  model,
+  allowedTools = DEFAULT_ALLOWED_TOOLS,
+} = {}) {
+  const p = String(prompt ?? '').trim();
+  if (!p) throw new Error('[review] claude: missing prompt');
+
+  const args = buildClaudeReviewArgs({ model, allowedTools });
+  const heartbeatMs = resolveClaudeKeepaliveMs(env ?? {});
+  const res = await runCaptureResult('claude', args, {
+    cwd: repoDir,
+    env: env ?? {},
+    streamLabel,
+    teeFile,
+    teeLabel,
+    input: p,
+    heartbeatMs,
+  });
+  return { ...res, stdout: res.out, stderr: res.err };
+}

package/scripts/utils/review/runners/claude.test.mjs

@@ -0,0 +1,47 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { buildClaudeReviewArgs, detectClaudeAuthError } from './claude.mjs';
+
+test('buildClaudeReviewArgs includes non-interactive flags', () => {
+  const args = buildClaudeReviewArgs();
+  assert.deepEqual(args, [
+    '--print',
+    '--input-format',
+    'text',
+    '--output-format',
+    'text',
+    '--no-session-persistence',
+    '--disable-slash-commands',
+    '--permission-mode',
+    'bypassPermissions',
+    '--allowed-tools',
+    'Bash(git:*),Bash(rg:*),Bash(cat:*),Bash(sed:*),Bash(ls:*),Bash(wc:*),Bash(head:*),Bash(tail:*)',
+  ]);
+});
+
+test('buildClaudeReviewArgs includes --model when provided', () => {
+  const args = buildClaudeReviewArgs({ model: 'opus' });
+  assert.equal(args.includes('--model'), true);
+  const idx = args.indexOf('--model');
+  assert.equal(args[idx + 1], 'opus');
+});
+
+test('detectClaudeAuthError matches login/auth failures', () => {
+  const stdout = 'Authentication required. Run `claude login` to continue.';
+  assert.equal(detectClaudeAuthError({ stdout, stderr: '' }), true);
+});
+
+test('detectClaudeAuthError matches rate-limit failures', () => {
+  const stderr = 'HTTP 429: rate limit exceeded';
+  assert.equal(detectClaudeAuthError({ stdout: '', stderr }), true);
+});
+
+test('detectClaudeAuthError returns false for normal output', () => {
+  assert.equal(detectClaudeAuthError({ stdout: 'Review completed', stderr: '' }), false);
+});
+
+test('detectClaudeAuthError does not treat reviewer prose as a runtime rate-limit failure', () => {
+  const stdout = 'If gh release upload fails due to a transient network issue or rate limit, the job fails.';
+  assert.equal(detectClaudeAuthError({ stdout, stderr: '' }), false);
+});

package/scripts/utils/review/runners/coderabbit.mjs

@@ -0,0 +1,105 @@
+import { runCaptureResult } from '../../proc/proc.mjs';
+import { join } from 'node:path';
+import { appendFile } from 'node:fs/promises';
+
+function normalizeType(raw) {
+  const t = String(raw ?? '').trim().toLowerCase();
+  if (!t) return 'committed';
+  if (t === 'all' || t === 'committed' || t === 'uncommitted') return t;
+  throw new Error(`[review] invalid coderabbit type: ${raw} (expected: all|committed|uncommitted)`);
+}
+
+export function parseCodeRabbitRateLimitRetryMs(text) {
+  const s = String(text ?? '');
+  const m = s.match(/Rate limit exceeded,\s*please try after\s+(\d+)\s+minutes?\s+and\s+(\d+)\s+seconds?/i);
+  if (!m) return null;
+  const minutes = Number(m[1]);
+  const seconds = Number(m[2]);
+  if (!Number.isFinite(minutes) || minutes < 0) return null;
+  if (!Number.isFinite(seconds) || seconds < 0) return null;
+  // Add +1s padding to avoid retrying too early.
+  const totalSeconds = minutes * 60 + seconds + 1;
+  return Math.max(1000, totalSeconds * 1000);
+}
+
+export function buildCodeRabbitReviewArgs({ repoDir, baseRef, baseCommit, type, configFiles }) {
+  const args = ['review', '--plain', '--no-color', '--type', normalizeType(type), '--cwd', repoDir];
+  const base = String(baseRef ?? '').trim();
+  const bc = String(baseCommit ?? '').trim();
+  if (base && bc) {
+    throw new Error('[review] coderabbit: baseRef and baseCommit are mutually exclusive');
+  }
+  if (base) args.push('--base', base);
+  if (bc) args.push('--base-commit', bc);
+  const files = Array.isArray(configFiles) ? configFiles.filter(Boolean) : [];
+  if (files.length) args.push('--config', ...files);
+  return args;
+}
+
+export function buildCodeRabbitEnv({ env, homeDir }) {
+  const merged = { ...(env ?? {}) };
+  const dir = String(homeDir ?? '').trim();
+  if (!dir) return merged;
+
+  // IMPORTANT:
+  // Do not override HOME/USERPROFILE here.
+  //
+  // CodeRabbit uses OS credential storage (e.g. macOS Keychain). If HOME is pointed at
+  // an isolated directory (like .project/coderabbit-home), the underlying keychain
+  // lookup can fail with "Keychain Not Found" and auth will not work in the wrapper.
+  //
+  // We still isolate CodeRabbit's on-disk config/cache under the provided homeDir via
+  // CODERABBIT_HOME + XDG dirs.
+  merged.CODERABBIT_HOME = join(dir, '.coderabbit');
+  merged.XDG_CONFIG_HOME = join(dir, '.config');
+  merged.XDG_CACHE_HOME = join(dir, '.cache');
+  merged.XDG_STATE_HOME = join(dir, '.local', 'state');
+  merged.XDG_DATA_HOME = join(dir, '.local', 'share');
+  return merged;
+}
+
+export async function runCodeRabbitReview({
+  repoDir,
+  baseRef,
+  baseCommit,
+  env,
+  type = 'committed',
+  configFiles = [],
+  streamLabel,
+  teeFile,
+  teeLabel,
+}) {
+  const homeDir = (env?.HAPPIER_STACK_CODERABBIT_HOME_DIR ?? '').toString().trim();
+  const args = buildCodeRabbitReviewArgs({ repoDir, baseRef, baseCommit, type, configFiles });
+  const maxAttempts = 50;
+  let last = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    // eslint-disable-next-line no-await-in-loop
+    const res = await runCaptureResult('coderabbit', args, {
+      cwd: repoDir,
+      env: buildCodeRabbitEnv({ env, homeDir }),
+      streamLabel,
+      teeFile,
+      teeLabel,
+    });
+    last = res;
+    if (res.ok) return { ...res, stdout: res.out, stderr: res.err };
+
+    const retryMs = parseCodeRabbitRateLimitRetryMs(`${res.out ?? ''}\n${res.err ?? ''}`);
+    if (!retryMs) return { ...res, stdout: res.out, stderr: res.err };
+
+    const seconds = Math.ceil(retryMs / 1000);
+    const msg = `[review] coderabbit rate limited; retrying in ${seconds}s (attempt ${attempt}/${maxAttempts})\n`;
+    try {
+      if (teeFile) await appendFile(teeFile, msg);
+    } catch {
+      // ignore
+    }
+    // eslint-disable-next-line no-console
+    console.warn(msg.trimEnd());
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, retryMs));
+  }
+
+  return { ...last, stdout: last?.out ?? '', stderr: last?.err ?? '' };
+}

package/scripts/utils/review/runners/coderabbit.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { parseCodeRabbitRateLimitRetryMs } from './coderabbit.mjs';
+
+test('parseCodeRabbitRateLimitRetryMs returns null when no rate limit message is present', () => {
+  assert.equal(parseCodeRabbitRateLimitRetryMs('Review completed ✔'), null);
+});
+
+test('parseCodeRabbitRateLimitRetryMs parses the suggested retry delay', () => {
+  const ms = parseCodeRabbitRateLimitRetryMs(
+    '[2026-01-25T22:29:41.623Z] ❌ ERROR: Error: Rate limit exceeded, please try after 3 minutes and 2 seconds'
+  );
+  assert.ok(ms);
+  // Allow +1s padding.
+  assert.equal(ms, (3 * 60 + 2 + 1) * 1000);
+});
+
+test('parseCodeRabbitRateLimitRetryMs supports seconds-only windows', () => {
+  const ms = parseCodeRabbitRateLimitRetryMs(
+    '[2026-01-26T00:27:23.067Z] ❌ ERROR: Error: Rate limit exceeded, please try after 0 minutes and 31 seconds'
+  );
+  assert.ok(ms);
+  assert.equal(ms, (31 + 1) * 1000);
+});
+
+test('parseCodeRabbitRateLimitRetryMs enforces a minimum 1s retry window', () => {
+  const ms = parseCodeRabbitRateLimitRetryMs(
+    '[2026-01-26T00:27:23.067Z] ERROR: Rate limit exceeded, please try after 0 minutes and 0 seconds'
+  );
+  assert.equal(ms, 1000);
+});

package/scripts/utils/review/runners/codex.mjs

@@ -0,0 +1,129 @@
+import { runCaptureResult } from '../../proc/proc.mjs';
+
+const unsupportedModels = new Set();
+
+function parsePositiveInt(raw) {
+  const n = Number(String(raw ?? '').trim());
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+
+function resolveCodexKeepaliveMs(env) {
+  const specific = parsePositiveInt(env?.HAPPIER_STACK_REVIEW_CODEX_KEEPALIVE_MS);
+  if (specific !== null) return specific;
+  const global = parsePositiveInt(env?.HAPPIER_STACK_REVIEW_KEEPALIVE_MS);
+  if (global !== null) return global;
+  return 30_000;
+}
+
+export function detectCodexUnsupportedModelError({ stdout, stderr }) {
+  const combined = `${stdout ?? ''}\n${stderr ?? ''}`;
+  return combined.includes('model is not supported when using Codex with a ChatGPT account');
+}
+
+export function markCodexModelUnsupported(model) {
+  const m = String(model ?? '').trim();
+  if (m) unsupportedModels.add(m);
+}
+
+export function isCodexModelKnownUnsupported(model) {
+  const m = String(model ?? '').trim();
+  if (!m) return false;
+  return unsupportedModels.has(m);
+}
+
+export function extractCodexReviewFromJsonl(jsonlText) {
+  const lines = String(jsonlText ?? '')
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean);
+
+  // JSONL events typically look like: { "type": "...", "payload": {...} } or similar.
+  // We keep this resilient by searching for keys matching the exec output format.
+  for (const line of lines) {
+    let obj = null;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const candidates = [obj, obj?.msg, obj?.payload, obj?.event, obj?.data, obj?.result].filter(Boolean);
+    for (const c of candidates) {
+      const exited =
+        c?.ExitedReviewMode ??
+        (c?.type === 'ExitedReviewMode' ? c : null) ??
+        (c?.event?.type === 'ExitedReviewMode' ? c.event : null) ??
+        (c?.payload?.type === 'ExitedReviewMode' ? c.payload : null);
+
+      const reviewOutput = exited?.review_output ?? exited?.reviewOutput ?? null;
+      if (reviewOutput) return reviewOutput;
+    }
+  }
+  return null;
+}
+
+export function buildCodexReviewArgs({ baseRef, jsonMode, prompt, model }) {
+  const args = ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox'];
+  // Review runs should be deterministic and lightweight; disable user-configured MCP servers.
+  args.push('-c', 'mcp_servers={}');
+
+  // Codex review targets are mutually exclusive:
+  // - --base / --commit / --uncommitted are distinct "targets"
+  // - Providing a PROMPT switches to the "custom instructions" target and cannot be combined with the above.
+  // Therefore, when reviewing a target (base/commit/uncommitted), we do not pass a prompt.
+  if (baseRef) args.push('--base', baseRef);
+
+  if (jsonMode) {
+    args.push('--json');
+  }
+
+  const m = String(model ?? '').trim();
+  if (m) args.push('--model', m);
+
+  const p = String(prompt ?? '').trim();
+  if (!baseRef && p) args.push(p);
+  if (!baseRef && !p) args.push('--uncommitted');
+  return args;
+}
+
+export async function runCodexReview({ repoDir, baseRef, env, jsonMode, streamLabel, teeFile, teeLabel, prompt, model }) {
+  const merged = { ...(env ?? {}) };
+  const codexHome =
+    (merged.HAPPIER_STACK_CODEX_HOME_DIR ?? merged.CODEX_HOME ?? '').toString().trim();
+  if (codexHome) merged.CODEX_HOME = codexHome;
+
+  const effectiveModel = isCodexModelKnownUnsupported(model) ? '' : model;
+  const args = buildCodexReviewArgs({ baseRef, jsonMode, prompt, model: effectiveModel });
+  const heartbeatMs = resolveCodexKeepaliveMs(merged);
+  const res = await runCaptureResult('codex', args, {
+    cwd: repoDir,
+    env: merged,
+    streamLabel,
+    teeFile,
+    teeLabel,
+    heartbeatMs,
+  });
+
+  const out = { ...res, stdout: res.out, stderr: res.err };
+  if (out.ok) return out;
+
+  const m = String(model ?? '').trim();
+  if (m && detectCodexUnsupportedModelError({ stdout: out.stdout, stderr: out.stderr })) {
+    markCodexModelUnsupported(m);
+    // eslint-disable-next-line no-console
+    console.warn(`[review] codex model '${m}' not supported; retrying without --model`);
+    // In some environments, Codex running under a ChatGPT account rejects certain model IDs.
+    // If that happens, fall back to the user's configured default model by omitting --model.
+    const retryArgs = buildCodexReviewArgs({ baseRef, jsonMode, prompt, model: '' });
+    const retry = await runCaptureResult('codex', retryArgs, {
+      cwd: repoDir,
+      env: merged,
+      streamLabel,
+      teeFile,
+      teeLabel,
+      heartbeatMs,
+    });
+    return { ...retry, stdout: retry.out, stderr: retry.err };
+  }
+
+  return out;
+}

package/scripts/utils/review/runners/codex.test.mjs

@@ -0,0 +1,115 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  buildCodexReviewArgs,
+  detectCodexUnsupportedModelError,
+  extractCodexReviewFromJsonl,
+  isCodexModelKnownUnsupported,
+  markCodexModelUnsupported,
+} from './codex.mjs';
+
+test('buildCodexReviewArgs uses --base and avoids --cd', () => {
+  const args = buildCodexReviewArgs({ baseRef: 'upstream/main', jsonMode: false });
+  assert.equal(args.includes('--cd'), false);
+  assert.deepEqual(args, [
+    'exec',
+    'review',
+    '--dangerously-bypass-approvals-and-sandbox',
+    '-c',
+    'mcp_servers={}',
+    '--base',
+    'upstream/main',
+  ]);
+});
+
+test('buildCodexReviewArgs uses --experimental-json when jsonMode is true', () => {
+  const args = buildCodexReviewArgs({ baseRef: 'upstream/main', jsonMode: true });
+  assert.deepEqual(args, [
+    'exec',
+    'review',
+    '--dangerously-bypass-approvals-and-sandbox',
+    '-c',
+    'mcp_servers={}',
+    '--base',
+    'upstream/main',
+    '--json',
+  ]);
+});
+
+test('buildCodexReviewArgs appends a prompt when provided', () => {
+  const args = buildCodexReviewArgs({ baseRef: null, jsonMode: false, prompt: 'be thorough' });
+  assert.deepEqual(args, ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox', '-c', 'mcp_servers={}', 'be thorough']);
+});
+
+test('buildCodexReviewArgs includes --model when provided', () => {
+  const args = buildCodexReviewArgs({ baseRef: 'upstream/main', jsonMode: false, model: 'codex-5.3' });
+  assert.deepEqual(args, [
+    'exec',
+    'review',
+    '--dangerously-bypass-approvals-and-sandbox',
+    '-c',
+    'mcp_servers={}',
+    '--base',
+    'upstream/main',
+    '--model',
+    'codex-5.3',
+  ]);
+});
+
+test('buildCodexReviewArgs defaults to --uncommitted for targetless review', () => {
+  const args = buildCodexReviewArgs({ baseRef: '', jsonMode: false, prompt: '   ' });
+  assert.deepEqual(args, [
+    'exec',
+    'review',
+    '--dangerously-bypass-approvals-and-sandbox',
+    '-c',
+    'mcp_servers={}',
+    '--uncommitted',
+  ]);
+});
+
+test('buildCodexReviewArgs ignores prompt when baseRef target is provided', () => {
+  const args = buildCodexReviewArgs({ baseRef: 'upstream/main', jsonMode: false, prompt: 'be thorough' });
+  assert.equal(args.includes('be thorough'), false);
+  assert.equal(args.includes('--uncommitted'), false);
+});
+
+test('extractCodexReviewFromJsonl finds review_output in multiple event shapes', () => {
+  const out1 = extractCodexReviewFromJsonl(
+    JSON.stringify({ msg: { ExitedReviewMode: { review_output: { a: 1 } } } }) + '\n'
+  );
+  assert.deepEqual(out1, { a: 1 });
+
+  const out2 = extractCodexReviewFromJsonl(JSON.stringify({ type: 'ExitedReviewMode', review_output: { b: 2 } }) + '\n');
+  assert.deepEqual(out2, { b: 2 });
+
+  const out3 = extractCodexReviewFromJsonl(
+    JSON.stringify({ event: { type: 'ExitedReviewMode', reviewOutput: { c: 3 } } }) + '\n'
+  );
+  assert.deepEqual(out3, { c: 3 });
+});
+
+test('extractCodexReviewFromJsonl returns null for invalid/no-match lines', () => {
+  const result = extractCodexReviewFromJsonl('not-json\n{"type":"Progress","payload":{"x":1}}\n');
+  assert.equal(result, null);
+});
+
+test('detectCodexUnsupportedModelError detects the ChatGPT-account unsupported-model failure', () => {
+  assert.equal(
+    detectCodexUnsupportedModelError({
+      stdout: '',
+      stderr: `ERROR: {"detail":"The 'codex-5.3' model is not supported when using Codex with a ChatGPT account."}`,
+    }),
+    true,
+  );
+  assert.equal(detectCodexUnsupportedModelError({ stdout: 'ok', stderr: '' }), false);
+});
+
+test('markCodexModelUnsupported / isCodexModelKnownUnsupported track unsupported models', () => {
+  const model = `test-model-${process.hrtime.bigint()}`;
+  assert.equal(isCodexModelKnownUnsupported(model), false);
+  markCodexModelUnsupported(model);
+  assert.equal(isCodexModelKnownUnsupported(model), true);
+  assert.equal(isCodexModelKnownUnsupported(` ${model} `), true);
+});

package/scripts/utils/review/slice_mode.mjs

@@ -0,0 +1,20 @@
+const UNCOMMITTED_PATH_SLICE_REVIEWERS = new Set(['coderabbit', 'codex', 'claude']);
+
+export function reviewerSupportsUncommittedPathSlices(reviewer) {
+  return UNCOMMITTED_PATH_SLICE_REVIEWERS.has(String(reviewer ?? '').trim().toLowerCase());
+}
+
+export function shouldUseUncommittedPathSlices({
+  reviewer,
+  changeType,
+  fileCount,
+  maxFiles,
+  chunksPreference = null,
+} = {}) {
+  if (String(changeType ?? '').trim().toLowerCase() !== 'uncommitted') return false;
+  if (!reviewerSupportsUncommittedPathSlices(reviewer)) return false;
+  if (chunksPreference !== null && chunksPreference !== undefined) return Boolean(chunksPreference);
+  const parsedMaxFiles = Number(maxFiles);
+  if (!Number.isFinite(parsedMaxFiles) || parsedMaxFiles <= 0) return false;
+  return Number(fileCount ?? 0) > parsedMaxFiles;
+}

package/scripts/utils/review/slice_mode.test.mjs

@@ -0,0 +1,69 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { shouldUseUncommittedPathSlices } from './slice_mode.mjs';
+
+test('shouldUseUncommittedPathSlices enables codex when file count exceeds max', () => {
+  const out = shouldUseUncommittedPathSlices({
+    reviewer: 'codex',
+    changeType: 'uncommitted',
+    fileCount: 120,
+    maxFiles: 100,
+    chunksPreference: null,
+  });
+  assert.equal(out, true);
+});
+
+test('shouldUseUncommittedPathSlices disables claude when under max and no explicit chunk flag', () => {
+  const out = shouldUseUncommittedPathSlices({
+    reviewer: 'claude',
+    changeType: 'uncommitted',
+    fileCount: 20,
+    maxFiles: 100,
+    chunksPreference: null,
+  });
+  assert.equal(out, false);
+});
+
+test('shouldUseUncommittedPathSlices honors explicit chunk override', () => {
+  const out = shouldUseUncommittedPathSlices({
+    reviewer: 'claude',
+    changeType: 'uncommitted',
+    fileCount: 20,
+    maxFiles: 100,
+    chunksPreference: true,
+  });
+  assert.equal(out, true);
+});
+
+test('shouldUseUncommittedPathSlices returns false for unsupported reviewers', () => {
+  const out = shouldUseUncommittedPathSlices({
+    reviewer: 'augment',
+    changeType: 'uncommitted',
+    fileCount: 120,
+    maxFiles: 100,
+    chunksPreference: true,
+  });
+  assert.equal(out, false);
+});
+
+test('shouldUseUncommittedPathSlices returns false for non-uncommitted change types', () => {
+  const out = shouldUseUncommittedPathSlices({
+    reviewer: 'codex',
+    changeType: 'committed',
+    fileCount: 120,
+    maxFiles: 100,
+    chunksPreference: true,
+  });
+  assert.equal(out, false);
+});
+
+test('shouldUseUncommittedPathSlices returns false when maxFiles is missing and no override is set', () => {
+  const out = shouldUseUncommittedPathSlices({
+    reviewer: 'codex',
+    changeType: 'uncommitted',
+    fileCount: 1,
+    chunksPreference: null,
+  });
+  assert.equal(out, false);
+});