atris 3.15.13 → 3.15.22

package/commands/activate.js

@@ -55,16 +55,25 @@ function activateAtris() {
     // Sort descending (most recent first)
     allLogs.sort().reverse();
 
-    // Extract C# items from logs until we have 3
+    // Extract C# items from logs until we have 3. Dedupe by ID across files
+    // since per-day numbering reuses C1, C2, etc. — the same ID appearing
+    // in two day-files would otherwise render as duplicate rows.
+    const seenIds = new Set();
     for (const logPath of allLogs) {
       if (recentCompletions.length >= 3) break;
       const content = fs.readFileSync(logPath, 'utf8');
       const completedSection = content.match(/## Completed ✅\n([\s\S]*?)(?=\n## |$)/);
       if (completedSection) {
-        const matches = completedSection[1].matchAll(/- \*\*C(\d+):\*?\*?\s*(.+?)(?:\s*\[.*\])?$/gm);
+        // Match `- **C#: Title**` (title between the bold markers). If extra
+        // prose follows after `**`, ignore it — the activation panel shows
+        // titles only, truncated to 59 chars.
+        const matches = completedSection[1].matchAll(/- \*\*C(\d+):\s*([^*\n]+?)\*\*/gm);
         for (const match of matches) {
           if (recentCompletions.length >= 3) break;
-          recentCompletions.push({ id: `C${match[1]}`, desc: match[2], file: path.basename(logPath) });
+          const id = `C${match[1]}`;
+          if (seenIds.has(id)) continue;
+          seenIds.add(id);
+          recentCompletions.push({ id, desc: match[2].trim(), file: path.basename(logPath) });
         }
       }
     }

package/commands/aeo.js

@@ -88,7 +88,7 @@ function printHelp() {
   console.log('');
   console.log('Examples:');
   console.log('  atris aeo init');
-  console.log('  atris aeo draft "what is pallet" --queries "what is pallet,best freight platform"');
+  console.log('  atris aeo draft "what is example-co" --queries "what is example-co,best freight platform"');
   console.log('  atris aeo draft "how does atris work" --workspace doordash --slug atris-overview');
 }
 

package/commands/align.js

@@ -12,10 +12,10 @@
  *
  * USAGE:
  *   atris align                    # auto-detect business from .atris/business.json
- *   atris align pallet             # explicit business slug
- *   atris align pallet --dry-run   # show diff, do nothing
- *   atris align pallet --fix       # local is canonical: delete EC2 extras, push local-only
- *   atris align pallet --fix --from cloud  # cloud is canonical: pull EC2-only, delete local extras
+ *   atris align example-co             # explicit business slug
+ *   atris align example-co --dry-run   # show diff, do nothing
+ *   atris align example-co --fix       # local is canonical: delete EC2 extras, push local-only
+ *   atris align example-co --fix --from cloud  # cloud is canonical: pull EC2-only, delete local extras
  */
 
 const fs = require('fs');
@@ -489,15 +489,15 @@ async function alignAtris() {
     if (!slug || slug.startsWith('-')) slug = null;
   }
 
-  if (!slug || slug === '--help' || slug === '-h') {
+  if (!slug || slug === '--help' || slug === '-h' || slug === 'help') {
     console.log('Usage: atris align [business] [--fix] [--hard] [--from cloud|local] [--dry-run]');
     console.log('');
     console.log('  atris align                   Diff current workspace against cloud (auto-detect)');
-    console.log('  atris align pallet            Diff pallet workspace');
-    console.log('  atris align pallet --fix      Fix drift (local is canonical by default)');
-    console.log('  atris align pallet --fix --hard  Force-push: nuke cloud cruft, upload local. Skips diff. Fast.');
-    console.log('  atris align pallet --fix --from cloud  Cloud is canonical: pull EC2-only, delete local extras');
-    console.log('  atris align pallet --dry-run  Show what would change, do nothing');
+    console.log('  atris align example-co            Diff example-co workspace');
+    console.log('  atris align example-co --fix      Fix drift (local is canonical by default)');
+    console.log('  atris align example-co --fix --hard  Force-push: nuke cloud cruft, upload local. Skips diff. Fast.');
+    console.log('  atris align example-co --fix --from cloud  Cloud is canonical: pull EC2-only, delete local extras');
+    console.log('  atris align example-co --dry-run  Show what would change, do nothing');
     process.exit(0);
   }
 

package/commands/analytics.js

@@ -67,12 +67,17 @@ function analyticsAtris() {
       }
     }
 
-    // Parse timestamps for productivity hours
-    const timestampMatches = content.match(/\*\*(\d{2}):(\d{2}):(\d{2})\*\*/g);
+    // Parse timestamps for productivity hours. Match the journal heading
+    // format `### Title — HH:MM` and the legacy `**HH:MM:SS**` form.
+    const timestampMatches = content.match(/(?:—|--)\s*(\d{2}):\d{2}(?::\d{2})?\b|\*\*(\d{2}):\d{2}(?::\d{2})?\*\*/g);
     if (timestampMatches) {
       timestampMatches.forEach(ts => {
-        const hour = parseInt(ts.match(/\d{2}/)[0]);
-        hourCounts[hour] = (hourCounts[hour] || 0) + 1;
+        const m = ts.match(/(\d{2}):/);
+        if (!m) return;
+        const hour = parseInt(m[1], 10);
+        if (Number.isFinite(hour) && hour >= 0 && hour < 24) {
+          hourCounts[hour] = (hourCounts[hour] || 0) + 1;
+        }
       });
     }
   });

package/commands/app.js

@@ -299,6 +299,8 @@ async function appCommand(subcommand, ...args) {
         await show(args[0]);
         break;
       case 'help':
+      case '-h':
+      case '--help':
       case undefined:
         await help();
         break;

package/commands/apps.js

@@ -0,0 +1,276 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function findAppsPackRoot(startDir = process.cwd()) {
+  const explicit = process.env.ATRIS_APPS_PACK;
+  if (explicit) {
+    const resolved = path.resolve(explicit);
+    if (fs.existsSync(path.join(resolved, 'scripts', 'app_use.py'))) return resolved;
+  }
+  let current = path.resolve(startDir);
+  while (true) {
+    const candidate = path.join(current, 'atris', 'apps-pack');
+    if (fs.existsSync(path.join(candidate, 'scripts', 'app_use.py'))) return candidate;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+function appsUsageLines() {
+  return [
+    'Usage: atris apps <command>',
+    '',
+    'Commands:',
+    '  list [--json]                List available local apps',
+    '  run <slug> [--lines N]       Run an app and print data/latest.md or --json status',
+    '  owner <slug> [--json]        Show owner view: launch, usage, learning, next actions',
+    '  status [--json]              Show local app health',
+    '  queue                        Show app improvement queue',
+    '  rate <slug> <up|down> [note] Record output feedback',
+    '  smoke                        Run fresh-checkout smoke test',
+    '  doctor [--strict]            Audit pack health, smoke, and source cleanliness',
+    '  handoff [--json]             Print app operator checklist and receipt paths',
+    '  overnight                    Run the bounded overnight app loop',
+    '  overnight-install [--start]  Install bounded macOS LaunchAgent',
+    '  overnight-agent [status|stop] Inspect or stop macOS LaunchAgent',
+  ];
+}
+
+function printAppsHelp() {
+  console.log('');
+  for (const line of appsUsageLines()) console.log(line);
+  console.log('');
+}
+
+function wantsJson(subcommand, rawArgs) {
+  return subcommand === '--json' || rawArgs.includes('--json');
+}
+
+function normalizeInvocation(subcommand, rawArgs) {
+  if (subcommand === '--json') {
+    return { subcommand: 'list', rawArgs: ['--json', ...rawArgs] };
+  }
+  return { subcommand, rawArgs };
+}
+
+function exitAppsError(message, json, options = {}) {
+  const payload = {
+    ok: false,
+    error: message,
+    ...(options.extra || {}),
+  };
+  if (options.usage) payload.usage = appsUsageLines();
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.error(message);
+    if (options.usage) printAppsHelp();
+  }
+  process.exit(options.code || 1);
+}
+
+function parseScalar(value) {
+  const trimmed = value.trim();
+  if (trimmed === '[]') return [];
+  if (trimmed === 'true') return true;
+  if (trimmed === 'false') return false;
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+  const quoted = trimmed.match(/^"(.*)"$/) || trimmed.match(/^'(.*)'$/);
+  return quoted ? quoted[1] : trimmed;
+}
+
+function readAppManifest(appDir) {
+  const text = fs.readFileSync(path.join(appDir, 'APP.md'), 'utf8');
+  const match = text.match(/^---\n([\s\S]*?)\n---/);
+  const manifest = {};
+  if (!match) return manifest;
+  let currentList = null;
+  for (const line of match[1].split('\n')) {
+    const listItem = line.match(/^\s+-\s+(.*)$/);
+    if (listItem && currentList) {
+      manifest[currentList].push(parseScalar(listItem[1]));
+      continue;
+    }
+    if (/^\s+/.test(line)) {
+      if (currentList && manifest[currentList].length === 0) delete manifest[currentList];
+      currentList = null;
+      continue;
+    }
+    const field = line.match(/^([A-Za-z0-9_]+):\s*(.*)$/);
+    if (!field) continue;
+    const [, key, rawValue] = field;
+    if (rawValue === '') {
+      manifest[key] = [];
+      currentList = key;
+    } else {
+      manifest[key] = parseScalar(rawValue);
+      currentList = null;
+    }
+  }
+  return manifest;
+}
+
+function listAppManifests(packRoot) {
+  const appsDir = path.join(packRoot, 'apps');
+  return fs.readdirSync(appsDir)
+    .filter((name) => fs.existsSync(path.join(appsDir, name, 'APP.md')))
+    .sort()
+    .map((slug) => ({
+      slug,
+      path: path.join(appsDir, slug, 'APP.md'),
+      latest_output: path.join(appsDir, slug, 'data', 'latest.md'),
+      ...readAppManifest(path.join(appsDir, slug)),
+    }));
+}
+
+function popOption(args, name, fallback = null) {
+  const eqPrefix = `${name}=`;
+  const eqIndex = args.findIndex((arg) => arg.startsWith(eqPrefix));
+  if (eqIndex >= 0) {
+    const value = args[eqIndex].slice(eqPrefix.length);
+    args.splice(eqIndex, 1);
+    return value || fallback;
+  }
+  const index = args.indexOf(name);
+  if (index >= 0) {
+    const value = args[index + 1];
+    args.splice(index, value === undefined ? 1 : 2);
+    return value || fallback;
+  }
+  return fallback;
+}
+
+function runPackScript(packRoot, script, args) {
+  const result = spawnSync('python3', [script, ...args], {
+    cwd: packRoot,
+    stdio: 'inherit',
+    env: process.env,
+  });
+  if (result.error) {
+    console.error(`✗ Failed to run python3 ${script}: ${result.error.message}`);
+    process.exit(1);
+  }
+  process.exit(result.status ?? 0);
+}
+
+function appsCommand(subcommand, ...rawArgs) {
+  const jsonRequested = wantsJson(subcommand, rawArgs);
+  const normalized = normalizeInvocation(subcommand, rawArgs);
+  subcommand = normalized.subcommand;
+  rawArgs = normalized.rawArgs;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+    printAppsHelp();
+    return;
+  }
+  const packRoot = findAppsPackRoot();
+  if (!packRoot) {
+    if (jsonRequested) {
+      exitAppsError('No Atris app pack found.', true, {
+        extra: { expected: 'atris/apps-pack/ in this workspace, or ATRIS_APPS_PACK' },
+      });
+    }
+    console.error('✗ No Atris app pack found.');
+    console.error('  Expected atris/apps-pack/ in this workspace, or set ATRIS_APPS_PACK.');
+    process.exit(1);
+  }
+
+  const args = [...rawArgs];
+  const workspace = path.resolve(popOption(args, '--workspace', process.cwd()));
+  const lines = popOption(args, '--lines', null);
+  const note = popOption(args, '--note', null);
+  const hours = popOption(args, '--hours', null);
+  const intervalMinutes = popOption(args, '--interval-minutes', null);
+  const maxCycles = popOption(args, '--max-cycles', null);
+  const label = popOption(args, '--label', null);
+  const python = popOption(args, '--python', null);
+  const json = args.includes('--json');
+  if (json) args.splice(args.indexOf('--json'), 1);
+  const noRun = args.includes('--no-run');
+  if (noRun) args.splice(args.indexOf('--no-run'), 1);
+
+  if (subcommand === 'list') {
+    if (json) {
+      console.log(JSON.stringify({ pack: packRoot, apps: listAppManifests(packRoot) }, null, 2));
+      process.exit(0);
+    }
+    runPackScript(packRoot, 'scripts/app_use.py', ['--list']);
+  }
+  if (subcommand === 'status') runPackScript(packRoot, 'scripts/app_status.py', json ? ['--json'] : []);
+  if (subcommand === 'queue') runPackScript(packRoot, 'scripts/app_improvement_queue.py', []);
+  if (subcommand === 'smoke') runPackScript(packRoot, 'scripts/install_smoke.py', []);
+  if (subcommand === 'doctor') runPackScript(packRoot, 'scripts/install_smoke.py', []);
+  if (subcommand === 'handoff') {
+    const command = ['--workspace', workspace];
+    if (json) command.push('--json');
+    runPackScript(packRoot, 'scripts/app_operator_checklist.py', command);
+  }
+  if (subcommand === 'overnight') {
+    const command = ['--workspace', workspace];
+    if (hours) command.push('--hours', hours);
+    if (intervalMinutes) command.push('--interval-minutes', intervalMinutes);
+    if (maxCycles) command.push('--max-cycles', maxCycles);
+    runPackScript(packRoot, 'scripts/app_overnight.py', command);
+  }
+  if (subcommand === 'overnight-install') {
+    const command = ['--workspace', workspace];
+    if (hours) command.push('--hours', hours);
+    if (intervalMinutes) command.push('--interval-minutes', intervalMinutes);
+    if (maxCycles) command.push('--max-cycles', maxCycles);
+    if (label) command.push('--label', label);
+    if (python) command.push('--python', python);
+    if (args.includes('--start')) command.push('--start');
+    if (args.includes('--dry-run')) command.push('--dry-run');
+    runPackScript(packRoot, 'scripts/install_overnight_launch_agent.py', command);
+  }
+  if (subcommand === 'overnight-agent') {
+    const command = [args.shift() || 'status'];
+    if (label) command.push('--label', label);
+    if (args.includes('--dry-run')) command.push('--dry-run');
+    if (json) command.push('--json');
+    runPackScript(packRoot, 'scripts/control_overnight_launch_agent.py', command);
+  }
+  if (subcommand === 'run') {
+    const slug = args.shift();
+    if (!slug) {
+      exitAppsError('Usage: atris apps run <slug> [--workspace <path>] [--lines N]', json);
+    }
+    const command = [slug, '--workspace', workspace];
+    if (lines) command.push('--lines', lines);
+    if (json) command.push('--json');
+    if (noRun) command.push('--no-run');
+    runPackScript(packRoot, 'scripts/app_use.py', command);
+  }
+  if (subcommand === 'owner') {
+    const slug = args.shift();
+    if (!slug) {
+      exitAppsError('Usage: atris apps owner <slug> [--workspace <path>] [--lines N]', json);
+    }
+    const command = [slug, '--workspace', workspace];
+    if (lines) command.push('--lines', lines);
+    if (json) command.push('--json');
+    if (noRun) command.push('--no-run');
+    runPackScript(packRoot, 'scripts/app_owner.py', command);
+  }
+  if (subcommand === 'rate') {
+    const slug = args.shift();
+    const rating = args.shift();
+    const ratingNote = note || args.join(' ');
+    if (!slug || !['up', 'down'].includes(rating)) {
+      console.error('Usage: atris apps rate <slug> <up|down> [note]');
+      process.exit(1);
+    }
+    runPackScript(packRoot, 'scripts/app_rate.py', [slug, rating, ratingNote || '']);
+  }
+
+  exitAppsError(`Unknown apps command: ${subcommand}`, json, { usage: true });
+}
+
+module.exports = {
+  appsCommand,
+  findAppsPackRoot,
+  listAppManifests,
+};

package/commands/auth.js

@@ -341,7 +341,7 @@ async function accountsCmd() {
       }
       profiles.forEach(p => deleteProfile(p));
       deleteCredentials();
-      console.log(`✓ Removed ${profiles.length} account(s).`);
+      console.log(`✓ Removed ${profiles.length} ${profiles.length === 1 ? 'account' : 'accounts'}.`);
       process.exit(0);
     }
     if (!target) {

package/commands/autopilot.js

@@ -39,6 +39,7 @@ async function suggestNextTask(cwd, skipped = new Set(), { auto = false } = {})
 
   for (const t of todo.backlog) {
     if (t.tags && t.tags.includes('unverified')) continue;
+    if (shouldSkipEndgameAtPicker(cwd, t)) continue;
     if (t.tag === 'endgame' && !skipped.has(t.title)) {
       suggestions.push({
         task: t.title,
@@ -125,6 +126,7 @@ async function suggestNextTask(cwd, skipped = new Set(), { auto = false } = {})
   // --- Backlog tasks ---
   for (const t of todo.backlog) {
     if (t.tags && t.tags.includes('unverified')) continue;
+    if (shouldSkipEndgameAtPicker(cwd, t)) continue;
     if (skipped.has(t.title)) continue;
     const remaining = todo.backlog.filter(b => !(b.tags && b.tags.includes('unverified'))).length;
     suggestions.push({
@@ -697,6 +699,12 @@ function writeLesson(cwd, slug, status, explanation) {
   }
 
   let content = fs.readFileSync(lessonsPath, 'utf8');
+  // Same-day dedup: if an identical line already exists, skip the write. A
+  // cron firing every 13min produced 5 identical no-verify-field lessons in
+  // one day (2026-05-08) before the picker-side fix landed — pure noise. The
+  // append-only contract still holds across days because today's date is in
+  // the line.
+  if (content.includes(lessonLine)) return;
   // Append after the --- separator
   if (content.includes('---\n')) {
     content = content.replace(/---\n/, `---\n\n${lessonLine}\n`);
@@ -784,7 +792,7 @@ function getVerifyCommand(cwd, taskTitle) {
   const todoPath = path.join(cwd, 'atris', 'TODO.md');
   if (fs.existsSync(todoPath)) {
     const todo = parseTodo(todoPath);
-    const task = [...todo.inProgress, ...todo.backlog, ...todo.completed]
+    const task = [...todo.inProgress, ...(todo.review || []), ...todo.backlog, ...todo.completed]
       .find(t => t.title === taskTitle);
     if (task && task.verify) return { cmd: task.verify, explicit: true };
   }
@@ -813,6 +821,14 @@ function detectDefaultVerify(cwd) {
   if (fs.existsSync(path.join(cwd, 'pytest.ini')) ||
       fs.existsSync(path.join(cwd, 'pyproject.toml')) ||
       fs.existsSync(path.join(cwd, 'setup.py'))) {
+    // Prefer a repo-curated fast lane over bare `pytest`. Large repos (e.g.
+    // atrisos-backend) ship a critical-path runner because the full suite is
+    // unsafe to run unsupervised (CLAUDE.md: "NEVER run pytest tests/ ... eats
+    // 10GB+ RAM"). lessons.md 2026-05-10 verify-failed: bare `pytest` failed
+    // a reactive-signal verify and halted the loop.
+    for (const fast of ['backend/scripts/test_fast.sh', 'scripts/test_fast.sh', 'test_fast.sh']) {
+      if (fs.existsSync(path.join(cwd, fast))) return `bash ${fast}`;
+    }
     return 'pytest';
   }
   if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) {
@@ -1177,10 +1193,16 @@ function runTaskOnce(context, options = {}) {
   // task is already done — either way, halt. This is the keystone that makes
   // Verify load-bearing. The cmd is captured here and reused post-execute so
   // an agent cannot swap the rubric mid-tick.
+  //
+  // Timeout: 300s. Many endgame Verify clauses chain a fast-suite run
+  // (test_fast.sh ~60s) plus extra assertions. At 60s the gate timed out
+  // before the chain could finish, the catch branch labeled it "falsifiable",
+  // and the loop executed already-done work. 300s lets the standard
+  // pytest+fast-suite shape complete cleanly.
   const skipFalsifiability = options.skipFalsifiability === true;
   if (!skipFalsifiability && verifyResult.explicit && context.kind === 'endgame' && verifyCmd) {
     try {
-      execSync(verifyCmd, { cwd, stdio: 'pipe', timeout: 60000 });
+      execSync(verifyCmd, { cwd, stdio: 'pipe', timeout: 300000 });
       writeLesson(cwd, 'verify-not-falsifiable', 'fail',
         `Verify \`${verifyCmd}\` passed before work started on "${context.task}". Either the rubric is trivial or the task is already done. Tick halted.`);
       return {
@@ -1466,7 +1488,8 @@ function readEndgameState(cwd) {
       pickedAt: pickedMatch ? pickedMatch[1].trim() : null,
       horizon: horizonMatch ? horizonMatch[1].trim() : '',
       remaining: todo.backlog.filter(t => t.tag === 'endgame').length
-        + todo.inProgress.filter(t => t.tag === 'endgame').length,
+        + todo.inProgress.filter(t => t.tag === 'endgame').length
+        + (todo.review || []).filter(t => t.tag === 'endgame').length,
       completed: todo.completed.filter(t => t.tag === 'endgame').length,
     };
   } catch {
@@ -2207,6 +2230,42 @@ function isLessonResolvedLegacy(lessonLine, cwd) {
  * system already wrote down about itself. A `fail` lesson with `isLessonResolved
  * === false` means grep confirms the bug pattern is still present — actionable.
  */
+/**
+ * Returns true if a recent (within `windowDays`) `verify-not-falsifiable`
+ * lesson references this exact task title. The falsifiability gate halts the
+ * tick when the Verify clause already passes before work starts (task is
+ * already shipped or rubric is trivial), but nothing in TODO.md changes —
+ * so the next tick re-picks the same task and burns another 90s+ halting in
+ * the same place. Reading the lesson log breaks the loop without requiring
+ * a TODO.md hand-edit (which is the structurally-broken file we route around
+ * per feedback_todo_md_is_the_problem).
+ */
+function hasRecentVerifyPrePass(cwd, taskTitle, windowDays = 7) {
+  if (!taskTitle) return false;
+  const lessons = parseLessons(cwd);
+  if (lessons.length === 0) return false;
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - windowDays);
+  const cutoffDate = cutoff.toISOString().split('T')[0];
+  const needle = `"${taskTitle}"`;
+  for (const l of lessons) {
+    if (l.id !== 'verify-not-falsifiable') continue;
+    if (l.date < cutoffDate) continue;
+    if (l.body.includes(needle)) return true;
+  }
+  return false;
+}
+
+function shouldSkipEndgameAtPicker(cwd, task) {
+  if (!task || task.tag !== 'endgame') return false;
+  // Endgame tasks must declare an explicit **Verify:** field. runTaskOnce would
+  // halt them, so the picker must not downgrade them into generic backlog work.
+  if (!task.verify) return true;
+  // If Verify already passed before work started recently, the task is already
+  // shipped or the rubric is trivial. Keep it out of all picker paths.
+  return hasRecentVerifyPrePass(cwd, task.title);
+}
+
 function pickUnresolvedFailLesson(cwd) {
   const lessons = parseLessons(cwd);
   if (lessons.length === 0) return null;
@@ -2245,6 +2304,11 @@ function pickUnresolvedFailLesson(cwd) {
   return candidates[0];
 }
 
+function getLessonVerdict(lessonLine) {
+  const match = lessonLine.match(/\*\*\[\d{4}-\d{2}-\d{2}\]\s+[\w-]+\*\*\s*[—-]\s*(pass|fail)\b/i);
+  return match ? match[1].toLowerCase() : null;
+}
+
 /**
  * Propose 3 candidate next horizons for the autopilot loop. Combines
  * `getIdleTickCount` + `getRecentSignals` into a prompt asking the LLM
@@ -2286,6 +2350,7 @@ Based on these signals, propose exactly 3 candidate next horizons for the loop t
 - A real, concrete horizon tied to what the signals actually reveal (no placeholders, no "candidate 1", no TODO/FIXME stubs).
 - Something the loop can actually work on in this repo right now.
 - Distinct from the other two candidates.
+- Not a restatement of a \`pass\` lesson; pass lessons are shipped constraints, not open work.
 
 Output STRICT JSON ONLY — no prose, no markdown code fences, no commentary. The output must be a single JSON array with exactly 3 objects, each shaped:
 
@@ -2353,7 +2418,7 @@ Reply with the JSON array and nothing else.`;
     throw new Error(`proposeCandidateHorizons: expected at least 1 valid candidate, got ${candidates.length}`);
   }
 
-  // Filter out candidates derived from resolved lessons
+  // Filter out candidates derived from shipped/resolved lessons.
   const lessonsPath = path.join(cwd, 'atris', 'lessons.md');
   const filtered = [];
   for (const c of candidates) {
@@ -2362,12 +2427,16 @@ Reply with the JSON array and nothing else.`;
     for (const lessonLine of signals.recentLessons) {
       const slugMatch = lessonLine.match(/\*\*\[\d{4}-\d{2}-\d{2}\]\s+([\w-]+)\*\*/);
       if (!slugMatch) continue;
-      if (lessonLine.includes('[resolved]')) continue;
+      const alreadyResolved = lessonLine.includes('[resolved]');
       const slug = slugMatch[1];
       // Fuzzy match: check if slug keywords appear in the candidate text
       const slugWords = slug.split('-').filter(w => w.length > 2);
       const matchCount = slugWords.filter(w => combinedText.includes(w)).length;
       if (matchCount < Math.ceil(slugWords.length * 0.5)) continue;
+      if (alreadyResolved || getLessonVerdict(lessonLine) === 'pass') {
+        droppedByLesson = true;
+        break;
+      }
       // Candidate matches this lesson — check if the lesson is resolved
       if (isLessonResolved(lessonLine, cwd)) {
         // Tag lesson [resolved] in lessons.md