ralph-prd 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-prd",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "AI-powered phased implementation runner for Claude Code — from PRD to shipped code",
   "bin": {
     "ralph-prd": "./bin/install.mjs"
@@ -30,4 +30,4 @@
   "engines": {
     "node": ">=18"
   }
-}
+}

package/ralph/lib/config.mjs

@@ -28,6 +28,7 @@ function isGitRepo(dirPath) {
  * @property {boolean}     waitForIt   - Pause for user confirmation before each commit step
  * @property {number}      maxRepairs  - Max repair attempts per phase before hard-stopping (default 3)
  * @property {number|null} onlyPhase   - When set, only this 1-based phase index is run (force re-run)
+ * @property {string}      logLevel    - "none" | "necessary" | "dump" (default "necessary")
  */
 
 /**
@@ -58,7 +59,7 @@ function isGitRepo(dirPath) {
 function parseConfigYaml(content) {
   const repos = [];
   const writableDirs = [];
-  const flags = { iDidThis: false, sendIt: false, waitForIt: false, maxRepairs: 3, onlyPhase: null };
+  const flags = { iDidThis: false, sendIt: false, waitForIt: false, maxRepairs: 3, onlyPhase: null, logLevel: 'necessary' };
   const hooks = { afterCommit: null };
   let section = null;
   let current = null;
@@ -119,6 +120,9 @@ function parseConfigYaml(content) {
         } else if (key === 'onlyPhase') {
           const n = parseInt(trimmedVal, 10);
           if (!isNaN(n) && n > 0) flags.onlyPhase = n;
+        } else if (key === 'logLevel') {
+          const valid = ['none', 'necessary', 'dump'];
+          if (valid.includes(trimmedVal)) flags.logLevel = trimmedVal;
         } else {
           flags[key] = trimmedVal === 'true';
         }

package/ralph/lib/log-writer.mjs

@@ -3,6 +3,11 @@
  *
  * Log writer for Ralph phase sessions.
  *
+ * Log levels:
+ *   "none"      — no files written at all
+ *   "necessary" — headers, footers, and verdict files only (pass/fail, progress)
+ *   "dump"      — full streamed output (current behaviour)
+ *
  * Each run gets a directory (passed in from the orchestrator, derived from the
  * plan name + timestamp).  Within that directory:
  *
@@ -11,8 +16,9 @@
  *
  * Public API:
  *   class LogWriter
- *     constructor(logsDir: string)    ensures the directory exists
- *     openStep(n, name, phaseName)    returns a StepLog
+ *     constructor(logsDir, logLevel)   ensures the directory exists (unless "none")
+ *     openStep(n, name, phaseName)     returns a StepLog
+ *     logLevel: string
  *
  *   class StepLog
  *     writeHeader()
@@ -24,6 +30,9 @@
 import { mkdirSync, appendFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 
+/** Valid log levels. */
+export const LOG_LEVELS = ['none', 'necessary', 'dump'];
+
 // ─── StepLog ─────────────────────────────────────────────────────────────────
 
 export class StepLog {
@@ -33,17 +42,20 @@ export class StepLog {
    * @param {number} taskNum   - 1-based task number within the phase
    * @param {string} name      - Task name, e.g. "implementation"
    * @param {string} phaseName
+   * @param {string} logLevel  - "none" | "necessary" | "dump"
    */
-  constructor(logsDir, phaseNum, _taskNum, name, phaseName) {
+  constructor(logsDir, phaseNum, _taskNum, name, phaseName, logLevel) {
     this._logsDir = logsDir;
     this._lastMessagePath = join(logsDir, 'last-message.txt');
     this.filePath = join(logsDir, `phase-${phaseNum}-${name}.log`);
     this._phaseName = phaseName;
     this._name = name;
+    this._logLevel = logLevel;
   }
 
   /** Write the step header line. */
   writeHeader() {
+    if (this._logLevel === 'none') return;
     const ts = new Date().toISOString();
     const line =
       `=== Phase: ${this._phaseName} | Step: ${this._name} | Started: ${ts} ===\n\n`;
@@ -54,9 +66,12 @@ export class StepLog {
    * Append a streamed text chunk to the step log and overwrite last-message.txt.
    * Calling this repeatedly builds up both files incrementally.
    *
+   * Only writes at "dump" level — "necessary" skips the verbose stream.
+   *
    * @param {string} text
    */
   writeChunk(text) {
+    if (this._logLevel !== 'dump') return;
     appendFileSync(this.filePath, text, 'utf8');
     writeFileSync(this._lastMessagePath, text, 'utf8');
   }
@@ -68,6 +83,7 @@ export class StepLog {
    * @param {number} durationMs
    */
   writeFooter(ok, durationMs) {
+    if (this._logLevel === 'none') return;
     const status = ok ? 'ok' : 'failed';
     const seconds = (durationMs / 1000).toFixed(1);
     const line = `\n\n=== Exit: ${status} | Duration: ${seconds}s ===\n`;
@@ -79,12 +95,15 @@ export class StepLog {
 
 export class LogWriter {
   /**
-   * @param {string} logsDir - Absolute path to the run directory.
-   *   Created here if it doesn't exist yet.
+   * @param {string} logsDir  - Absolute path to the run directory.
+   * @param {string} [logLevel="necessary"] - "none" | "necessary" | "dump"
    */
-  constructor(logsDir) {
+  constructor(logsDir, logLevel = 'necessary') {
     this.logsDir = logsDir;
-    mkdirSync(logsDir, { recursive: true });
+    this.logLevel = logLevel;
+    if (logLevel !== 'none') {
+      mkdirSync(logsDir, { recursive: true });
+    }
   }
 
   /**
@@ -97,6 +116,6 @@ export class LogWriter {
    * @returns {StepLog}
    */
   openStep(phaseNum, taskNum, name, phaseName) {
-    return new StepLog(this.logsDir, phaseNum, taskNum, name, phaseName);
+    return new StepLog(this.logsDir, phaseNum, taskNum, name, phaseName, this.logLevel);
   }
 }

package/ralph/lib/verifier.mjs

@@ -313,11 +313,13 @@ export async function runVerificationLoop({
 
   const { verdict: initialVerdict, failureNotes: initialNotes } = parseVerdict(initialText);
 
-  writeFileSync(
-    join(logWriter.logsDir, `verdict-phase-${phaseNum}-verification.md`),
-    `VERDICT: ${initialVerdict}\n` + (initialNotes ? `\nFAILURE_NOTES:\n${initialNotes}\n` : ''),
-    'utf8'
-  );
+  if (logWriter.logLevel !== 'none') {
+    writeFileSync(
+      join(logWriter.logsDir, `verdict-phase-${phaseNum}-verification.md`),
+      `VERDICT: ${initialVerdict}\n` + (initialNotes ? `\nFAILURE_NOTES:\n${initialNotes}\n` : ''),
+      'utf8'
+    );
+  }
 
   if (initialVerdict === 'PASS') {
     return { nextTaskNum: taskNum, repairCount: 0 };
@@ -363,11 +365,13 @@ export async function runVerificationLoop({
 
     const { verdict, failureNotes } = parseVerdict(reVerifyText);
 
-    writeFileSync(
-      join(logWriter.logsDir, `verdict-phase-${phaseNum}-re-verification-${attempt}.md`),
-      `VERDICT: ${verdict}\n` + (failureNotes ? `\nFAILURE_NOTES:\n${failureNotes}\n` : ''),
-      'utf8'
-    );
+    if (logWriter.logLevel !== 'none') {
+      writeFileSync(
+        join(logWriter.logsDir, `verdict-phase-${phaseNum}-re-verification-${attempt}.md`),
+        `VERDICT: ${verdict}\n` + (failureNotes ? `\nFAILURE_NOTES:\n${failureNotes}\n` : ''),
+        'utf8'
+      );
+    }
 
     if (verdict === 'PASS') {
       return { nextTaskNum: taskNum, repairCount: attempt };

package/ralph/ralph-claude.mjs

@@ -109,11 +109,19 @@ const onlyPhaseArg = (() => {
   if (eqArg) return parseInt(eqArg.slice('--only-phase='.length), 10);
   return null;
 })();
+// Log level: none | necessary | dump (default: necessary from config)
+const logLevelArg = (() => {
+  const idx = args.indexOf('--log-level');
+  if (idx !== -1 && args[idx + 1] !== undefined) return args[idx + 1];
+  const eqArg = args.find(a => a.startsWith('--log-level='));
+  if (eqArg) return eqArg.slice('--log-level='.length);
+  return null;
+})();
 
 if (!planArg) {
   console.error(
     'Usage: node ralph-claude.mjs <plan-file.md> ' +
-    '[--reset|--dry-run|--i-did-this|--send-it|--wait-for-it|--only-phase N|--version]'
+    '[--reset|--dry-run|--i-did-this|--send-it|--wait-for-it|--only-phase N|--log-level none|necessary|dump|--version]'
   );
   process.exit(1);
 }
@@ -211,7 +219,7 @@ function pushAndOpenPR(repos, branch, planPath, planContent, phases) {
   }
 }
 
-function printHeader({ planPath, branch, repos, logsDir, phases, currentPhaseIndex, state }) {
+function printHeader({ planPath, branch, repos, logsDir, logLevel, phases, currentPhaseIndex, state }) {
   const primaryRepos = repos.filter(r => !r.writableOnly);
   const writableDirs = repos.filter(r => r.writableOnly);
   const allDone = currentPhaseIndex === null;
@@ -234,7 +242,11 @@ function printHeader({ planPath, branch, repos, logsDir, phases, currentPhaseInd
     for (const r of writableDirs) console.log(`         ${r.path}`);
   }
 
-  console.log(`Logs:    ${logsDir}`);
+  if (logLevel !== 'none') {
+    console.log(`Logs:    ${logsDir} (${logLevel})`);
+  } else {
+    console.log('Logs:    disabled');
+  }
 
   if (allDone) {
     console.log(`Status:  all ${phases.length} phases complete`);
@@ -304,6 +316,7 @@ async function main() {
   const sendIt = sendItArg || configFlags.sendIt;
   const waitForIt = waitForItArg || configFlags.waitForIt;
   const onlyPhase = onlyPhaseArg ?? configFlags.onlyPhase ?? null;
+  const logLevel = logLevelArg ?? configFlags.logLevel ?? 'necessary';
 
   // Load state & find first incomplete phase
   const state = loadState(planPath);
@@ -331,7 +344,7 @@ async function main() {
   }
 
   // Print run header
-  printHeader({ planPath, branch, repos, logsDir, phases, currentPhaseIndex: onlyPhase !== null ? (onlyPhase - 1) : currentPhaseIndex, state });
+  printHeader({ planPath, branch, repos, logsDir, logLevel, phases, currentPhaseIndex: onlyPhase !== null ? (onlyPhase - 1) : currentPhaseIndex, state });
 
   // Show update notice if available
   const update = await updateCheck;
@@ -360,26 +373,28 @@ async function main() {
       console.log(`      (${detail})`);
     }
 
-    // Write dry-run log
-    mkdirSync(logsDir, { recursive: true });
-    const dryRunLines = [
-      `Ralph dry-run — ${new Date().toISOString()}`,
-      `Plan:   ${planPath}`,
-      `Branch: ${branch}`,
-      `Repos:  ${repos.filter(r => !r.writableOnly).map(r => r.path).join(', ')}`,
-      '',
-      'Phases:',
-      ...phases.map(p => {
-        const done = state.completedPhases.includes(p.index);
-        const check = done ? 'x' : ' ';
-        const detail = p.hasVerification
-          ? ` (${p.acceptanceCriteria.length} criteria)`
-          : ' (no verification)';
-        return `  [${check}] ${p.title}${detail}`;
-      }),
-    ];
-    writeFileSync(resolve(logsDir, 'dry-run.log'), dryRunLines.join('\n') + '\n', 'utf8');
-    console.log(`\n[dry-run] Log written to: ${logsDir}/dry-run.log`);
+    // Write dry-run log (unless logging is disabled)
+    if (logLevel !== 'none') {
+      mkdirSync(logsDir, { recursive: true });
+      const dryRunLines = [
+        `Ralph dry-run — ${new Date().toISOString()}`,
+        `Plan:   ${planPath}`,
+        `Branch: ${branch}`,
+        `Repos:  ${repos.filter(r => !r.writableOnly).map(r => r.path).join(', ')}`,
+        '',
+        'Phases:',
+        ...phases.map(p => {
+          const done = state.completedPhases.includes(p.index);
+          const check = done ? 'x' : ' ';
+          const detail = p.hasVerification
+            ? ` (${p.acceptanceCriteria.length} criteria)`
+            : ' (no verification)';
+          return `  [${check}] ${p.title}${detail}`;
+        }),
+      ];
+      writeFileSync(resolve(logsDir, 'dry-run.log'), dryRunLines.join('\n') + '\n', 'utf8');
+      console.log(`\n[dry-run] Log written to: ${logsDir}/dry-run.log`);
+    }
     process.exit(0);
   }
 
@@ -423,7 +438,7 @@ async function main() {
 
   // planContent already read during validation above
   const safetyHeader = loadSafetyHeader(__dirname);
-  const logWriter = new LogWriter(logsDir);
+  const logWriter = new LogWriter(logsDir, logLevel);
 
   // Track phases already complete before this run (for summary)
   const previouslyCompleted = phases
@@ -653,7 +668,7 @@ async function main() {
   console.log(`Duration: ${durationSec}s`);
   if (totalCost > 0) console.log(`API cost: ${totalCost.toFixed(4)}`);
   console.log(`Branch:   ${branch}`);
-  console.log(`Logs:     ${logsDir}`);
+  if (logLevel !== 'none') console.log(`Logs:     ${logsDir}`);
   console.log(LINE);
 
   notify('Ralph — complete', `${phaseResults.length} phase${phaseResults.length === 1 ? '' : 's'} done in ${durationSec}s`);

package/ralph/ralph.config.sample.yaml

@@ -42,3 +42,9 @@ flags:
   # gives up and exits. Increase if your phases are complex and need
   # more attempts to pass all acceptance criteria.
   maxRepairs: 3
+
+  # Log level controls what gets written to disk.
+  #   none      — no log files at all
+  #   necessary — verdicts (pass/fail), missed criteria, phase progress (default)
+  #   dump      — full streamed model output (verbose)
+  logLevel: necessary

package/ralph/test/committer.test.mjs

@@ -20,7 +20,7 @@ describe('runCommitStep', () => {
   test('no changed repos → skips send(), returns anyCommitted=false', async () => {
     const repoDir = makeTempRepo(); // clean after initial commit
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
     let sendCalled = false;
     const send = async () => { sendCalled = true; return ''; };
 
@@ -43,7 +43,7 @@ describe('runCommitStep', () => {
     writeFileSync(join(repoDir, 'feature.txt'), 'content\n');
 
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
     const send = makeFakeSend([
       'REPO: myrepo\nFILES:\n- feature.txt\nCOMMIT: ralph: add feature',
     ]);
@@ -67,7 +67,7 @@ describe('runCommitStep', () => {
     writeFileSync(join(repoDir, 'irrelevant.txt'), 'stuff\n');
 
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
     const send = makeFakeSend(['REPO: myrepo\nSKIP']);
 
     const { anyCommitted } = await runCommitStep({
@@ -87,7 +87,7 @@ describe('runCommitStep', () => {
     writeFileSync(join(repoDir, 'foo.txt'), 'foo\n');
 
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
     // Model omits the "ralph:" prefix — runner should add it
     const send = makeFakeSend([
       'REPO: r\nFILES:\n- foo.txt\nCOMMIT: add foo feature',
@@ -112,7 +112,7 @@ describe('runCommitStep', () => {
     writeFileSync(join(dirtyRepo, 'new.txt'), 'hi\n');
 
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
     const send = makeFakeSend([
       'REPO: dirty\nFILES:\n- new.txt\nCOMMIT: ralph: add new file',
     ]);
@@ -145,7 +145,7 @@ describe('runCommitStep', () => {
     writeFileSync(join(repoDir, 'x.txt'), 'x\n');
 
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
     const send = async () => { throw new Error('transport down'); };
 
     await assert.rejects(
@@ -170,7 +170,7 @@ describe('runCommitStep', () => {
     writeFileSync(join(repoDir, 'f.txt'), 'f\n');
 
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
     const send = makeFakeSend([
       'REPO: r\nFILES:\n- f.txt\nCOMMIT: ralph: commit f',
     ]);

package/ralph/test/e2e.test.mjs

@@ -78,7 +78,7 @@ describe('e2e: full single-phase run with fake transport', () => {
     const repoDir = makeTempRepo();
     const planPath = makePlanFile(SINGLE_PHASE_PLAN);
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
 
     const { phases } = parsePlanContent(SINGLE_PHASE_PLAN);
     const phase = phases[0];
@@ -129,7 +129,7 @@ describe('e2e: repair-loop run (fail → repair → pass)', () => {
     const repoDir = makeTempRepo();
     const planPath = makePlanFile(SINGLE_PHASE_PLAN);
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
 
     const { phases } = parsePlanContent(SINGLE_PHASE_PLAN);
     const phase = phases[0];
@@ -187,7 +187,7 @@ describe('e2e: double-fail run exits non-zero and preserves logs', () => {
     const repoDir = makeTempRepo();
     const planPath = makePlanFile(SINGLE_PHASE_PLAN);
     const logDir = makeTempDir();
-    const lw = new LogWriter(logDir);
+    const lw = new LogWriter(logDir, 'dump');
 
     const { phases } = parsePlanContent(SINGLE_PHASE_PLAN);
     const phase = phases[0];

package/ralph/test/log-writer.test.mjs

@@ -9,21 +9,21 @@ describe('log-writer', () => {
 
   test('constructor creates the run directory', () => {
     const dir = join(makeTempDir(), 'logs', 'run-1');
-    new LogWriter(dir);
+    new LogWriter(dir, 'dump');
     assert.ok(existsSync(dir));
   });
 
-  test('step log filename follows step-N-name.log convention', () => {
+  test('step log filename follows phase-N-name.log convention', () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
-    const step = lw.openStep(3, 'implementation', 'Phase 1');
-    assert.ok(step.filePath.endsWith('step-3-implementation.log'));
+    const lw = new LogWriter(dir, 'dump');
+    const step = lw.openStep(3, 1, 'implementation', 'Phase 1');
+    assert.ok(step.filePath.endsWith('phase-3-implementation.log'));
   });
 
   test('writeHeader includes phase name, step name, and timestamp', () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
-    const step = lw.openStep(1, 'verification', 'Phase 2: Transport');
+    const lw = new LogWriter(dir, 'dump');
+    const step = lw.openStep(1, 1, 'verification', 'Phase 2: Transport');
     step.writeHeader();
 
     const content = readFileSync(step.filePath, 'utf8');
@@ -35,7 +35,7 @@ describe('log-writer', () => {
 
   test('writeChunk appends to step log', () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const step = lw.openStep(1, 'implementation', 'P1');
     step.writeHeader();
     step.writeChunk('hello ');
@@ -47,7 +47,7 @@ describe('log-writer', () => {
 
   test('writeChunk updates last-message.txt with latest chunk', () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const step = lw.openStep(1, 'implementation', 'P1');
     step.writeChunk('first');
     step.writeChunk('second');
@@ -59,7 +59,7 @@ describe('log-writer', () => {
 
   test('writeFooter includes exit status and duration', () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const step = lw.openStep(1, 'commit', 'P1');
     step.writeHeader();
     step.writeFooter(true, 2500);
@@ -71,7 +71,7 @@ describe('log-writer', () => {
 
   test('writeFooter with ok=false includes "failed"', () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const step = lw.openStep(1, 'verification', 'P1');
     step.writeHeader();
     step.writeFooter(false, 1000);
@@ -82,7 +82,7 @@ describe('log-writer', () => {
 
   test('step log file persists even if footer not written (failure mid-stream)', () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const step = lw.openStep(1, 'implementation', 'P1');
     step.writeHeader();
     step.writeChunk('partial output…');
@@ -95,7 +95,7 @@ describe('log-writer', () => {
 
   test('multiple steps in same run get separate log files', () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const s1 = lw.openStep(1, 'implementation', 'P1');
     const s2 = lw.openStep(2, 'verification', 'P1');
     s1.writeHeader();
@@ -108,4 +108,40 @@ describe('log-writer', () => {
     assert.ok(readFileSync(s2.filePath, 'utf8').includes('verify output'));
   });
 
+  // ─── Log level: necessary ──────────────────────────────────────────────────
+
+  test('necessary level writes header and footer but skips chunks', () => {
+    const dir = makeTempDir();
+    const lw = new LogWriter(dir, 'necessary');
+    const step = lw.openStep(1, 'implementation', 'P1');
+    step.writeHeader();
+    step.writeChunk('this should not appear');
+    step.writeFooter(true, 1000);
+
+    const content = readFileSync(step.filePath, 'utf8');
+    assert.ok(content.includes('P1'));
+    assert.ok(content.includes('ok'));
+    assert.ok(!content.includes('this should not appear'));
+    assert.ok(!existsSync(join(dir, 'last-message.txt')));
+  });
+
+  // ─── Log level: none ───────────────────────────────────────────────────────
+
+  test('none level does not create logs directory', () => {
+    const dir = join(makeTempDir(), 'should-not-exist');
+    new LogWriter(dir, 'none');
+    assert.ok(!existsSync(dir));
+  });
+
+  test('none level writes nothing', () => {
+    const dir = makeTempDir();
+    const lw = new LogWriter(dir, 'none');
+    const step = lw.openStep(1, 'implementation', 'P1');
+    step.writeHeader();
+    step.writeChunk('invisible');
+    step.writeFooter(true, 500);
+
+    assert.ok(!existsSync(step.filePath));
+  });
+
 });

package/ralph/test/phase-executor.test.mjs

@@ -95,7 +95,7 @@ describe('runImplementation', () => {
 
   test('returns the full response text from send()', async () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const send = makeFakeSend(['I implemented the CLI.']);
 
     const result = await runImplementation({
@@ -114,7 +114,7 @@ describe('runImplementation', () => {
 
   test('writes a step log with header and footer', async () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const send = makeFakeSend(['done']);
 
     const step = lw.openStep(1, 'implementation', PHASE.title);
@@ -141,7 +141,7 @@ describe('runImplementation', () => {
 
   test('isDryRun → does not call send, logs prompt instead', async () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     let sendCalled = false;
     const send = async () => { sendCalled = true; return ''; };
 
@@ -161,7 +161,7 @@ describe('runImplementation', () => {
 
   test('send() failure → throws PhaseExecutorError with phase and step info', async () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const send = async () => { throw new Error('network timeout'); };
 
     await assert.rejects(
@@ -186,7 +186,7 @@ describe('runImplementation', () => {
 
   test('step log preserved even when send() throws', async () => {
     const dir = makeTempDir();
-    const lw = new LogWriter(dir);
+    const lw = new LogWriter(dir, 'dump');
     const send = async (prompt, { onChunk } = {}) => {
       onChunk?.('partial…');
       throw new Error('boom');

package/ralph/test/verifier.test.mjs

@@ -17,7 +17,7 @@ const PHASE = {
 function makeSetup() {
   const dir = makeTempDir();
   const repoDir = makeTempRepo();
-  const lw = new LogWriter(dir);
+  const lw = new LogWriter(dir, 'dump');
   const repos = [{ name: 'r', path: repoDir }];
   return { dir, lw, repos };
 }