@happier-dev/stack 0.1.0-preview.74.1

package/scripts/utils/proc/proc.mjs

@@ -0,0 +1,331 @@
+import { spawn } from 'node:child_process';
+import { createWriteStream } from 'node:fs';
+
+function nextLineBreakIndex(s) {
+  const n = s.indexOf('\n');
+  const r = s.indexOf('\r');
+  if (n < 0) return r;
+  if (r < 0) return n;
+  return Math.min(n, r);
+}
+
+function consumeLineBreak(buf) {
+  if (buf.startsWith('\r\n')) return buf.slice(2);
+  if (buf.startsWith('\n') || buf.startsWith('\r')) return buf.slice(1);
+  return buf;
+}
+
+function writeWithPrefix(stream, prefix, bufState, chunk) {
+  const s = chunk.toString();
+  bufState.buf += s;
+  while (true) {
+    const idx = nextLineBreakIndex(bufState.buf);
+    if (idx < 0) break;
+    const line = bufState.buf.slice(0, idx);
+    bufState.buf = consumeLineBreak(bufState.buf.slice(idx));
+    stream.write(`${prefix}${line}\n`);
+  }
+}
+
+function flushPrefixed(stream, prefix, bufState) {
+  if (!bufState.buf) return;
+  stream.write(`${prefix}${bufState.buf}\n`);
+  bufState.buf = '';
+}
+
+export function spawnProc(label, cmd, args, env, options = {}) {
+  const { silent = false, teeFile, teeLabel, ...spawnOptions } = options ?? {};
+  const child = spawn(cmd, args, {
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: false,
+    // Create a new process group so we can kill the whole tree reliably on shutdown.
+    detached: process.platform !== 'win32',
+    ...spawnOptions,
+  });
+
+  const outState = { buf: '' };
+  const errState = { buf: '' };
+  const outPrefix = `[${label}] `;
+  const errPrefix = `[${label}] `;
+
+  const teePath = typeof teeFile === 'string' && teeFile.trim() ? teeFile.trim() : '';
+  const teeStream = teePath ? createWriteStream(teePath, { flags: 'a' }) : null;
+  const teeOutState = { buf: '' };
+  const teeErrState = { buf: '' };
+  const teePrefix = (() => {
+    const t = typeof teeLabel === 'string' ? teeLabel.trim() : '';
+    if (t) return `[${t}] `;
+    return outPrefix;
+  })();
+
+  child.stdout?.on('data', (d) => {
+    if (!silent) writeWithPrefix(process.stdout, outPrefix, outState, d);
+    if (teeStream) writeWithPrefix(teeStream, teePrefix, teeOutState, d);
+  });
+  child.stderr?.on('data', (d) => {
+    if (!silent) writeWithPrefix(process.stderr, errPrefix, errState, d);
+    if (teeStream) writeWithPrefix(teeStream, teePrefix, teeErrState, d);
+  });
+  child.on('close', () => {
+    if (!silent) {
+      flushPrefixed(process.stdout, outPrefix, outState);
+      flushPrefixed(process.stderr, errPrefix, errState);
+    }
+    if (teeStream) {
+      flushPrefixed(teeStream, teePrefix, teeOutState);
+      flushPrefixed(teeStream, teePrefix, teeErrState);
+      try {
+        teeStream.end();
+      } catch {
+        // ignore
+      }
+    }
+  });
+  child.on('exit', (code, sig) => {
+    if (code !== 0) {
+      if (!silent) {
+        process.stderr.write(`[${label}] exited (code=${code}, sig=${sig})\n`);
+      }
+      if (teeStream) {
+        try {
+          teeStream.write(`${teePrefix.trimEnd()} exited (code=${code}, sig=${sig})\n`);
+        } catch {
+          // ignore
+        }
+      }
+    }
+  });
+
+  return child;
+}
+
+export function killProcessTree(child, signal) {
+  if (!child || child.exitCode != null || !child.pid) {
+    return;
+  }
+
+  try {
+    if (process.platform !== 'win32') {
+      // Kill the process group.
+      process.kill(-child.pid, signal);
+    } else {
+      child.kill(signal);
+    }
+  } catch {
+    // ignore
+  }
+}
+
+export async function run(cmd, args, options = {}) {
+  const { timeoutMs, input, ...spawnOptions } = options ?? {};
+  await new Promise((resolvePromise, rejectPromise) => {
+    const baseStdio = spawnOptions.stdio ?? 'inherit';
+    const stdio =
+      input != null
+        ? Array.isArray(baseStdio)
+          ? ['pipe', baseStdio[1] ?? 'inherit', baseStdio[2] ?? 'inherit']
+          : ['pipe', baseStdio, baseStdio]
+        : baseStdio;
+
+    const proc = spawn(cmd, args, { stdio, shell: false, ...spawnOptions });
+    if (input != null && proc.stdin) {
+      try {
+        proc.stdin.write(String(input));
+        proc.stdin.end();
+      } catch {
+        // ignore
+      }
+    }
+    const t =
+      Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? setTimeout(() => {
+            try {
+              proc.kill('SIGKILL');
+            } catch {
+              // ignore
+            }
+            const e = new Error(`${cmd} timed out after ${timeoutMs}ms`);
+            e.code = 'ETIMEDOUT';
+            rejectPromise(e);
+          }, timeoutMs)
+        : null;
+    proc.on('error', rejectPromise);
+    proc.on('exit', (code) => (code === 0 ? resolvePromise() : rejectPromise(new Error(`${cmd} failed (code=${code})`))));
+    proc.on('exit', () => {
+      if (t) clearTimeout(t);
+    });
+  });
+}
+
+export async function runCapture(cmd, args, options = {}) {
+  const { timeoutMs, ...spawnOptions } = options ?? {};
+  return await new Promise((resolvePromise, rejectPromise) => {
+    const proc = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], shell: false, ...spawnOptions });
+    let out = '';
+    let err = '';
+    const t =
+      Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? setTimeout(() => {
+            try {
+              proc.kill('SIGKILL');
+            } catch {
+              // ignore
+            }
+            const e = new Error(`${cmd} ${args.join(' ')} timed out after ${timeoutMs}ms`);
+            e.code = 'ETIMEDOUT';
+            e.out = out;
+            e.err = err;
+            rejectPromise(e);
+          }, timeoutMs)
+        : null;
+    proc.stdout?.on('data', (d) => (out += d.toString()));
+    proc.stderr?.on('data', (d) => (err += d.toString()));
+    proc.on('error', rejectPromise);
+    proc.on('exit', (code, signal) => {
+      if (t) clearTimeout(t);
+      if (code === 0) {
+        resolvePromise(out);
+      } else {
+        const e = new Error(
+          `${cmd} ${args.join(' ')} failed (code=${code ?? 'null'}, sig=${signal ?? 'null'}): ${err.trim()}`
+        );
+        e.code = 'EEXIT';
+        e.exitCode = code;
+        e.signal = signal;
+        e.out = out;
+        e.err = err;
+        rejectPromise(e);
+      }
+    });
+  });
+}
+
+export async function runCaptureResult(cmd, args, options = {}) {
+  const { timeoutMs, streamLabel, teeFile, teeLabel, input, heartbeatMs, ...spawnOptions } = options ?? {};
+  const startedAt = Date.now();
+  return await new Promise((resolvePromise) => {
+    const stdio = input != null ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'];
+    const proc = spawn(cmd, args, { stdio, shell: false, ...spawnOptions });
+    let out = '';
+    let err = '';
+    const label = String(streamLabel ?? '').trim();
+    const shouldStream = Boolean(label);
+    const outState = { buf: '' };
+    const errState = { buf: '' };
+    const prefix = shouldStream ? `[${label}] ` : '';
+
+    const teePath = String(teeFile ?? '').trim();
+    const shouldTee = Boolean(teePath);
+    const teeOutState = { buf: '' };
+    const teeErrState = { buf: '' };
+    const teePrefix = (() => {
+      const t = String(teeLabel ?? '').trim();
+      if (t) return `[${t}] `;
+      if (label) return `[${label}] `;
+      return '';
+    })();
+    const teeStream = shouldTee ? createWriteStream(teePath, { flags: 'a' }) : null;
+    const keepaliveEveryMs = Number.isFinite(heartbeatMs) && heartbeatMs > 0 ? heartbeatMs : 0;
+
+    function writeKeepaliveLine(line) {
+      if (shouldStream) process.stdout.write(`${prefix}${line}\n`);
+      if (shouldTee && teeStream) teeStream.write(`${teePrefix}${line}\n`);
+    }
+
+    function resolveWith(res) {
+      if (shouldStream) {
+        flushPrefixed(process.stdout, prefix, outState);
+        flushPrefixed(process.stderr, prefix, errState);
+      }
+      if (shouldTee && teeStream) {
+        flushPrefixed(teeStream, teePrefix, teeOutState);
+        flushPrefixed(teeStream, teePrefix, teeErrState);
+        try {
+          teeStream.end();
+        } catch {
+          // ignore
+        }
+      }
+      resolvePromise(res);
+    }
+    const hb =
+      keepaliveEveryMs > 0
+        ? setInterval(() => {
+            const elapsedSec = Math.floor((Date.now() - startedAt) / 1000);
+            writeKeepaliveLine(`still running (elapsed ${elapsedSec}s, pid=${proc.pid})`);
+          }, keepaliveEveryMs)
+        : null;
+    const t =
+      Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? setTimeout(() => {
+            try {
+              proc.kill('SIGKILL');
+            } catch {
+              // ignore
+            }
+            if (hb) clearInterval(hb);
+            resolveWith({
+              ok: false,
+              exitCode: null,
+              signal: null,
+              out,
+              err,
+              timedOut: true,
+              startedAt,
+              finishedAt: Date.now(),
+              durationMs: Date.now() - startedAt,
+            });
+          }, timeoutMs)
+        : null;
+    proc.stdout?.on('data', (d) => {
+      out += d.toString();
+      if (shouldStream) writeWithPrefix(process.stdout, prefix, outState, d);
+      if (shouldTee && teeStream) writeWithPrefix(teeStream, teePrefix, teeOutState, d);
+    });
+    proc.stderr?.on('data', (d) => {
+      err += d.toString();
+      if (shouldStream) writeWithPrefix(process.stderr, prefix, errState, d);
+      if (shouldTee && teeStream) writeWithPrefix(teeStream, teePrefix, teeErrState, d);
+    });
+
+    if (input != null && proc.stdin) {
+      try {
+        proc.stdin.write(String(input));
+        proc.stdin.end();
+      } catch {
+        // ignore
+      }
+    }
+    proc.on('error', (e) => {
+      if (t) clearTimeout(t);
+      if (hb) clearInterval(hb);
+      resolveWith({
+        ok: false,
+        exitCode: null,
+        signal: null,
+        out,
+        err: err + (err.endsWith('\n') || !err ? '' : '\n') + String(e) + '\n',
+        timedOut: false,
+        startedAt,
+        finishedAt: Date.now(),
+        durationMs: Date.now() - startedAt,
+      });
+    });
+    proc.on('close', (code, signal) => {
+      if (t) clearTimeout(t);
+      if (hb) clearInterval(hb);
+      resolveWith({
+        ok: code === 0,
+        exitCode: code,
+        signal: signal ?? null,
+        out,
+        err,
+        timedOut: false,
+        startedAt,
+        finishedAt: Date.now(),
+        durationMs: Date.now() - startedAt,
+      });
+    });
+  });
+}

package/scripts/utils/proc/proc.test.mjs

@@ -0,0 +1,85 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { runCaptureResult } from './proc.mjs';
+
+async function withTempRoot(t) {
+  const root = await mkdtemp(join(tmpdir(), 'happy-proc-test-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+  return root;
+}
+
+test('runCaptureResult captures stdout/stderr', async () => {
+  const res = await runCaptureResult(process.execPath, ['-e', 'console.log("hello"); console.error("oops")'], {
+    env: process.env,
+  });
+  assert.equal(res.ok, true);
+  assert.equal(res.exitCode, 0);
+  assert.match(res.out, /hello/);
+  assert.match(res.err, /oops/);
+});
+
+test('runCaptureResult streams output when streamLabel is set (without affecting captured output)', async (t) => {
+  const stdoutWrites = [];
+  const stderrWrites = [];
+  t.mock.method(process.stdout, 'write', (chunk) => {
+    stdoutWrites.push(String(chunk));
+    return true;
+  });
+  t.mock.method(process.stderr, 'write', (chunk) => {
+    stderrWrites.push(String(chunk));
+    return true;
+  });
+
+  const res = await runCaptureResult(process.execPath, ['-e', 'console.log("hello"); console.error("oops")'], {
+    env: process.env,
+    streamLabel: 'proc-test',
+  });
+  assert.equal(res.ok, true);
+  assert.equal(res.exitCode, 0);
+  assert.match(res.out, /hello/);
+  assert.match(res.err, /oops/);
+
+  const streamedOut = stdoutWrites.join('');
+  const streamedErr = stderrWrites.join('');
+  assert.match(streamedOut, /\[proc-test\] hello/);
+  assert.match(streamedErr, /\[proc-test\] oops/);
+});
+
+test('runCaptureResult can tee streamed output to a file', async (t) => {
+  const root = await withTempRoot(t);
+  const teeFile = join(root, 'tee.log');
+  const res = await runCaptureResult(process.execPath, ['-e', 'console.log("hello"); console.error("oops")'], {
+    env: process.env,
+    teeFile,
+    teeLabel: 'tee-test',
+  });
+  assert.equal(res.ok, true);
+  const raw = await readFile(teeFile, 'utf-8');
+  assert.match(raw, /\[tee-test\] hello/);
+  assert.match(raw, /\[tee-test\] oops/);
+});
+
+test('runCaptureResult emits periodic keepalive logs while process is running', async (t) => {
+  const root = await withTempRoot(t);
+  const teeFile = join(root, 'keepalive.log');
+  const res = await runCaptureResult(
+    process.execPath,
+    ['-e', 'setTimeout(() => { process.exit(0); }, 220);'],
+    {
+      env: process.env,
+      teeFile,
+      teeLabel: 'keepalive-test',
+      heartbeatMs: 50,
+    }
+  );
+  assert.equal(res.ok, true);
+  assert.equal(res.exitCode, 0);
+  const raw = await readFile(teeFile, 'utf-8');
+  assert.match(raw, /\[keepalive-test\] still running \(elapsed \d+s, pid=\d+\)/);
+});

package/scripts/utils/proc/terminate.mjs

@@ -0,0 +1,69 @@
+import { isPidAlive } from './pids.mjs';
+
+function nowMs() {
+  return Date.now();
+}
+
+async function waitForExit(pid, timeoutMs) {
+  const end = nowMs() + Math.max(0, Number(timeoutMs) || 0);
+  while (nowMs() < end) {
+    if (!isTargetAlive(pid)) return true;
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, 40));
+  }
+  return !isTargetAlive(pid);
+}
+
+function killGroup(pid, signal) {
+  if (!pid || pid <= 1) return;
+  try {
+    if (process.platform !== 'win32') process.kill(-pid, signal);
+    else {
+      // Windows doesn't implement POSIX signal semantics; process.kill(pid, SIGINT/SIGTERM)
+      // targets the single process and may terminate it immediately instead of graceful group shutdown.
+      process.kill(pid, signal);
+    }
+  } catch {
+    // ignore
+  }
+}
+
+function isTargetAlive(pid) {
+  if (!pid || pid <= 1) return false;
+  if (process.platform === 'win32') {
+    return isPidAlive(pid);
+  }
+  try {
+    process.kill(-pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === 'EPERM';
+  }
+}
+
+function normalizeStartSignal(signal) {
+  const s = String(signal ?? '').trim().toUpperCase();
+  if (s === 'SIGINT' || s === 'SIGTERM' || s === 'SIGKILL') return s;
+  return 'SIGINT';
+}
+
+export async function terminateProcessGroup(pid, { graceMs = 800, signal = 'SIGINT' } = {}) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 1) return { ok: false, reason: 'bad_pid' };
+  if (!isTargetAlive(n)) return { ok: true, alreadyExited: true };
+
+  const perSignalMs = Math.max(50, Number(graceMs) || 0);
+  const startSignal = normalizeStartSignal(signal);
+  const sequence = [startSignal, 'SIGINT', 'SIGTERM', 'SIGKILL'].filter(
+    (sig, index, arr) => arr.indexOf(sig) === index
+  );
+
+  for (const sig of sequence) {
+    killGroup(n, sig);
+    // eslint-disable-next-line no-await-in-loop
+    const exited = await waitForExit(n, sig === 'SIGKILL' ? Math.min(400, perSignalMs) : perSignalMs);
+    if (exited) return { ok: true, signal: sig };
+  }
+
+  return { ok: !isTargetAlive(n), signal: 'SIGKILL' };
+}

package/scripts/utils/proc/terminate.test.mjs

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+
+import { isPidAlive } from './pids.mjs';
+import { terminateProcessGroup } from './terminate.mjs';
+
+async function waitForPidExit(pid, timeoutMs) {
+  const end = Date.now() + Math.max(0, Number(timeoutMs) || 0);
+  while (Date.now() < end) {
+    if (!isPidAlive(pid)) return;
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, 30));
+  }
+  throw new Error(`timed out waiting for pid ${pid} to exit`);
+}
+
+test('terminateProcessGroup escalates to SIGKILL when child ignores SIGINT/SIGTERM', async (t) => {
+  if (process.platform === 'win32') {
+    t.skip('POSIX process-group signaling semantics');
+    return;
+  }
+
+  const child = spawn(
+    process.execPath,
+    [
+      '-e',
+      [
+        "process.on('SIGINT', () => {});",
+        "process.on('SIGTERM', () => {});",
+        'setInterval(() => {}, 1000);',
+      ].join(' '),
+    ],
+    { stdio: 'ignore', detached: true }
+  );
+  child.unref();
+  try {
+    assert.ok(child.pid && child.pid > 1, 'expected child pid');
+    assert.ok(isPidAlive(child.pid), 'expected child to be alive');
+
+    const res = await terminateProcessGroup(child.pid, { graceMs: 120 });
+    assert.equal(res.ok, true, `expected terminate ok, got ${JSON.stringify(res)}`);
+
+    await waitForPidExit(child.pid, 1200);
+  } finally {
+    if (child.pid && isPidAlive(child.pid)) {
+      try {
+        child.kill('SIGKILL');
+      } catch {
+        // best effort
+      }
+    }
+  }
+});

package/scripts/utils/proc/watch.mjs

@@ -0,0 +1,63 @@
+import { watch } from 'node:fs';
+
+function safeWatch(path, handler) {
+  try {
+    // Node supports recursive watching on macOS and Windows. On Linux this may throw; we fail closed by returning null.
+    return watch(path, { recursive: true }, handler);
+  } catch {
+    try {
+      return watch(path, {}, handler);
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Very small, dependency-free debounced watcher.
+ * Intended for dev ergonomics (rebuild/restart), not for correctness-critical logic.
+ */
+export function watchDebounced({ paths, debounceMs = 500, onChange } = {}) {
+  const list = Array.isArray(paths) ? paths.filter(Boolean) : [];
+  if (!list.length) return null;
+  if (typeof onChange !== 'function') return null;
+
+  let closed = false;
+  let t = null;
+  const watchers = [];
+
+  const trigger = (eventType, filename) => {
+    if (closed) return;
+    if (t) clearTimeout(t);
+    t = setTimeout(() => {
+      t = null;
+      try {
+        onChange({ eventType, filename });
+      } catch {
+        // ignore
+      }
+    }, debounceMs);
+  };
+
+  for (const p of list) {
+    const w = safeWatch(p, trigger);
+    if (w) watchers.push(w);
+  }
+
+  if (!watchers.length) return null;
+
+  return {
+    close() {
+      closed = true;
+      if (t) clearTimeout(t);
+      for (const w of watchers) {
+        try {
+          w.close();
+        } catch {
+          // ignore
+        }
+      }
+    },
+  };
+}
+

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

@@ -0,0 +1,105 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+function resolveRepoRoot() {
+  // This test must run from anywhere (repo root, package root, CI, etc.).
+  // Derive monorepo root from this file path to avoid cwd-sensitive failures.
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', '..', '..', '..', '..');
+}
+
+test('review script provides a non-empty prompt to augment in normal uncommitted mode', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'happier-review-auggie-'));
+  const binDir = path.join(tmp, 'bin');
+  fs.mkdirSync(binDir, { recursive: true });
+
+  const auggiePath = path.join(binDir, 'auggie');
+  fs.writeFileSync(
+    auggiePath,
+    `#!/usr/bin/env node
+const args = process.argv.slice(2);
+const last = args[args.length - 1] ?? '';
+if (!String(last).trim()) {
+  console.error('missing instruction');
+  process.exit(2);
+}
+process.stdout.write('ok\\n\\n===FINDINGS_JSON===\\n[]\\n');
+`,
+    { mode: 0o755 }
+  );
+
+  const repoRoot = resolveRepoRoot();
+  const env = {
+    ...process.env,
+    // Ensure our stub is used.
+    PATH: `${binDir}${path.delimiter}${process.env.PATH ?? ''}`,
+    // Keep Augment cache writes out of the repo.
+    HAPPIER_STACK_AUGMENT_CACHE_DIR: path.join(tmp, 'augment-home'),
+    HAPPIER_STACK_REPO_DIR: repoRoot,
+  };
+
+  const res = spawnSync(
+    process.execPath,
+    [
+      path.join(repoRoot, 'apps', 'stack', 'scripts', 'review.mjs'),
+      'all',
+      '--reviewers=augment',
+      '--type=uncommitted',
+      '--depth=normal',
+      '--no-chunks',
+      '--no-stream',
+      '--run-label=test-augment-normal-uncommitted',
+    ],
+    { cwd: repoRoot, env, encoding: 'utf8' }
+  );
+
+  assert.equal(res.status, 0, `expected exit 0; stderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+});
+
+test('review script infers repo dir from cwd even when target positionals are provided', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'happier-review-auggie-'));
+  const binDir = path.join(tmp, 'bin');
+  fs.mkdirSync(binDir, { recursive: true });
+
+  const auggiePath = path.join(binDir, 'auggie');
+  fs.writeFileSync(
+    auggiePath,
+    `#!/usr/bin/env node
+process.stdout.write('ok\\n\\n===FINDINGS_JSON===\\n[]\\n');
+`,
+    { mode: 0o755 }
+  );
+
+  const repoRoot = resolveRepoRoot();
+  const env = {
+    ...process.env,
+    PATH: `${binDir}${path.delimiter}${process.env.PATH ?? ''}`,
+    HAPPIER_STACK_AUGMENT_CACHE_DIR: path.join(tmp, 'augment-home'),
+    // Do NOT set HAPPIER_STACK_REPO_DIR here; we want it inferred from cwd.
+  };
+
+  const res = spawnSync(
+    process.execPath,
+    [
+      path.join(repoRoot, 'apps', 'stack', 'scripts', 'review.mjs'),
+      'all',
+      '--reviewers=augment',
+      '--type=uncommitted',
+      '--depth=normal',
+      '--no-chunks',
+      '--run-label=test-augment-repo-infer-with-positionals',
+    ],
+    { cwd: repoRoot, env, encoding: 'utf8' }
+  );
+
+  assert.equal(res.status, 0, `expected exit 0; stderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+  const repoRootPattern = repoRoot
+    .replaceAll('\\', '\\\\')
+    .replace(/^\/private/, '(?:\\/private)?');
+  assert.match(res.stdout, new RegExp(`\\[review\\] monorepo detected at ${repoRootPattern}`));
+});