atris 3.71.2 → 3.72.0

package/commands/task.js

@@ -29,10 +29,10 @@ const {
   parseVerifyChain,
   parseVerifyCommand,
   runVerifyCommand,
-  runVerifyCommandCached,
   DENIED_TAGS,
 } = require('../lib/auto-accept-certified');
 const { evaluateAcceptVerify } = require('../lib/accept-verify-gate');
+const { checkedCodeSha, runVerifyAtJobCode } = require('../lib/job-code-verify');
 const { proveTaskLanding } = require('../lib/landing-proof');
 const {
   taskExplanation,
@@ -10645,22 +10645,44 @@ function stampVerifyCacheMetadata(taskDb, db, taskId, { verify, result, actor, w
     reason: (result && result.reason) || null,
     ran_at: new Date().toISOString(),
     ran_by: actor,
-    code_sha: currentHeadSha(workspaceRoot),
+    // The commit the check ran on: the job's own code when it has some,
+    // else the folder the job lives in.
+    code_sha: (result && result.code_sha) || currentHeadSha(workspaceRoot),
+    code_source: (result && result.code_source) || 'checkout',
   };
+  // A check is not a touch. Bumping updated_at here put every failed job at
+  // the front of the next pass, so the same six failing jobs won every hour.
   db.prepare(`
     UPDATE tasks
-       SET metadata = ?,
-           updated_at = ?
+       SET metadata = ?
      WHERE id = ?
-  `).run(JSON.stringify(metadata), Date.now(), taskId);
+  `).run(JSON.stringify(metadata), taskId);
+}
+
+// When a review job was last given a second check; never checked reads 0.
+function lastCheckedMs(task) {
+  const ranAt = Date.parse(String(task?.metadata?.verify_cache?.ran_at || ''));
+  return Number.isFinite(ranAt) ? ranAt : 0;
+}
+
+// The check already failed on exactly this code: running it again proves
+// nothing until the code changes.
+function failedOnSameCode(task, verify, codeSha) {
+  const cache = task?.metadata?.verify_cache;
+  return Boolean(cache && typeof cache === 'object' && cache.ok === false && cache.reason === 'verify_failed'
+    && cache.command === verify && codeSha && cache.code_sha === codeSha);
 }
 
 function cachedVerifyVerdict(task, root) {
   const metadata = (task && task.metadata) || {};
   const cache = metadata.verify_cache;
   if (!cache || typeof cache !== 'object') return { fresh: false, command: metadata.verify || null };
+  // A check run on the job's own code stays fresh until that code changes.
+  const currentCode = cache.code_source && cache.code_source !== 'checkout'
+    ? checkedCodeSha(task, root)
+    : currentHeadSha(task.workspace_root || root);
   const fresh = cache.command === metadata.verify
-    && (!cache.code_sha || cache.code_sha === currentHeadSha(task.workspace_root || root));
+    && (!cache.code_sha || cache.code_sha === currentCode);
   return { ...cache, fresh: Boolean(fresh) };
 }
 
@@ -10711,7 +10733,7 @@ function reverifyBeforeLanding(taskDb, db, task, { actor = 'autoland-verifier',
       revise_reason: revised.reason || null,
     };
   }
-  const result = runVerifyCommandCached(verify, task.workspace_root || process.cwd(), verifyCache);
+  const result = runVerifyAtJobCode(verify, task, { root: process.cwd(), cache: verifyCache });
   stampVerifyCacheMetadata(taskDb, db, task.id, { verify, result, actor, workspaceRoot: task.workspace_root });
   if (result.ok) return { ok: true, verify, result };
   const note = landingVerifyFailureNote(verify, result);
@@ -10731,7 +10753,10 @@ function reverifyBeforeLanding(taskDb, db, task, { actor = 'autoland-verifier',
 }
 
 function cmdCertifyVerified(args, options = {}) {
-  const dryRun = hasFlag(args, '--dry-run');
+  // preview: the hourly pass's dry run. Reads the named workspace's jobs and
+  // writes nothing, not even the task list file.
+  const preview = options.preview === true;
+  const dryRun = preview || hasFlag(args, '--dry-run');
   const asJson = wantsJson(args);
   const silent = options.silent === true;
   const verifyCache = options.verifyCache || null;
@@ -10741,13 +10766,18 @@ function cmdCertifyVerified(args, options = {}) {
 
   const taskDb = getTaskDb();
   const db = taskDb.open();
-  const { projection } = writeDefaultProjection(taskDb, db);
+  const projection = preview
+    ? enrichTaskProjection(taskDb.taskProjection(db, { workspaceRoot: options.workspaceRoot || taskDb.workspaceRoot(), limit: 500 }))
+    : writeDefaultProjection(taskDb, db).projection;
+  // Least recently checked first, oldest first among never-checked jobs. The
+  // limit counts checks that actually run, so skipped rows never use a turn.
   const candidates = (projection.tasks || [])
     .filter((t) => t && t.status === 'review')
-    .sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0))
-    .slice(0, max);
+    .sort((a, b) => lastCheckedMs(a) - lastCheckedMs(b) || Number(a.updated_at || 0) - Number(b.updated_at || 0));
   const results = [];
+  let checks = 0;
   for (const item of candidates) {
+    if (checks >= max) break;
     const fullProjection = enrichTaskProjection(taskDb.taskProjection(db, { taskId: item.id }));
     const task = fullProjection.tasks[0] || null;
     if (!task) {
@@ -10809,11 +10839,16 @@ function cmdCertifyVerified(args, options = {}) {
       results.push({ ref, action: 'skipped', reason: 'no_runnable_check_in_proof' });
       continue;
     }
+    if (failedOnSameCode(task, verify, checkedCodeSha(task, process.cwd()))) {
+      results.push({ ref, action: 'skipped', reason: 'failed_on_this_code', verify });
+      continue;
+    }
+    checks += 1;
     if (dryRun) {
       results.push({ ref, action: 'would_certify', verify });
       continue;
     }
-    const run = runVerifyCommandCached(verify, task.workspace_root || process.cwd(), verifyCache);
+    const run = runVerifyAtJobCode(verify, task, { root: process.cwd(), cache: verifyCache });
     stampVerifyCacheMetadata(taskDb, db, task.id, { verify, result: run, actor, workspaceRoot: task.workspace_root });
     if (!run.ok) {
       results.push({ ref, action: 'verify_failed', reason: run.reason, verify });
@@ -10840,7 +10875,7 @@ function cmdCertifyVerified(args, options = {}) {
     const certifiedNow = readied.event?.payload?.agent_certified === true;
     results.push({ ref, action: certifiedNow ? 'certified' : 'pass_recorded', verify });
   }
-  const { outPath } = writeDefaultProjection(taskDb, db);
+  const outPath = preview ? null : writeDefaultProjection(taskDb, db).outPath;
   const certified = results.filter((r) => r.action === 'certified').length;
   const payload = {
     ok: true,
@@ -13698,6 +13733,7 @@ module.exports = {
   delegateTask,
   AGENT_ENV_MARKERS,
   autoRenderTodoFromDb,
+  cmdCertifyVerified,
   refreshKeptTaskList,
   keptCount,
   projectionMissions,

package/commands/worktree.js

@@ -16,6 +16,9 @@ const close = require('./close');
 // parallel landings that each carry a copy always clash.
 const REGEN_ADAPTER_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md', '.atris/state/tasks.projection.json'];
 const COMMAND_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+// Push also runs local hooks. Backend startup and regression checks alone can
+// exceed the short network-only allowance used by fetch and discovery.
+const GIT_PUSH_TIMEOUT_MS = 5 * 60 * 1000;
 const GIT_OID_PATTERN = /^[0-9a-f]{40,64}$/;
 const ONE_LAP_PROOF_REF_PATTERN = /^refs\/atris\/one-lap\/([0-9a-f]{40,64})$/;
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -37,13 +40,15 @@ function gitNetworkEnvironment(source = process.env, cwd = process.cwd()) {
 // A killed network call leaves stderr empty; name the timeout instead.
 function gitFailureDetail(result) {
   if (result && result.error && result.error.code === 'ETIMEDOUT') return 'timed out';
-  return String((result && (result.stderr || result.stdout)) || '').trim();
+  return [result && result.stdout, result && result.stderr]
+    .map(output => String(output || '').trim()).filter(Boolean).join('\n');
 }
 
 function runGit(args, { cwd = process.cwd(), check = true, timeout } = {}) {
   const network = ['fetch', 'push', 'ls-remote'].includes(args[0]);
   // Only network calls need the SSH probe; local calls skip its extra git spawn.
-  const options = { cwd, encoding: 'utf8', timeout: timeout ?? (network ? 30000 : undefined),
+  const defaultTimeout = args[0] === 'push' ? GIT_PUSH_TIMEOUT_MS : network ? 30000 : undefined;
+  const options = { cwd, encoding: 'utf8', timeout: timeout ?? defaultTimeout,
     killSignal: 'SIGKILL', env: network ? gitNetworkEnvironment(process.env, cwd) : undefined };
   let result = spawnSync('git', args, options);
   // Linked checkouts share config. A concurrent start must not silently lose
@@ -1118,6 +1123,23 @@ function shipWorktree(args) {
         if (/already merged/i.test(`${merged.stdout}${merged.stderr}`)) {
           throw new Error(`gh pr merge reported the PR was already merged (stale PR reused): ${(merged.stdout || merged.stderr).trim()}`);
         }
+        // A merge queue accepts the request before merging. Deleting its head
+        // here closes the PR and cancels that request, so confirm the outcome.
+        const confirmation = spawnSync('gh', ['pr', 'view', mergeRef, '--json', 'state,mergedAt'], { cwd: root, encoding: 'utf8' });
+        if (confirmation.status !== 0) {
+          throw new Error('could not confirm the merge; the source branch was kept');
+        }
+        let state;
+        try { state = JSON.parse(confirmation.stdout); } catch {
+          throw new Error('could not read the merge result; the source branch was kept');
+        }
+        if (state.state === 'OPEN' && !state.mergedAt) {
+          console.log('merge: pending; kept the source branch while required checks finish');
+          return 0;
+        }
+        if (state.state !== 'MERGED' || !state.mergedAt) {
+          throw new Error('the change was not merged; the source branch was kept');
+        }
         console.log('merge: merged');
         const deleted = runGit(['push', 'origin', '--delete', branch], { cwd: root, check: false });
         if (deleted.status === 0) {

package/commands/zen.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const { abandonedDaysFromEnv, checkZen, sideCopyLines } = require('../lib/zen');
+const { applyZen } = require('../lib/zen-apply');
+const { workspaceZen } = require('../lib/zen-workspace');
+
+function showZenHelp() {
+  console.log('usage: atris zen [--check] [--no-fetch] [--json]');
+  console.log('');
+  console.log('Brings this repo to zen: code matches origin, nothing left lying around.');
+  console.log('Old stashes are archived, idle side copies put away, finished branches');
+  console.log('cleared, stray code edits saved to a zen-backup/ branch, and the main');
+  console.log('branch caught up. Only branches already on origin are cleared, so nothing');
+  console.log('is lost, and everything else can be brought back. Team notes');
+  console.log('in atris/ and agent config stay as they are. Anything touched in the last');
+  console.log('30 minutes is left alone. A side copy with unsaved work nobody has touched in');
+  console.log('3 days is saved to a zen-backup/ branch and put away. A side copy locked with git worktree lock');
+  console.log('always stays. Then the workspace is tidied with atris clean, and');
+  console.log('anything only you can do is listed with the one command that does it.');
+  console.log('');
+  console.log('  --check      Only look. Report what is out of place and change nothing.');
+  console.log('  --no-fetch   Use the last fetched origin instead of fetching.');
+  console.log('  --json       Print machine-readable results.');
+  console.log('');
+  console.log('Add more team-state paths in .atris/zen.json: {"team_state": ["logs/"]}');
+}
+
+function pause(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function makeOut(calm) {
+  const dim = (text) => (calm ? `\x1b[2m${text}\x1b[0m` : text);
+  const line = (text = '', ms = 110) => {
+    console.log(text);
+    if (calm && text) pause(ms);
+  };
+  // One raked line, drawn left to right.
+  const rake = (width = 34) => {
+    if (!calm) {
+      console.log(`  ${'─'.repeat(width)}`);
+      return;
+    }
+    process.stdout.write('  ');
+    for (let i = 0; i < width; i += 1) {
+      process.stdout.write(dim('─'));
+      pause(14);
+    }
+    process.stdout.write('\n');
+    pause(160);
+  };
+  return { dim, line, rake };
+}
+
+function teamLine(n) {
+  if (!n) return 'no team notes changed.';
+  return n === 1 ? '1 team note kept as it is.' : `${n} team notes kept as they are.`;
+}
+
+function printYours(yours, line, dim) {
+  const width = Math.max(...yours.map((item) => item.text.length));
+  for (const item of yours) line(`  ${item.text.padEnd(width)}   ${dim(item.cmd)}`);
+}
+
+function printCheck(result, workspace) {
+  const kept = result.team_files
+    ? (result.team_files === 1 ? '1 team file kept as it is' : `${result.team_files} team files kept as they are`)
+    : 'no team files changed';
+  const stale = result.fetched === false ? ' (could not reach origin, using last fetch)' : '';
+  const tidy = workspace?.todo.length || 0;
+  if (result.zen && tidy) {
+    console.log(`zen: almost, the code is calm and the workspace has ${tidy} ${tidy === 1 ? 'thing' : 'things'} to tidy`);
+    console.log(`  code matches ${result.upstream}${stale}`);
+    console.log(`  ${kept}`);
+    console.log('  run atris zen to make it zen');
+  } else if (result.zen) {
+    console.log('zen: yes');
+    console.log(`  code matches ${result.upstream}${stale}`);
+    console.log(`  ${kept}`);
+  } else {
+    const n = result.problems.length;
+    console.log(`zen: no, ${n} ${n === 1 ? 'thing is' : 'things are'} out of place${stale}`);
+    for (const problem of result.problems) console.log(`  - ${problem.text}`);
+    console.log(`  ${kept}`);
+    console.log('  run atris zen to make it zen');
+  }
+  if (result.worktrees_with_work.length) {
+    for (const text of sideCopyLines(result.worktrees_with_work, abandonedDaysFromEnv())) console.log(`  ${text}`);
+  }
+  const held = result.worktrees_locked?.length || 0;
+  if (held) {
+    console.log(`  ${held} side ${held === 1 ? 'copy is locked by its owner' : 'copies are locked by their owners'}, left alone`);
+  }
+  const live = result.worktrees_in_use?.length || 0;
+  if (live) {
+    const mins = result.fresh_minutes;
+    console.log(`  ${live} side ${live === 1 ? 'copy was' : 'copies were'} used in the last ${mins} ${mins === 1 ? 'minute' : 'minutes'}, left alone`);
+  }
+  if (workspace?.todo.length) {
+    console.log('workspace:');
+    for (const text of workspace.todo) console.log(`  - ${text}`);
+  }
+  if (workspace?.yours.length) {
+    console.log('for you:');
+    printYours(workspace.yours, (text) => console.log(text), (text) => text);
+  }
+}
+
+function printApply(result, out) {
+  const { dim, line, rake } = out;
+  line('');
+  line('  atris zen', 200);
+  line('');
+  rake();
+  line('');
+  line(dim('  code'));
+  if (!result.done.length && result.zen) line(`  matches ${result.upstream || 'origin'}`);
+  for (const text of result.done) line(`  ${text}`);
+  for (const text of [...result.left, ...result.notes]) line(dim(`  ${text}`));
+  line('');
+  const ws = result.workspace || { done: [], yours: [] };
+  if (ws.ran) {
+    line(dim('  workspace'));
+    if (!ws.done.length) line('  tidy');
+    for (const text of ws.done) line(`  ${text}`);
+    line('');
+  }
+  if (ws.yours?.length) {
+    line(dim('  for you'));
+    printYours(ws.yours, line, dim);
+    line('');
+  }
+  if (result.zen) {
+    line(`  ${result.already ? 'already zen.' : 'zen.'}`, 260);
+  } else {
+    line('  almost zen. still out of place:');
+    for (const text of result.remaining) line(dim(`  - ${text}`));
+  }
+  line(dim(`  ${teamLine(result.team_files)}`));
+  if (result.saved.length) {
+    line(dim('  everything is kept: git for-each-ref refs/archive refs/heads/zen-backup'));
+  }
+  line('');
+}
+
+function zenCommand(args = [], cwd = process.cwd()) {
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    showZenHelp();
+    return 0;
+  }
+  const fetch = !args.includes('--no-fetch');
+  const json = args.includes('--json');
+
+  if (args.includes('--check')) {
+    const result = checkZen({ cwd, fetch });
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+      return result.ok ? (result.zen ? 0 : 1) : 2;
+    }
+    if (!result.ok) {
+      console.log(`zen: can't check, ${result.error}.`);
+      return 2;
+    }
+    const workspace = workspaceZen({ root: result.root, dryRun: true });
+    printCheck(result, workspace);
+    return result.zen && !workspace.todo.length ? 0 : 1;
+  }
+
+  const result = applyZen({ cwd, fetch });
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.ok ? (result.zen ? 0 : 1) : 2;
+  }
+  if (!result.ok) {
+    console.log(`zen: can't start, ${result.error}.`);
+    return 2;
+  }
+  const calm = Boolean(process.stdout.isTTY) && !process.env.CI;
+  printApply(result, makeOut(calm));
+  return result.zen ? 0 : 1;
+}
+
+module.exports = { zenCommand, showZenHelp };

package/lib/auto-accept-certified.js

@@ -1157,8 +1157,13 @@ function agentBranchOnlyResult(ref, resolved) {
   };
 }
 
-function runResolvedVerify(resolved, workspaceRoot, cache) {
-  const result = runVerifyCommandCached(resolved.verify, workspaceRoot, cache);
+// A check recorded from main runs against the job's own code, the same place
+// the second check ran it (lib/job-code-verify.js), so the landing gate never
+// judges a branch-only test by the main folder.
+function runResolvedVerify(resolved, task, workspaceRoot, cache) {
+  const result = resolved.rewritten
+    ? runVerifyCommandCached(resolved.verify, workspaceRoot, cache)
+    : require('./job-code-verify').runVerifyAtJobCode(resolved.verify, task, { root: workspaceRoot, cache });
   if (resolved.rewritten && result.reason === 'verify_failed') {
     return { ...result, reason: 'verify_failed_on_main', recorded_verify: resolved.recorded };
   }
@@ -1258,7 +1263,7 @@ function evaluateAutoAccept(task, options = {}) {
     if (tierRequiresStrictVerify && !verify) return strictVerifyMissingResult(ref);
     if (resolvedVerify.missing) return agentBranchOnlyResult(ref, resolvedVerify);
     if (verify && executeVerify) {
-      const verifyResult = runResolvedVerify(resolvedVerify, task.workspace_root || process.cwd(), verifyCache);
+      const verifyResult = runResolvedVerify(resolvedVerify, task, task.workspace_root || process.cwd(), verifyCache);
       // A check that runs and fails blocks. So does a check whose worktree
       // is gone, otherwise the daily reap converts "has a failing check"
       // into "lands unchecked" the morning after it clears the worktree.
@@ -1361,7 +1366,7 @@ function evaluateAutoAccept(task, options = {}) {
     if (resolvedVerify.missing) return agentBranchOnlyResult(ref, resolvedVerify);
     if (executeVerify) {
       const workspaceRoot = task.workspace_root || process.cwd();
-      const verifyResult = runResolvedVerify(resolvedVerify, workspaceRoot, verifyCache);
+      const verifyResult = runResolvedVerify(resolvedVerify, task, workspaceRoot, verifyCache);
       if (!verifyResult.ok) {
         return { eligible: false, ref, reason: verifyResult.reason, verify, ...verifyResult };
       }

package/lib/campaign-cadence.js

@@ -11,6 +11,7 @@ const fs = require('fs');
 const path = require('path');
 const { paysDollars } = require('./campaign-core');
 const { getCampaign, openCampaignStore } = require('./campaign-store');
+const { readingKey } = require('./campaign-loop');
 
 const LESSON_LINES_FOR_PLANNING = 30;
 
@@ -26,18 +27,45 @@ function lessonsPath(root, campaignId) {
   return path.join(root, 'atris', 'campaigns', campaignId, 'lessons.md');
 }
 
-// The newest lessons, for the planner.
-function readLessons(root, campaignId, lines = LESSON_LINES_FOR_PLANNING) {
+function globalLessonsPath(root) {
+  return path.join(root, 'atris', 'campaigns', 'lessons.md');
+}
+
+function parseBulletLines(filePath) {
   try {
-    const text = fs.readFileSync(lessonsPath(root, campaignId), 'utf8');
-    return text.split('\n').filter((line) => line.trim().startsWith('- ')).slice(-lines).join('\n');
+    const text = fs.readFileSync(filePath, 'utf8');
+    return text.split('\n').filter((line) => {
+      const bullet = line.trim();
+      return bullet.startsWith('- ') && bullet !== '- (no review written this round)';
+    });
   } catch {
-    return '';
+    return [];
+  }
+}
+
+// The newest lessons for the planner: local campaign lessons plus deduplicated
+// cross-campaign RSI lessons so every new campaign inherits earlier lessons.
+function readLessons(root, campaignId, lines = LESSON_LINES_FOR_PLANNING) {
+  const local = parseBulletLines(lessonsPath(root, campaignId));
+  const global = parseBulletLines(globalLessonsPath(root));
+  const seen = new Set();
+  const merged = [];
+  for (const line of [...local, ...global]) {
+    const key = line.trim().toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(line);
   }
+  return merged.slice(-lines).join('\n');
 }
 
 function roundSummary(before, after) {
-  const fresh = after.missions.filter((m) => !before.missions.some((b) => b.id === m.id && b.status === m.status));
+  const previous = new Map();
+  for (const { id, status } of before.missions) {
+    if (!previous.has(id)) previous.set(id, new Set());
+    previous.get(id).add(status);
+  }
+  const fresh = after.missions.filter((m) => !previous.get(m.id)?.has(m.status));
   const kept = fresh.filter((m) => m.status === 'ended' && m.outcome === 'kept').length;
   const failed = fresh.filter((m) => m.status === 'ended' && m.outcome !== 'kept').length;
   const vetoed = fresh.filter((m) => m.status === 'vetoed').length;
@@ -45,6 +73,12 @@ function roundSummary(before, after) {
   return { kept, failed, vetoed, spent, fresh };
 }
 
+// Nothing finished and the check reads the same: there is nothing to learn.
+function quietRound(before, after, summary) {
+  const key = (v) => (v.last_judge ? readingKey(v.last_judge.passed, v.last_judge.reading, v.answer.text) : null);
+  return !summary.fresh.some((m) => m.status === 'ended' || m.status === 'vetoed') && key(before) === key(after);
+}
+
 // On a subscription the round is told without dollars, since none were paid.
 function roundTally(view, summary) {
   return `${summary.kept} kept, ${summary.failed} failed${paysDollars(view) ? `, $${summary.spent} spent` : ''}`;
@@ -82,9 +116,10 @@ function makeCadence(root, loop, options = {}, deps = {}) {
   async function review(id, before) {
     const after = getCampaign(store, id);
     const summary = roundSummary(before, after);
+    const quiet = quietRound(before, after, summary);
     const lessons = readLessons(root, id, 200);
     let written = [];
-    if (ask) {
+    if (ask && !quiet) {
       const answer = await ask(root, after, reviewPrompt(after, summary, lessons));
       // A lesson already on file is not written twice.
       const known = new Set(lessons.split('\n').map((line) => line.trim().toLowerCase()));
@@ -96,8 +131,10 @@ function makeCadence(root, loop, options = {}, deps = {}) {
     if (!fs.existsSync(file)) fs.writeFileSync(file, `# Lessons: ${after.title}\n\nWritten by the owner at each review; the next round plans from them.\n`);
     const stamp = new Date(now()).toISOString().slice(0, 16).replace('T', ' ');
     const header = `\n## ${stamp}: ${roundTally(after, summary)}\n`;
-    fs.appendFileSync(file, `${header}${(written.length ? written : ['- (no review written this round)']).join('\n')}\n`);
-    return { summary, lessons: written, view: after };
+    // A quiet round is noted as plain text, so the planner never reads it as a lesson.
+    const body = quiet ? ['(no review written this round: nothing ended and the reading held)'] : (written.length ? written : ['- (no review written this round)']);
+    fs.appendFileSync(file, `${header}${body.join('\n')}\n`);
+    return { summary, lessons: written, view: after, quiet };
   }
 
   async function run(id) {
@@ -109,27 +146,29 @@ function makeCadence(root, loop, options = {}, deps = {}) {
       const until = now() + workMs;
       log(`round ${round}: working until ${new Date(until).toISOString().slice(11, 16)}`);
       let stopped = null;
+      let failed = false;
       while (now() < until) {
         const result = await loop.step(id);
         if (result.stop) {
           stopped = result.reason;
+          failed = result.ok === false;
           break;
         }
       }
       const breakStarted = now();
       log(`round ${round}: review`);
-      const { summary, lessons, view: reviewed } = await review(id, before);
-      log(`  ${roundTally(reviewed, summary)}; ${lessons.length} lesson${lessons.length === 1 ? '' : 's'} written`);
+      const { summary, lessons, view: reviewed, quiet } = await review(id, before);
+      log(quiet ? '  nothing new this round; no review' : `  ${roundTally(reviewed, summary)}; ${lessons.length} lesson${lessons.length === 1 ? '' : 's'} written`);
       const view = getCampaign(store, id);
-      last = { reason: stopped || 'work window ended', round };
+      last = { reason: stopped || 'work window ended', round, failed };
       // Finished, out of money, or waiting on a person: no point in another round.
       if (['done', 'out_of_budget', 'needs_you', 'paused'].includes(view.state) || (stopped && !/missions running|nothing usable/.test(stopped))) {
-        return { rounds: round, reason: stopped || view.state, campaign: view };
+        return { ...(failed ? { ok: false } : {}), rounds: round, reason: stopped || view.state, campaign: view };
       }
       const rest = breakMs - (now() - breakStarted);
       if (round < rounds && rest > 0) await sleep(rest);
     }
-    return { rounds: round, reason: last.reason, campaign: getCampaign(store, id) };
+    return { ...(last.failed ? { ok: false } : {}), rounds: round, reason: last.reason, campaign: getCampaign(store, id) };
   }
 
   return { run, review };