atris 3.69.0 → 3.71.0

package/commands/worktree.js

@@ -5,12 +5,16 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const { hasFlag, readFlag } = require('../lib/arg-parser');
 const { stampLatestOpenBriefForWorktree } = require('../lib/brief-ledger');
-const { isConductorArtifact } = require('../lib/conductor-artifacts');
+const { isConductorArtifact, isConductorUntracked } = require('../lib/conductor-artifacts');
 const { fixMapDocs } = require('../lib/map-refs');
 const { sleepSync } = require('../lib/sleep-sync');
 const close = require('./close');
 
-const REGEN_ADAPTER_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
+// Files atris regenerates on its own. Unstaged churn in them is restored
+// before ship commits, unless the commit message names the file. The task
+// projection is rewritten by any task command run in a work folder, and two
+// 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;
 const GIT_OID_PATTERN = /^[0-9a-f]{40,64}$/;
 const ONE_LAP_PROOF_REF_PATTERN = /^refs\/atris\/one-lap\/([0-9a-f]{40,64})$/;
@@ -159,6 +163,34 @@ function branchName(member, task, now = new Date()) {
   return `codex/${slugify(member, 'member', 24)}-${slugify(task, 'task', 36)}-${stamp(now)}`;
 }
 
+// The newest earlier run of this same member+job, if its commits never reached
+// the base, so a retry continues that work instead of redoing it. Only the
+// newest run counts: once it landed or did nothing, anything older is stale.
+function lastRunBranch(root, owner, task, base, skip) {
+  const prefix = `codex/${slugify(owner, 'member', 24)}-${slugify(task, 'task', 36)}-`;
+  const listed = runGit(['for-each-ref', '--format=%(refname:short)', `refs/heads/${prefix}*`], { cwd: root, check: false });
+  if (listed.status !== 0) return null;
+  // Only exact runs of this job (stamp plus optional same-second number), so
+  // "fix-login" never matches "fix-login-page".
+  const runs = listed.stdout.split('\n').map((name) => name.trim())
+    .map((name) => ({ name, run: name.slice(prefix.length).match(/^(\d{8}-\d{6})(?:-(\d+))?$/) }))
+    .filter(({ name, run }) => run && name !== skip)
+    .sort((a, b) => b.run[1].localeCompare(a.run[1]) || Number(b.run[2] || 1) - Number(a.run[2] || 1));
+  if (!runs.length) return null;
+  const newest = runs[0].name;
+  const cherry = runGit(['cherry', base, newest], { cwd: root, check: false });
+  if (cherry.status !== 0) return null;
+  return cherry.stdout.split('\n').some((line) => line.startsWith('+')) ? newest : null;
+}
+
+// True only when git proves the branch no longer merges cleanly with the base.
+// merge-tree --write-tree exits 1 on conflict; an error or old git keeps the
+// resume as before.
+function conflictsWithBase(root, base, branch) {
+  const result = runGit(['merge-tree', '--write-tree', '--name-only', base, branch], { cwd: root, check: false });
+  return result.status === 1;
+}
+
 function defaultWorktreePath(root, member, task, now = new Date()) {
   const name = `${slugify(member, 'member', 24)}-${slugify(task, 'task', 36)}-${stamp(now)}`;
   return path.join(path.dirname(root), '.agent-worktrees', path.basename(root), name);
@@ -446,10 +478,30 @@ function statusCounts(root, {
 
 // Remove conductor plumbing from the index after a broad `git add -A`, so the commit
 // records engine output only. Paths that were never staged are simply not listed.
+// GitHub refuses a merge with "Base branch was modified" when another PR
+// merged into the same base a moment earlier; the same merge succeeds on a
+// second try. On 2026-10-15 five parallel dispatches lost three landings to
+// it. Retry only that message, a few times, with a short wait.
+const BASE_MODIFIED_PATTERN = /Base branch was modified/i;
+function mergePrWithRetry(mergeArgs, root, { run = spawnSync, wait = sleepSync, attempts = 4 } = {}) {
+  let merged = run('gh', mergeArgs, { cwd: root, encoding: 'utf8' });
+  for (let attempt = 1; attempt < attempts && merged.status !== 0
+    && BASE_MODIFIED_PATTERN.test(`${merged.stderr || ''}${merged.stdout || ''}`); attempt += 1) {
+    console.log(`merge: base branch moved, retrying (${attempt + 1}/${attempts})`);
+    wait(1500 * attempt);
+    merged = run('gh', mergeArgs, { cwd: root, encoding: 'utf8' });
+  }
+  return merged;
+}
+
 function unstageConductorArtifacts(root) {
   const staged = runGit(['diff', '--cached', '--name-only'], { cwd: root, check: false });
   if (staged.status !== 0) return [];
-  const drop = String(staged.stdout || '').split(/\r?\n/).filter(Boolean).filter(isConductorArtifact);
+  const added = runGit(['diff', '--cached', '--name-only', '--diff-filter=A'], { cwd: root, check: false });
+  const newFiles = new Set(String(added.stdout || '').split(/\r?\n/).filter(Boolean));
+  // A file this commit would add under .atris/ is the tool's own state, never work.
+  const drop = String(staged.stdout || '').split(/\r?\n/).filter(Boolean)
+    .filter((file) => isConductorArtifact(file) || (newFiles.has(file) && isConductorUntracked(file)));
   if (drop.length) runGit(['reset', '-q', 'HEAD', '--', ...drop], { cwd: root, check: false });
   return drop;
 }
@@ -529,8 +581,18 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     reapedBeforeStart = cleaned.removed;
     cachePrunedBeforeStart = cleaned.cachePruned;
   } catch {}
-  const branch = branchOverride || branchName(owner, task, now);
-  const target = path.resolve(pathOverride || defaultWorktreePath(root, owner, task, now));
+  let branch = branchOverride || branchName(owner, task, now);
+  let target = path.resolve(pathOverride || defaultWorktreePath(root, owner, task, now));
+  // Two runs of the same job in the same second get the same name; number
+  // the later one instead of failing it.
+  if (!pathOverride && !branchOverride) {
+    const baseBranch = branch;
+    const baseTarget = target;
+    for (let n = 2; fs.existsSync(target) && n < 100; n += 1) {
+      branch = `${baseBranch}-${n}`;
+      target = `${baseTarget}-${n}`;
+    }
+  }
   // Agent/member worktrees always cut from the mainline: honoring the
   // launcher checkout's upstream let a dispatch inherit another session's
   // in-progress feature branch (2026-07-09: an auth fix arrived carrying 13
@@ -540,9 +602,24 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
   if (fs.existsSync(target)) throw new Error(`worktree path already exists: ${target}`);
   fs.mkdirSync(path.dirname(target), { recursive: true });
   const staleBase = refreshRemoteRef(root, checkoutBase);
+  // A retry of the same job starts from the last run's unlanded commits; it
+  // still ships to the mainline.
+  let resumedFrom = (!pathOverride && !branchOverride)
+    ? lastRunBranch(root, owner, task, checkoutBase, branch)
+    : null;
+  // A last run that now conflicts with the mainline would hand its conflict
+  // to the retry, which then cannot land on the first try. Start fresh; the
+  // old branch keeps its commits.
+  let skippedResume = null;
+  if (resumedFrom && conflictsWithBase(root, checkoutBase, resumedFrom)) {
+    skippedResume = resumedFrom;
+    resumedFrom = null;
+    console.error(`note: the last run's branch ${skippedResume} no longer merges cleanly with ${checkoutBase}, so this run starts fresh; that branch keeps its commits`);
+  }
+  const startPoint = resumedFrom || checkoutBase;
   const ref = `refs/heads/${branch}`;
   const existed = runGit(['show-ref', '--verify', '--quiet', ref], { cwd: root, check: false }).status !== 1;
-  const baseCommit = runGit(['rev-parse', '--verify', `${checkoutBase}^{commit}`], { cwd: root, check: false });
+  const baseCommit = runGit(['rev-parse', '--verify', `${startPoint}^{commit}`], { cwd: root, check: false });
   const startCommit = baseCommit.status === 0 ? baseCommit.stdout.trim() : '';
   // With no local copy the start fails on its own; only a real cut gets the warning.
   if (staleBase && startCommit) {
@@ -554,7 +631,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     if (registered) {
       if (!fs.existsSync(target) || fs.realpathSync(registered.path) !== fs.realpathSync(target)
         || registered.head !== startCommit) return;
-      const dirt = statusCounts(target, { ignoreUntracked: isConductorArtifact });
+      const dirt = statusCounts(target, { ignoreUntracked: isConductorUntracked });
       if (!dirt || dirt.staged || dirt.unstaged || dirt.untracked) return;
       // No engine has started. Normal removal still refuses unexpected dirt.
       runGit(['worktree', 'remove', target], { cwd: root });
@@ -562,7 +639,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     if (!fs.existsSync(target)) runGit(['update-ref', '-d', ref, startCommit], { cwd: root });
   };
   for (let attempt = 0; attempt < 3; attempt += 1) {
-    const added = runGit(['worktree', 'add', '-b', branch, target, checkoutBase], { cwd: root, check: false });
+    const added = runGit(['worktree', 'add', '-b', branch, target, startPoint], { cwd: root, check: false });
     if (added.status === 0) break;
     // Git can create the branch before failing to write its tracking config.
     // Drop only that untouched ref, never an existing branch or a checkout.
@@ -572,6 +649,15 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     }
     sleepSync(100 * (attempt + 1));
   }
+  // A resumed branch takes in what the mainline gained since, or a job that
+  // keeps resuming drifts further behind every run until it clashes
+  // (2026-10-15: five long jobs sat 103 to 129 commits behind). The clash
+  // check above proved this merge is clean; if git still refuses, the run
+  // keeps the old start instead of failing.
+  if (resumedFrom) {
+    const caughtUp = runGit(['merge', '--no-edit', '-m', `Merge ${checkoutBase} into ${branch}`, checkoutBase], { cwd: target, check: false });
+    if (caughtUp.status !== 0) runGit(['merge', '--abort'], { cwd: target, check: false });
+  }
   try {
     runGit(['config', `branch.${branch}.atris-base`, shipBase], { cwd: target });
     runGit(['config', `branch.${branch}.atris-owner`, owner], { cwd: target });
@@ -587,6 +673,8 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
         branch,
         base: shipBase,
         checkout_base: checkoutBase,
+        resumed_from: resumedFrom,
+        skipped_resume: skippedResume,
         workspace_root: root,
         created_at: now.toISOString(),
       }, null, 2) + '\n',
@@ -596,7 +684,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     discardFailedStart();
     throw error;
   }
-  return { path: target, branch, base: shipBase, checkoutBase, owner, reapedBeforeStart, cachePrunedBeforeStart };
+  return { path: target, branch, base: shipBase, checkoutBase, resumedFrom, skippedResume, owner, reapedBeforeStart, cachePrunedBeforeStart };
 }
 
 function startWorktree(args) {
@@ -912,7 +1000,7 @@ function shipWorktree(args) {
   const ignoredUnstagedFiles = dryRun ? new Set(skippedAdapters) : new Set();
   // Conductor plumbing must not make the checkout look dirty, or a flight where the
   // engine wrote nothing commits the fleet's own prompt file and calls it work.
-  const counts = statusCounts(root, { ignoredUnstagedFiles, ignoreUntracked: isConductorArtifact })
+  const counts = statusCounts(root, { ignoredUnstagedFiles, ignoreUntracked: isConductorUntracked })
     || { staged: 0, unstaged: 0, untracked: 0 };
   const dirty = counts.staged || counts.unstaged || counts.untracked;
   if (dirty && !message) {
@@ -952,7 +1040,7 @@ function shipWorktree(args) {
     // already present before the verifier ran, so counting it here blocks a clean ship.
     const afterVerify = dryRun
       ? { staged: 0, unstaged: 0, untracked: 0 }
-      : statusCounts(root, { ignoreUntracked: isConductorArtifact })
+      : statusCounts(root, { ignoreUntracked: isConductorUntracked })
         || { staged: 0, unstaged: 0, untracked: 0 };
     if (!dryRun && (afterVerify.staged || afterVerify.unstaged || afterVerify.untracked)) {
       console.error(
@@ -992,7 +1080,7 @@ function shipWorktree(args) {
             throw new Error((switched.stderr || switched.stdout || `git switch ${targetBranch} failed`).trim());
           }
         }
-        const primaryCounts = statusCounts(primary, { ignoreUntracked: isConductorArtifact }) || { staged: 0, unstaged: 0, untracked: 0 };
+        const primaryCounts = statusCounts(primary, { ignoreUntracked: isConductorUntracked }) || { staged: 0, unstaged: 0, untracked: 0 };
         if (primaryCounts.staged || primaryCounts.unstaged || primaryCounts.untracked) {
           throw new Error(
             `primary checkout dirty staged=${primaryCounts.staged} ` +
@@ -1023,7 +1111,7 @@ function shipWorktree(args) {
         const mergeArgs = ['pr', 'merge'];
         if (mergeRef) mergeArgs.push(mergeRef);
         mergeArgs.push('--merge');
-        const merged = spawnSync('gh', mergeArgs, { cwd: root, encoding: 'utf8' });
+        const merged = mergePrWithRetry(mergeArgs, root);
         if (merged.status !== 0) throw new Error((merged.stderr || merged.stdout || 'gh pr merge failed').trim());
         // `gh pr merge` on an already-merged PR exits 0 with a warning
         // instead of failing, which would otherwise report a false landing.
@@ -1067,7 +1155,7 @@ function guard(args) {
   // Conductor plumbing (worktree metadata, the fleet prompt written for this very
   // engine, runtime scratch, the brief ledger) must not count as dirt, otherwise the
   // harness blocks the engine with the harness's own files.
-  const counts = statusCounts(root, { ignoreUntracked: isConductorArtifact });
+  const counts = statusCounts(root, { ignoreUntracked: isConductorUntracked });
   if (counts && (counts.staged || counts.unstaged || counts.untracked) && !hasFlag(args, '--allow-dirty')) {
     console.error(`blocked: checkout is dirty staged=${counts.staged} unstaged=${counts.unstaged} untracked=${counts.untracked}`);
     return 3;
@@ -1125,12 +1213,14 @@ function canonicalPath(value) {
   }
 }
 
+// null means the scan failed: we cannot tell who is inside, so callers keep
+// every folder. An empty list would read as "nobody is here" and delete.
 function listActiveProcessCwds() {
   const result = spawnSync('lsof', ['-n', '-a', '-d', 'cwd', '-F', 'n'], {
     encoding: 'utf8',
     maxBuffer: COMMAND_MAX_BUFFER_BYTES,
   });
-  if (result.status !== 0) return [];
+  if (result.error || result.status !== 0) return null;
   return String(result.stdout || '')
     .split(/\r?\n/)
     .filter((line) => line.startsWith('n'))
@@ -1138,7 +1228,45 @@ function listActiveProcessCwds() {
     .filter(Boolean);
 }
 
+// Absolute paths named on each program's command line, including flag values
+// like --require=/x.js. A program can run a script from a work folder while
+// its current folder is elsewhere; the folder scan alone misses it. The list
+// prints arguments unquoted, so a path with a space is also kept as the rest
+// of the line from where it starts; the folder match is a prefix check.
+function parseProcessArgPaths(psOutput) {
+  const paths = new Set();
+  const starts = /(?:^|\s)(?:[^\s=]*=)?(?=\/)/g;
+  for (const raw of String(psOutput || '').split(/\r?\n/)) {
+    const line = raw.trim();
+    for (const match of line.matchAll(starts)) {
+      const rest = line.slice(match.index + match[0].length);
+      const token = rest.split(/\s/, 1)[0];
+      if (token.length > 1) paths.add(token);
+      if (rest.length > token.length) paths.add(rest);
+    }
+  }
+  return [...paths];
+}
+
+function listActiveProcessArgPaths() {
+  const result = spawnSync('ps', ['-axww', '-o', 'args='], {
+    encoding: 'utf8',
+    maxBuffer: COMMAND_MAX_BUFFER_BYTES,
+  });
+  if (result.error || result.status !== 0) return [];
+  return parseProcessArgPaths(result.stdout);
+}
+
+// Everything a running program is anchored to: its current folder plus any
+// script path on its command line.
+function listActiveProcessPaths() {
+  const cwds = listActiveProcessCwds();
+  if (!Array.isArray(cwds)) return cwds;
+  return cwds.concat(listActiveProcessArgPaths());
+}
+
 function worktreeHasActiveProcess(worktreePath, activeCwds) {
+  if (!Array.isArray(activeCwds)) return true;
   const resolved = canonicalPath(worktreePath);
   const prefix = `${resolved}${path.sep}`;
   return activeCwds.some((cwd) => {
@@ -1186,7 +1314,7 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
   const worktrees = listWorktrees(root);
   const primary = worktrees[0]?.path ? path.resolve(worktrees[0].path) : '';
   const current = path.resolve(root);
-  const activeCwds = Array.isArray(activeCwdsOverride) ? activeCwdsOverride.map(canonicalPath) : listActiveProcessCwds();
+  const activeCwds = Array.isArray(activeCwdsOverride) ? activeCwdsOverride.map(canonicalPath) : listActiveProcessPaths();
   const base = normalizeTargetRef(root, baseOverride || defaultShipTarget(root));
   refreshRemoteRef(root, base);
   const candidates = [];
@@ -1221,7 +1349,7 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
       continue;
     }
     if (worktreeHasActiveProcess(wtPath, activeCwds)) {
-      kept.push({ ...item, reason: 'active_process' });
+      kept.push({ ...item, reason: activeCwds ? 'active_process' : 'process_scan_failed' });
       continue;
     }
     const rawCounts = statusCounts(wt.path);
@@ -1401,6 +1529,7 @@ function worktreeCommand(args = []) {
 module.exports = {
   branchName,
   collidingFlights,
+  mergePrWithRetry,
   createAgentWorktree,
   deniedLaneForShip,
   createOrFindPr,
@@ -1411,9 +1540,10 @@ module.exports = {
   gitNetworkEnvironment,
   describeFlightAge,
   flightStampMs,
-  listActiveProcessCwds,
+  listActiveProcessPaths,
   listWorktrees,
   parseAgentFlightName,
+  parseProcessArgPaths,
   parseWorktrees,
   normalizeTargetRef,
   recordWorktreeRemoval,

package/commands/write.js

@@ -341,7 +341,17 @@ function coach(argv, root = process.cwd()) {
 
   if (!offline && claudeAvailable()) {
     const prompt = coachPrompt({ topic, beats, counts, findings, planText, draftText, currentBeat: current.title });
+    // Machine memory and load at both ends of the launch, so one killed with
+    // SIGKILL says whether the machine was short on memory.
+    const endResource = require('../lib/engine-resource').startEngineRun(root, { engine: 'claude', task: 'write coach' });
     const res = spawnSync('claude', ['-p', prompt], { encoding: 'utf8', timeout: 120000, maxBuffer: 1024 * 1024 });
+    // spawnSync does not throw, so a failure is passed in the thrown shape.
+    const end = endResource(res.error || res.signal || res.status !== 0 ? {
+      code: res.error && res.error.code,
+      signal: res.signal,
+      stderr: res.stderr,
+      message: res.error ? res.error.message : `claude exited ${res.status}`,
+    } : null);
     const out = (res.stdout || '').trim();
     if (res.status === 0 && /QUESTION:/.test(out)) {
       console.log(out.split('\n').map((l) => `  ${l}`).join('\n'));
@@ -350,7 +360,8 @@ function coach(argv, root = process.cwd()) {
       console.log(`\n  your move: answer under "## ${current.title}" in draft.md, then \`atris write status\`\n`);
       return 0;
     }
-    console.log('  (claude coach unavailable, falling back to the offline coach)\n');
+    const stopped = end && end.cause ? `claude coach stopped by ${res.signal}; ${end.cause}` : 'claude coach unavailable';
+    console.log(`  (${stopped}, falling back to the offline coach)\n`);
   }
 
   // Offline coach: still proactive, still gets you going. Seeds + one question.

package/commands/youtube.js

@@ -1239,17 +1239,32 @@ function buildDigestPrompt(briefs = []) {
 
 function defaultDigestRunner(prompt, deps = {}) {
   const spawn = deps.spawnSync || spawnSync;
-  return spawn('claude', ['-p', prompt, '--model', 'claude-haiku-5-5'], {
+  // Machine memory and load at both ends of the launch, so one killed with
+  // SIGKILL says whether the machine was short on memory.
+  const endResource = require('../lib/engine-resource').startEngineRun(deps.cwd || process.cwd(), { engine: 'claude', task: 'youtube digest' });
+  const result = spawn('claude', ['-p', prompt, '--model', 'claude-haiku-5-5'], {
     encoding: 'utf8',
     timeout: DIGEST_ENGINE_TIMEOUT_MS,
     maxBuffer: 10 * 1024 * 1024,
   });
+  // spawnSync does not throw, so a failure is passed in the thrown shape.
+  const failed = !result || result.error || result.signal || result.status !== 0;
+  const end = endResource(failed ? {
+    code: result && result.error && result.error.code,
+    signal: result && result.signal,
+    stderr: result && result.stderr,
+    message: result && result.error ? result.error.message : `claude exited ${result && result.status}`,
+  } : null);
+  return end && end.cause && result && !(result.error && result.error.code === 'ETIMEDOUT') ? { ...result, cause: end.cause } : result;
 }
 
 function invokeDigestEngine(prompt, deps = {}) {
   const runner = deps.runner || ((nextPrompt) => defaultDigestRunner(nextPrompt, deps));
   const result = runner(prompt, deps);
   if (typeof result === 'string') return result.trim();
+  if (result && result.signal && !result.error) {
+    throw new Error(`digest engine stopped by ${result.signal}${result.cause ? `; ${result.cause}` : ''}`);
+  }
   if (!result || result.error || (result.status != null && result.status !== 0)) {
     const detail = String(result?.stderr || result?.error?.message || 'digest engine failed').trim();
     throw new Error(detail || 'digest engine failed');
@@ -1401,7 +1416,7 @@ function runYoutubeDigest(args = [], deps = {}) {
   const prompt = buildDigestPrompt(briefs);
   let text;
   try {
-    text = invokeDigestEngine(prompt, deps);
+    text = invokeDigestEngine(prompt, { ...deps, cwd });
   } catch (err) {
     output(err.message || 'digest engine failed');
     return 1;

package/lib/accept-verify-gate.js

@@ -123,4 +123,5 @@ function evaluateAcceptVerify(task, workspaceRoot, { cache = null } = {}) {
 module.exports = {
   storedVerifyCommand,
   evaluateAcceptVerify,
+  nonFalsifyingIssue,
 };

package/lib/auto-accept-certified.js

@@ -1398,6 +1398,7 @@ module.exports = {
   DENIED_TAGS,
   deniedTagOf,
   candidatePolicyGate,
+  declaredCandidatePathValues,
   declaredProtectedLane,
   sniffedProtectedLane,
   protectedLaneOf,

package/lib/autoland.js

@@ -267,6 +267,8 @@ function acceptedInLastDay(tasks, now = Date.now()) {
       result: String(t.result || t.metadata?.result || '').slice(0, 220),
       happened: String(t.review?.landing?.happened || t.metadata?.landing_happened || '').slice(0, 300),
       member: String(t.claimed_by || t.metadata?.executed_by || t.assigned_to || '').trim(),
+      // Accepted is a review verdict; only a passed landing proof is landed.
+      landed: t.metadata?.landing?.status === 'landed',
     };
     if (t.metadata?.auto_accepted_at) auto.push(entry);
     else human.push(entry);
@@ -481,6 +483,9 @@ function unexplainedSummaryRows(items, label) {
   if (label === 'landed') {
     return [`${plur(count, 'landed result')} stayed hidden because ${count === 1 ? 'its outcome was' : 'their outcomes were'} unclear`];
   }
+  if (label === 'accepted') {
+    return [`${plur(count, 'accepted result')} stayed hidden because ${count === 1 ? 'its outcome was' : 'their outcomes were'} unclear`];
+  }
   if (label === 'in review') {
     return [`${plur(count, 'review')} stayed hidden because ${count === 1 ? 'its next action was' : 'their next actions were'} unclear`];
   }
@@ -547,6 +552,10 @@ function composeDigest({ accepted, waiting, protectedWaiting = [], waitingWishes
   lines.push(`atris ${project}: last 24 hours`);
   const autoCount = accepted.auto.length;
   const humanCount = accepted.human.length;
+  const landedCount = accepted.auto.filter((item) => item.landed === true).length;
+  // "N landed" only when every one of them proved it; otherwise say both.
+  const finished = landedCount === autoCount ? `${autoCount} landed` : `${autoCount} accepted, ${landedCount} landed`;
+  const finishedWord = landedCount === autoCount ? 'landed' : 'accepted';
   const wishWaits = (Array.isArray(waitingWishes) ? waitingWishes : [])
     .filter((wish) => wish && String(wish.text || '').trim());
   if (autoCount > 0) {
@@ -564,8 +573,8 @@ function composeDigest({ accepted, waiting, protectedWaiting = [], waitingWishes
       // The header states the actual bar: under accept-all the claim
       // "verified twice" would be a lie the operator builds trust on.
       lines.push(acceptAll
-        ? `${autoCount} landed; ${plur(ready.length, 'clear result')}, protected lanes held back for you:`
-        : `${autoCount} landed; ${plur(ready.length, 'clear result')}, each verified twice with proof on file:`);
+        ? `${finished}; ${plur(ready.length, 'clear result')}, protected lanes held back for you:`
+        : `${finished}; ${plur(ready.length, 'clear result')}, each verified twice with proof on file:`);
       for (const { item, line } of visibleWork) {
         lines.push('');
         lines.push(`- ${line || item.ref}${memberTrustLabel(item.member, root)}`);
@@ -577,9 +586,9 @@ function composeDigest({ accepted, waiting, protectedWaiting = [], waitingWishes
           : `${plur(held, 'more result')} when you want them: atris autoland digest`);
       }
     } else {
-      lines.push(`${autoCount} landed with proof on file; no clear result was ready to show:`);
+      lines.push(`${finished} with proof on file; no clear result was ready to show:`);
     }
-    for (const row of unexplainedSummaryRows(unexplainedWork, 'landed')) lines.push(row);
+    for (const row of unexplainedSummaryRows(unexplainedWork, finishedWord)) lines.push(row);
   }
   if (autoCount + humanCount === 0) lines.push('nothing finished in the last day');
   if (waiting.length > 0) {

package/lib/campaign-cadence.js

@@ -0,0 +1,131 @@
+// Work and review in rounds (Astra's rule: let agents work 50 minutes, then
+// take 10). In the work window the campaign loop runs: it plans, runs missions
+// at once, and judges. In the break the judge runs if due, reserves are
+// reconciled, and the owner writes a short review of the round into the
+// campaign's lessons file, which the next round's planning reads. Each round
+// leaves the campaign a little smarter than the last.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getCampaign, openCampaignStore } = require('./campaign-store');
+
+const LESSON_LINES_FOR_PLANNING = 30;
+
+function parseDuration(text, fallbackMs) {
+  if (text === undefined || text === null || text === '') return fallbackMs;
+  const match = /^(\d+(?:\.\d+)?)\s*(s|m|h)?$/i.exec(String(text).trim());
+  if (!match) throw new Error(`durations look like 50m, 10m, 90s, or 1h (got ${text})`);
+  const unit = (match[2] || 'm').toLowerCase();
+  return Math.round(Number(match[1]) * { s: 1000, m: 60000, h: 3600000 }[unit]);
+}
+
+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) {
+  try {
+    const text = fs.readFileSync(lessonsPath(root, campaignId), 'utf8');
+    return text.split('\n').filter((line) => line.trim().startsWith('- ')).slice(-lines).join('\n');
+  } catch {
+    return '';
+  }
+}
+
+function roundSummary(before, after) {
+  const fresh = after.missions.filter((m) => !before.missions.some((b) => b.id === m.id && b.status === 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;
+  const spent = Math.round((after.budget.spent - before.budget.spent) * 100) / 100;
+  return { kept, failed, vetoed, spent, fresh };
+}
+
+function reviewPrompt(view, summary, lessons) {
+  const missions = summary.fresh.map((m) => `- ${m.id}: ${m.status}${m.outcome ? ` (${m.outcome})` : ''}${m.cost_usd !== null ? `, $${m.cost_usd}` : ''}`).join('\n') || '- none ended this round';
+  return [
+    'You review one round of an Atris campaign. Reply with 2 to 6 short lessons, one per line, each starting with "- ".',
+    'A lesson says what to do differently next round, in plain words. Do not repeat a lesson already listed.',
+    '',
+    `Campaign: ${view.title}`,
+    `Judge: ${view.judge}`,
+    `Judge now: ${view.last_judge ? `${view.last_judge.passed ? 'passed' : 'failed'}${view.last_judge.reading !== null ? ` (reading ${view.last_judge.reading})` : ''}: ${view.answer.text || ''}` : 'never run'}`,
+    `This round: ${summary.kept} kept, ${summary.failed} failed, ${summary.vetoed} could not start, $${summary.spent} spent`,
+    'Missions this round:',
+    missions,
+    '',
+    'Lessons so far:',
+    lessons || '- none yet',
+  ].join('\n');
+}
+
+function makeCadence(root, loop, options = {}, deps = {}) {
+  const store = deps.store || openCampaignStore(root);
+  const log = deps.log || ((line) => console.log(line));
+  const now = deps.now || (() => Date.now());
+  const sleep = deps.sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const ask = deps.ask;
+  const workMs = parseDuration(options.work, 50 * 60000);
+  const breakMs = parseDuration(options.break, 10 * 60000);
+  const rounds = Number(options.rounds) > 0 ? Number(options.rounds) : Infinity;
+
+  async function review(id, before) {
+    const after = getCampaign(store, id);
+    const summary = roundSummary(before, after);
+    const lessons = readLessons(root, id, 200);
+    let written = [];
+    if (ask) {
+      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()));
+      written = String((answer && answer.text) || '').split('\n').map((line) => line.trim())
+        .filter((line) => line.startsWith('- ') && !known.has(line.toLowerCase())).slice(0, 6);
+    }
+    const file = lessonsPath(root, id);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    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}: ${summary.kept} kept, ${summary.failed} failed, $${summary.spent} spent\n`;
+    fs.appendFileSync(file, `${header}${(written.length ? written : ['- (no review written this round)']).join('\n')}\n`);
+    return { summary, lessons: written };
+  }
+
+  async function run(id) {
+    let round = 0;
+    let last = { reason: 'not started' };
+    while (round < rounds) {
+      round += 1;
+      const before = getCampaign(store, id);
+      const until = now() + workMs;
+      log(`round ${round}: working until ${new Date(until).toISOString().slice(11, 16)}`);
+      let stopped = null;
+      while (now() < until) {
+        const result = await loop.step(id);
+        if (result.stop) {
+          stopped = result.reason;
+          break;
+        }
+      }
+      const breakStarted = now();
+      log(`round ${round}: review`);
+      const { summary, lessons } = await review(id, before);
+      log(`  ${summary.kept} kept, ${summary.failed} failed, $${summary.spent} spent; ${lessons.length} lesson${lessons.length === 1 ? '' : 's'} written`);
+      const view = getCampaign(store, id);
+      last = { reason: stopped || 'work window ended', round };
+      // 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 };
+      }
+      const rest = breakMs - (now() - breakStarted);
+      if (round < rounds && rest > 0) await sleep(rest);
+    }
+    return { rounds: round, reason: last.reason, campaign: getCampaign(store, id) };
+  }
+
+  return { run, review };
+}
+
+module.exports = { lessonsPath, makeCadence, parseDuration, readLessons, reviewPrompt };