atris 3.37.0 → 3.38.0

package/commands/autoland.js

@@ -470,9 +470,12 @@ function showStatus(root, args) {
   const blocked = results.filter((r) => r.action !== 'would_accept');
   const tasks = readProjection(root);
   const waiting = autoland.waitingOnHuman(tasks);
-  const heartbeatInstalled = typeof policy?.heartbeat_installed === 'boolean'
-    ? policy.heartbeat_installed
-    : null;
+  // Ask the crontab, not the policy file. The cached flag is written once at
+  // `autoland on` time, so it reports "unknown" for a cron that has been
+  // running hourly for weeks, and would keep reporting "running" for one
+  // someone deleted. A loop that cannot confirm its own liveness from
+  // evidence cannot be trusted to say it is healthy.
+  const heartbeatInstalled = heartbeatLiveness(root, policy);
 
   if (json) {
     console.log(JSON.stringify({
@@ -498,12 +501,7 @@ function showStatus(root, args) {
     : 'off - everything waits for you';
   console.log(`  policy: ${policyText}`);
   if (enabled && acceptAll) console.log('  bar: everything lands except the protected lanes (money, deploys, security, customer, outward)');
-  const heartbeatText = heartbeatInstalled === true
-    ? 'running hourly'
-    : heartbeatInstalled === false
-      ? 'not installed'
-      : 'unknown - run atris autoland on to check and repair';
-  console.log(`  heartbeat: ${heartbeatText}`);
+  console.log(`  heartbeat: ${heartbeatStatusText(root, policy)}`);
   if (policy && policy.imessage_to) console.log(`  daily message: ${policy.imessage_to} at ${policy.digest_hour ?? autoland.DEFAULT_DIGEST_HOUR}:00`);
   const reapTrouble = autoland.readState(root).last_reap_error;
   if (reapTrouble) console.log(`  cleanup trouble: landing sweep failed on ${reapTrouble.date} (${reapTrouble.error}) - run: atris land --reap`);
@@ -696,6 +694,68 @@ function persistTickReceipt(root, receipt) {
   return receipt.receipt_path;
 }
 
+// A tick that scans a backlog, lands none of it, and prints only zeros is
+// indistinguishable from a tick with no work. Say the standing numbers out
+// loud, and call out the two states that mean the loop is wedged rather than
+// idle: work blocked behind a check the harness could not execute, and work
+// that passed every gate and still did not land.
+// Installed and alive are different claims, and only one of them is worth
+// printing. Deliberately does NOT shell out to crontab: `autoland status` is
+// read-only and must stay fast (a stalled crontab would block it for the full
+// 10s read timeout — see 'autoland status never probes a stalled crontab').
+// Tick receipts are local file reads and are stronger evidence anyway: a
+// crontab line proves configuration, a recent receipt proves the loop ran.
+function heartbeatLiveness(root, policy) {
+  return typeof policy?.heartbeat_installed === 'boolean' ? policy.heartbeat_installed : null;
+}
+
+function lastTickAgeHours(root) {
+  try {
+    const runsDir = path.join(root, 'atris', 'runs');
+    const newest = fs.readdirSync(runsDir)
+      .filter((f) => f.startsWith('autoland-tick-') && f.endsWith('.json'))
+      .sort()
+      .pop();
+    if (!newest) return null;
+    const stamp = fs.statSync(path.join(runsDir, newest)).mtimeMs;
+    return (Date.now() - stamp) / 3_600_000;
+  } catch {
+    return null;
+  }
+}
+
+function heartbeatStatusText(root, policy) {
+  const ageHours = lastTickAgeHours(root);
+  const ageText = ageHours === null
+    ? null
+    : ageHours < 1 ? 'under an hour' : `${Math.floor(ageHours)}h`;
+  // Evidence first: a receipt from the last couple of hours proves the loop is
+  // alive no matter what the policy file remembers. The hourly cron makes two
+  // missed hours an outage rather than jitter — and a heartbeat that has gone
+  // quiet is the single most useful thing this line can say, because that is
+  // the state nobody notices.
+  if (ageHours !== null && ageHours <= 2) return `running hourly (last tick ${ageText} ago)`;
+  if (ageHours !== null) return `SILENT - last tick ${ageText} ago; run atris autoland tick`;
+  const installed = heartbeatLiveness(root, policy);
+  if (installed === false) return 'not installed - run atris autoland on';
+  if (installed === true) return 'installed, but no tick has ever run - run atris autoland tick';
+  return 'unknown - run atris autoland on to check and repair';
+}
+
+function stuckBacklogNote(receipt) {
+  const parts = [];
+  const scanned = Number(receipt.scanned || 0);
+  const certified = Number(receipt.certified || 0);
+  if (scanned > 0 && receipt.landed.length === 0) {
+    parts.push(`${certified}/${scanned} certified in review, none landed`);
+  }
+  const unrunnable = Array.isArray(receipt.unrunnable_verifiers) ? receipt.unrunnable_verifiers.length : 0;
+  if (unrunnable > 0) {
+    parts.push(`${unrunnable} blocked by a check this machine could not run`);
+  }
+  return parts.length ? `, ${parts.join(', ')}` : '';
+}
+
 function digestTickStatus(receipt) {
   if (receipt.digest_sent) return 'sent';
   if (receipt.digest_due) return 'saved';
@@ -734,6 +794,23 @@ function runTickBody(root, { json, policy, receipt }) {
       .filter((r) => r.action === 'skipped' && r.proof_state === 'suite_green_citation_required')
       .map((r) => ({ ref: r.ref, reason: r.reason }));
     if (citationBlocks.length) receipt.citation_blocks = citationBlocks;
+    // A verifier the machine cannot execute is a broken harness, not a verdict
+    // on the diff. It must never sit quietly in the skipped pile: surface it
+    // as an alarm so a wedged loop is visible on the first tick, not the 480th.
+    // Not filtered by action: an unrunnable check surfaces as `skipped` from
+    // the eligibility gate and as `revised`/`revise_failed` from the landing
+    // gate. The reason is the signal, not the lane it came through.
+    const unrunnable = results
+      .filter((r) => r && r.action !== 'accepted' && r.reason === 'verify_unrunnable')
+      .map((r) => ({
+        ref: r.ref,
+        cause: r.unrunnable_cause || 'unknown',
+        command: r.command || r.verify || null,
+      }));
+    if (unrunnable.length) {
+      receipt.unrunnable_verifiers = unrunnable;
+      receipt.alarms = Number(receipt.alarms || 0) + unrunnable.length;
+    }
     receipt.certified = parsed.certified ?? null;
     receipt.scanned = parsed.scanned ?? null;
     receipt.revised = parsed.revised ?? null;
@@ -956,7 +1033,12 @@ function runTickBody(root, { json, policy, receipt }) {
     const heldNote = receipt.missions_held ? `, held ${receipt.missions_held} human-blocked mission${receipt.missions_held === 1 ? '' : 's'}` : '';
     const wishNote = `, ${wishSweepSummaryLine(receipt.wish_dispatch, receipt.wish_dispatch_error)}`;
     const receiptNote = receipt.receipt_path ? `, receipt ${receipt.receipt_path}` : '';
-    const summary = `autoland tick: ${receipt.reviews_certified ?? 0} reviews certified, ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}, ${receipt.alarms} alarms, digest ${digestTickStatus(receipt)}${reapNote}${janitorNote}${heldNote}${wishNote}${receiptNote}`;
+    // Deltas alone ("0 certified, 0 landed") are true and useless: they read
+    // as "nothing to do" whether the queue is empty or 19-deep and wedged.
+    // Always print the standing backlog, and name work that cleared every
+    // gate and still did not land — that is the shape of a stuck loop.
+    const stuckNote = stuckBacklogNote(receipt);
+    const summary = `autoland tick: ${receipt.reviews_certified ?? 0} reviews certified, ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}, ${receipt.alarms} alarms${stuckNote}, digest ${digestTickStatus(receipt)}${reapNote}${janitorNote}${heldNote}${wishNote}${receiptNote}`;
     console.log(gateForHuman(summary).text);
     for (const fulfilled of receipt.wish_dispatch?.fulfilled_results || []) {
       if (fulfilled.review_ask) console.log(fulfilled.review_ask);
@@ -1014,18 +1096,14 @@ function autolandCommand(args = []) {
 
 module.exports = {
   autolandCommand,
-  attachedTasksForMission,
   digestNextMoves,
   digestStoryRows,
   digestTickStatus,
   explainResult,
-  missionReadyForClosedTaskVerify,
   operatorReady,
   readAcceptedTaskHistory,
   hasAgentJargon,
   runTickBody,
-  persistTickReceipt,
   sweepLanding,
   verifyClosedTaskMissions,
-  wishSweepSummaryLine,
 };

package/commands/autopilot-front.js

@@ -279,10 +279,6 @@ async function autopilotFront(args = []) {
 module.exports = {
   autopilotFront,
   maxLegsFlag,
-  autopilotStop,
-  autopilotStatus,
-  legPlan,
-  pickMember,
   stopRequested,
   requestStop,
   clearStop,

package/commands/autopilot.js

@@ -3825,7 +3825,6 @@ async function autopilotFromTodo(options = {}) {
 }
 
 module.exports = {
-  appendTickSummary,
   snapshotRepoHeads,
   diffAdvancedRepoHeads,
   reconcileTimedOutTick,
@@ -3833,10 +3832,7 @@ module.exports = {
   findCompletionReceipt,
   isDoPhaseTimeoutMessage,
   validateVerifyCommandShape,
-  askHuman,
-  askModel,
   autopilotAtris,
-  autopilotFromTodo,
   buildPrompt,
   pendingExperimentTargets,
   isLessonResolved,
@@ -3847,7 +3843,6 @@ module.exports = {
   parseLessons,
   pickUnresolvedFailLesson,
   runLessonDetector,
-  isStillTrue,
   getTaskAgeDays,
   getIdleTickCount,
   getRecentSignals,
@@ -3865,14 +3860,8 @@ module.exports = {
   renderHumanSuggestion,
   renderHumanTickIntro,
   proposeCandidateHorizons,
-  recordTickCommit,
-  regressionCheck,
-  repoMapAuditReportsClean,
-  isCleanMapBrokenRefFailLesson,
-  inlinePythonVerifyFailureNowPasses,
   runPlanReview,
   runTaskOnce,
-  buildPlanReviewPrompt,
   parseVerdict,
   scoreEndgameCandidates,
   suggestNextTask,
@@ -3882,7 +3871,6 @@ module.exports = {
   isPhaseKillError,
   execPhaseCommandSync,
   executePhaseDetailed,
-  autopilotGlassLogDir,
   buildAutopilotGlassLog,
   writeAutopilotGlassLog,
   lessonSlug

package/commands/brain.js

@@ -1714,17 +1714,10 @@ function brainCommand(args = process.argv.slice(3)) {
 module.exports = {
   brainCommand,
   collectState,
-  prepareBrainState,
   renderStatus,
-  renderLedger,
-  renderActivationCard,
-  renderActivationGallery,
   recordTaskEpisodeScorecards,
-  recordFeedback,
-  recordApproval,
   verifyActivationCard,
   verifyActivationGallery,
-  verifyBrain,
   parseContributionCard,
   escapeRegExp,
   countTodoItems,

package/commands/brief.js

@@ -642,10 +642,8 @@ module.exports = {
   buildBriefData,
   briefCommand,
   handleBriefAnswer,
-  parsePromptAnswer,
   renderBrief,
   renderBriefHtml,
   run: briefCommand,
-  runBriefLedgerCommand,
   shouldPromptBrief,
 };

package/commands/business-sync.js

@@ -1082,7 +1082,6 @@ module.exports = {
   buildConflictMarkers,
   canPreviewPush,
   collectBrainSnapshot,
-  collectWorkspaceSnapshot,
   collectWorkspaceWarnings,
   collectLocalSyncStatus,
   collectConflictResolutionEntries,

package/commands/business.js

@@ -6,6 +6,12 @@ const { apiRequestJson } = require('../utils/api');
 const { syncBusinessCanonical, ensureWorkspaceStateFiles, ensureBusinessRootAgentAdapters } = require('./sync');
 const { ensureContextScaffold, writeWikiStatus, appendWikiLog } = require('../lib/wiki');
 const { writeRuntimeReceipt } = require('../lib/runtime-bootstrap');
+const {
+  SIMULATE_USAGE,
+  buildSimulationPlan,
+  parseSimulationArgs,
+  renderDryRun,
+} = require('../lib/business-simulate');
 
 function getBusinessConfigPath() {
   const home = require('os').homedir();
@@ -2386,6 +2392,7 @@ async function createBusinessInternal(name, flags = [], mode = 'auto') {
     options.here ||
     Boolean(options.root)
   );
+  let workspaceRoot = null;
 
   // Scaffold legacy local directory if in an atris project
   const atrisDir = !shouldCreateCanonicalWorkspace ? findAtrisDir() : null;
@@ -2405,7 +2412,7 @@ async function createBusinessInternal(name, flags = [], mode = 'auto') {
       console.log(`  Local scaffold: ${bizDir}/`);
     }
   } else if (shouldCreateCanonicalWorkspace) {
-    const workspaceRoot = resolveWorkspaceRoot(biz.slug, options);
+    workspaceRoot = resolveWorkspaceRoot(biz.slug, options);
     const scaffold = createCanonicalBusinessWorkspace(workspaceRoot, {
       business_id: biz.id,
       workspace_id: biz.workspace_id,
@@ -2446,10 +2453,10 @@ async function createBusinessInternal(name, flags = [], mode = 'auto') {
   console.log(`  Agent:     ${biz.agent_id || '(none)'}`);
   console.log(`  Dashboard: https://atris.ai/dashboard/gm/${biz.id}`);
   if (shouldCreateCanonicalWorkspace) {
-    const workspaceRoot = resolveWorkspaceRoot(biz.slug, options);
     console.log(renderBusinessCreatedNextSteps(biz, workspaceRoot));
   }
   console.log('');
+  return { business: biz, workspaceRoot };
 }
 
 async function createBusiness(name, ...flags) {
@@ -2875,6 +2882,96 @@ function findAtrisDir() {
   return null;
 }
 
+function printBusinessSimulateHelp() {
+  console.log(SIMULATE_USAGE);
+  console.log('');
+  console.log('Creates a business workspace, four simulation members, their missions, and atris/ENDGAME.md.');
+  console.log('Use --dry-run to preview every simulation file without cloud calls or writes.');
+}
+
+async function simulateBusiness(args = [], dependencies = {}) {
+  const options = parseSimulationArgs(args);
+  const createdAt = new Date().toISOString();
+  const preview = buildSimulationPlan({
+    idea: options.idea,
+    businessName: options.businessName,
+    roleNames: options.roleNames,
+    createdAt,
+  });
+
+  if (options.dryRun) {
+    console.log(renderDryRun(preview));
+    return preview;
+  }
+
+  const init = dependencies.initBusinessWorkspace || initBusinessWorkspace;
+  const runMemberCommand = dependencies.memberCommand || require('./member').memberCommand;
+  const initialized = await init(options.businessName);
+  const business = initialized?.business || {};
+  const workspaceRoot = initialized?.workspaceRoot
+    || resolveWorkspaceRoot(business.slug || options.businessSlug, {});
+  const plan = buildSimulationPlan({
+    idea: options.idea,
+    businessName: business.name || options.businessName,
+    businessSlug: business.slug || options.businessSlug,
+    roleNames: options.roleNames,
+    createdAt,
+    workspacePath: workspaceRoot,
+  });
+
+  const businessJson = path.join(workspaceRoot, '.atris', 'business.json');
+  if (!fs.existsSync(businessJson)) {
+    throw new Error(`Business init did not create the expected workspace: ${workspaceRoot}`);
+  }
+
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(workspaceRoot);
+
+    const endgame = plan.files.find((file) => file.kind === 'endgame');
+    fs.writeFileSync(path.join(workspaceRoot, endgame.path), endgame.content, 'utf8');
+
+    for (const role of plan.roles) {
+      const memberDir = path.join(workspaceRoot, 'atris', 'team', role.name);
+      const memberFile = path.join(memberDir, 'MEMBER.md');
+      if (!fs.existsSync(memberFile)) {
+        await runMemberCommand(
+          'create',
+          role.name,
+          `--role=${role.title}`,
+          `--description=${role.description}`,
+        );
+      } else {
+        console.log(`Using existing team/${role.name}/ scaffold from business init.`);
+      }
+
+      for (const directory of ['skills', 'tools', 'context', 'logs']) {
+        fs.mkdirSync(path.join(memberDir, directory), { recursive: true });
+      }
+
+      const roleFiles = plan.files.filter((file) => file.role?.name === role.name);
+      for (const file of roleFiles) {
+        fs.writeFileSync(path.join(workspaceRoot, file.path), file.content, 'utf8');
+      }
+
+      await runMemberCommand('push', role.name);
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+
+  console.log('');
+  console.log('business simulation ready');
+  console.log(`workspace: ${workspaceRoot}`);
+  console.log('roster:');
+  for (const role of plan.roles) {
+    console.log(`  - ${role.name}: ${role.role}`);
+  }
+  console.log('next: open an agent session in the workspace and run the loop against atris/ENDGAME.md');
+  console.log('');
+  return plan;
+}
+
 
 async function quickstart() {
   console.log(`
@@ -2945,6 +3042,7 @@ function printBusinessHelp() {
   console.log('  init <name>          RECOMMENDED: create a business environment (cloud + local)');
   console.log('  workspace <name>     Alias for init');
   console.log('  create <name>        Cloud-only business record; add --workspace to also scaffold local');
+  console.log('  simulate <idea>      Create a business, four-role team, missions, and endgame loop');
   console.log('  add <slug>           Register an existing cloud business');
   console.log('  list                 Show registered businesses');
   console.log('  team [slug]          Show members, roles, and admin access');
@@ -2973,6 +3071,10 @@ async function businessCommand(subcommand, ...args) {
     printBusinessHelp();
     return;
   }
+  if (subcommand === 'simulate' && args.some(isHelpToken)) {
+    printBusinessSimulateHelp();
+    return;
+  }
   const nameTakingSubcommands = new Set(['create', 'new', 'init', 'workspace']);
   if (nameTakingSubcommands.has(subcommand) && args.some(isHelpToken)) {
     printBusinessHelp();
@@ -2995,6 +3097,9 @@ async function businessCommand(subcommand, ...args) {
     case 'workspace':
       await initBusinessWorkspace(args[0], ...args.slice(1));
       break;
+    case 'simulate':
+      await simulateBusiness(args);
+      break;
     case 'list':
     case 'ls': {
       const opts = {};
@@ -3072,26 +3177,16 @@ async function businessCommand(subcommand, ...args) {
 
 module.exports = {
   businessCommand,
-  businessHealth,
-  businessAudit,
-  businessDoctor,
-  businessTeam,
   loadBusinesses,
   saveBusinesses,
-  getBusinessConfigPath,
   businessMatchesSlug,
   isAccidentalHelpBusiness,
   validateBusinessCreateName,
   analyzeBusinessDoctor,
-  readBusinessFolderBindings,
   createCanonicalBusinessWorkspace,
-  initBusinessWorkspace,
   onboardBusiness,
-  startBusinessWorkspace,
   shareBusinessWorkspace,
   collectBusinessShareState,
   renderBusinessCreatedNextSteps,
-  renderBusinessShareHandoff,
-  renderBusinessStartCard,
   recordBusinessRun,
 };

package/commands/clean.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const escapeRegExp = require('../lib/escape-regexp');
+const { wikiMetabolismNudge } = require('../lib/wiki');
 
 /**
  * atris clean - Workspace housekeeping with auto-heal
@@ -60,6 +61,14 @@ function cleanAtris(options = {}) {
   const stalePages = findStalePages(cwd, atrisDir);
   results.stalePages = stalePages;
 
+  // 6. Dead code report (report-only: deletion is a human/reviewed call)
+  try {
+    const { findDeadCode } = require('./slop');
+    const dead = findDeadCode(cwd);
+    results.deadFiles = dead.dead.map((f) => path.relative(cwd, f));
+    results.testOnlyFiles = dead.testOnly.map((f) => path.relative(cwd, f));
+  } catch { results.deadFiles = []; results.testOnlyFiles = []; }
+
   if (options.json) {
     console.log(JSON.stringify(cleanResultPayload(results, options, cwd), null, 2));
     return results;
@@ -75,6 +84,12 @@ function cleanAtris(options = {}) {
   console.log('Results:');
   console.log('');
 
+  const wikiNudge = wikiMetabolismNudge(cwd);
+  if (wikiNudge) {
+    console.log(wikiNudge);
+    console.log('');
+  }
+
   // Stale tasks
   if (staleTasks.length > 0) {
     console.log(`⚠ ${staleTasks.length} stale ${staleTasks.length === 1 ? 'task' : 'tasks'} (claimed >3 days, not completed):`);
@@ -140,6 +155,16 @@ function cleanAtris(options = {}) {
     console.log('✓ No stale wiki pages');
   }
 
+  // Dead code
+  if ((results.deadFiles || []).length > 0) {
+    console.log(`⚠ ${results.deadFiles.length} dead ${results.deadFiles.length === 1 ? 'file' : 'files'} (unreachable and unreferenced — atris slop dead for detail):`);
+    results.deadFiles.slice(0, 5).forEach((f) => console.log(`   • ${f}`));
+    if (results.deadFiles.length > 5) console.log(`   ... and ${results.deadFiles.length - 5} more`);
+    console.log('');
+  } else {
+    console.log('✓ No dead code');
+  }
+
   const hasIssues = staleTasks.length > 0 || unhealable.length > 0 || stalePages.length > 0;
   if (hasIssues) {
     console.log('Manual action needed:');
@@ -165,6 +190,7 @@ function cleanResultPayload(results, options = {}, cwd = process.cwd()) {
   if (results.staleTasks.length > 0) manualAction.push('Delete stale tasks or finish them');
   if (results.unhealableRefs.length > 0) manualAction.push('Manually fix unhealable MAP.md refs');
   if (results.stalePages.length > 0) manualAction.push('Re-compile stale pages');
+  if ((results.deadFiles || []).length > 0) manualAction.push('Delete dead files (atris slop dead)');
   return {
     ok: manualAction.length === 0,
     action: 'clean',
@@ -196,6 +222,11 @@ function cleanResultPayload(results, options = {}, cwd = process.cwd()) {
           stale_source: page.staleSource,
         })),
       },
+      dead_code: {
+        count: (results.deadFiles || []).length,
+        items: results.deadFiles || [],
+        test_only: results.testOnlyFiles || [],
+      },
     },
     manual_action: manualAction,
   };
@@ -659,8 +690,6 @@ module.exports = {
   cleanResultPayload,
   findStaleTasks,
   healBrokenMapRefs,
-  archiveOldJournals,
-  cleanEmptySections,
   findStalePages,
   checkPageStaleness
 };

package/commands/close.js

@@ -517,14 +517,27 @@ function pulseLivenessState(cwd, now) {
 // pulse liveness check only sees silence; this sees a run of negative reward.
 // Sums reward over the last N finished ticks; unhealthy when the trend is net
 // negative, healthy once it climbs back to zero or better.
+//
+// Recency guard: this sensor only speaks to a *live* run of ticks. A
+// decommissioned or intermittent loop leaves stale receipts frozen; without a
+// guard the last N finished ticks stay net-negative forever and the flag can
+// never clear (no fresh positive receipt arrives). It also must not treat a
+// scattered set — e.g. one tick today plus five from days ago — as a "run":
+// summing rewards across a multi-day gap is meaningless. So we only consider
+// finished ticks from the last few days and require a full window of them; a
+// silent or sparse loop is the pulse-liveness sensor's concern, and here it
+// reports healthy so any open reward flag auto-closes.
 const REWARD_REGRESSION_WINDOW = 6;
+const REWARD_REGRESSION_RECENCY_MS = 2 * DAY_MS;
 
 function rewardRegressionState(cwd, now) {
   const receipts = pulse.readJsonl(pulse.pulseReceiptsPath(cwd));
   const finished = receipts
     .filter((r) => r && r.phase === 'finished' && parseDate(r.ts || r.at) !== null)
+    .filter((r) => now.getTime() - parseDate(r.ts || r.at) <= REWARD_REGRESSION_RECENCY_MS)
     .sort((a, b) => parseDate(a.ts || a.at) - parseDate(b.ts || b.at));
-  if (finished.length < REWARD_REGRESSION_WINDOW) return { healthy: false, unhealthy: false };
+  // Not enough recent signal to call a degradation run: leave it to pulse liveness.
+  if (finished.length < REWARD_REGRESSION_WINDOW) return { healthy: true, unhealthy: false, sparse: true };
   const window = finished.slice(-REWARD_REGRESSION_WINDOW);
   const sum = window.reduce((acc, r) => acc + (Number(r.reward) || 0), 0);
   return { healthy: sum >= 0, unhealthy: sum < 0, sum };
@@ -782,13 +795,14 @@ function appendOpenedFromSource({ what, owner = 'operator', lane = 'code', ttlDa
   return event;
 }
 
-function appendClosedFromSource(flag, cwd, now) {
+function appendClosedFromSource(flag, cwd, now, note) {
   const event = {
     kind: 'closed',
     at: now.toISOString(),
     id: flag.id,
     proof: RESOLVED_IN_SOURCE_PROOF,
   };
+  if (note) event.note = note;
   appendEvent(event, cwd);
   return event;
 }
@@ -809,12 +823,20 @@ function scanState(cwd = process.cwd(), options = {}) {
   const lessonFlags = lessonFlagsState(cwd, now);
   const openBySource = new Map();
   const dissolvedSources = new Set();
+  const recentlyClosedSources = new Set();
   const autoClosed = [];
 
   // Dissolve is a durable verdict: a source the operator declared dead on
-  // purpose must never re-open on a later scan.
+  // purpose must never re-open on a later scan. Recent closes get a 30-day
+  // quiet period so a resolved source cannot immediately breed a new flag.
   for (const flag of foldEvents(readEvents(cwd), { now })) {
     if (flag.status === 'dissolved' && flag.source) dissolvedSources.add(flag.source);
+    const closedAt = parseDate(flag.closed_at);
+    const closedAge = closedAt === null ? null : now.getTime() - closedAt;
+    if (flag.status === 'closed' && flag.source && closedAge !== null
+      && closedAge >= 0 && closedAge <= 30 * DAY_MS) {
+      recentlyClosedSources.add(flag.source);
+    }
   }
 
   const failedTasks = Array.from(tasksById.values())
@@ -827,17 +849,22 @@ function scanState(cwd = process.cwd(), options = {}) {
     if (flag.source) openBySource.set(flag.source, flag);
   }
 
-  const closeFlag = (flag) => {
-    const event = appendClosedFromSource(flag, cwd, now);
+  const closeFlag = (flag, note) => {
+    const event = appendClosedFromSource(flag, cwd, now, note);
     autoClosed.push({ flag, event });
     openBySource.delete(flag.source);
+    recentlyClosedSources.add(flag.source);
   };
 
   for (const flag of Array.from(openBySource.values())) {
     if (flag.source.startsWith('task:')) {
       const task = tasksById.get(flag.source.slice('task:'.length));
       const status = normalizeSpaces(task && task.status).toLowerCase();
-      if (task && (taskResolved(task) || status === 'failed')) closeFlag(flag);
+      if (!task) {
+        closeFlag(flag, 'task no longer in projection (done/archived)');
+      } else if (!taskWaitingOnHumanAccept(task) || taskResolved(task) || status === 'failed') {
+        closeFlag(flag);
+      }
       continue;
     }
     if (flag.source.startsWith(FAILED_TASK_BATCH_PREFIX)) {
@@ -881,7 +908,8 @@ function scanState(cwd = process.cwd(), options = {}) {
 
   const opened = [];
   const openCandidate = (candidate) => {
-    if (!candidate.source || openBySource.has(candidate.source) || dissolvedSources.has(candidate.source)) return null;
+    if (!candidate.source || openBySource.has(candidate.source)
+      || dissolvedSources.has(candidate.source) || recentlyClosedSources.has(candidate.source)) return null;
     const event = appendOpenedFromSource(candidate, cwd, now);
     opened.push(event);
     openBySource.set(candidate.source, { ...event, status: 'open' });
@@ -889,10 +917,11 @@ function scanState(cwd = process.cwd(), options = {}) {
   };
 
   for (const task of tasks) {
-    const source = taskSource(task);
-    const ref = taskRef(task);
+    const currentTask = tasksById.get(normalizeSpaces(task && task.id));
+    const source = taskSource(currentTask);
+    const ref = taskRef(currentTask);
     if (!source || !ref) continue;
-    if (taskWaitingOnHumanAccept(task) && isOlderThan(task.updated_at, 5, now)) {
+    if (taskWaitingOnHumanAccept(currentTask) && isOlderThan(currentTask.updated_at, 5, now)) {
       openCandidate({
         what: `task ${ref} has waited in review too long, accept it or send it back`,
         lane: 'code',
@@ -1054,6 +1083,13 @@ function run(args = [], context = {}) {
       printHelp();
       return 0;
     }
+    // `close <sub> --help` is a help request, not a run — sweep and scan mutate
+    // the ledger (escalations, auto-closes), so never execute a subcommand just
+    // to show usage.
+    if (rest.includes('--help') || rest.includes('-h')) {
+      printHelp();
+      return 0;
+    }
     if (subcommand === 'add') return commandAdd(rest, context);
     if (subcommand === 'list') return commandList(rest, context);
     if (subcommand === 'done') return commandDone(rest, context);
@@ -1078,6 +1114,5 @@ module.exports = {
   openFlags,
   ledgerPath,
   readEvents,
-  listLine,
   sweepLine,
 };

package/commands/cloud.js

@@ -240,6 +240,5 @@ module.exports = {
   cloudClean,
   collectCloudOrphans,
   parseCloudCleanArgs,
-  readCloudCleanSlug,
   renderCloudCleanSummary,
 };