atris 3.62.0 → 3.64.0

package/commands/task.js

@@ -253,6 +253,8 @@ atris task - durable local task state (SQLite, gitignored)
                                            Sweep off-roadmap/duplicate work as archived (not failed);
                                            --from-failed opts in to relabel a fail-closed row (never done)
   atris task clear-done [--before <days>] [--dry-run] [--json]  Archive completed rows, oldest first
+  atris task prune-test-junk [--yes] [--vacuum] [--json]
+                                           Count rows test runs left from temp folders; --yes backs up the db, then removes them
   atris task keep [--json]                 Put away finished and untouched work, then refresh the list
   atris task reap-mission-blockers [--json] Close blocker rows whose missions are complete or stopped
   atris task relabel-archived [--dry-run|--apply]
@@ -1421,7 +1423,7 @@ function taskReviewSummary(task) {
   const reviewPassCount = Number(metadata.agent_review_pass_count || payload.review_pass_count || 0);
   const agentCertified = metadata.agent_certified === true
     || payload.agent_certified === true
-    || reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES;
+    || (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES && reviewIntegrity.hasIndependentReview(task));
   const reviewedEventHas = (key) => reviewed && reviewed.event_type === 'reviewed'
     && Object.prototype.hasOwnProperty.call(payload, key);
   const clearedReviewFields = new Set(Array.isArray(payload.cleared_review_fields) ? payload.cleared_review_fields : []);
@@ -7922,6 +7924,8 @@ function publicWords(value) {
     ]).has(word));
 }
 
+const { memberTypeOf } = require('../lib/member-type');
+
 function parseMemberFrontmatter(text) {
   const source = String(text || '');
   if (!source.startsWith('---')) return {};
@@ -7952,6 +7956,7 @@ function readTeamMembers(root = process.cwd()) {
         slug,
         role: cleanPublicText(frontmatter.role || slug.replace(/[-_]/g, ' '), 120),
         description: cleanPublicText(frontmatter.description || '', 240),
+        type: memberTypeOf(frontmatter).type,
         path: memberPath,
       };
     })
@@ -8018,6 +8023,8 @@ function chooseTaskOwner({ purpose, tag, requestedOwner, root = process.cwd() }
   const words = publicWords(`${purpose || ''} ${tag || ''}`);
   let best = null;
   for (const member of members) {
+    // A person can be named as an owner, but routing never hands them work as if they were an AI.
+    if (member.type !== 'ai') continue;
     const score = scoreTeamMember(member, words, tag);
     if (!best || score > best.score) best = { member, score };
   }
@@ -8836,7 +8843,7 @@ function taskAllowsReviewChat(task, { allowCertified = false } = {}) {
   if (allowCertified) return true;
   if (review.agent_certified === true || metadata.agent_certified === true) return false;
   const reviewPassCount = Number(review.agent_review_pass_count || metadata.agent_review_pass_count || 0);
-  if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES) return false;
+  if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES && reviewIntegrity.hasIndependentReview(task)) return false;
   const handoff = reviewHandoffForTask(task, { suppressExistingFollowUp: true });
   return !(handoff && (handoff.next_action === 'continue_work' || handoff.next_action === 'human_accept_waiting'));
 }
@@ -9809,6 +9816,78 @@ function cmdClearDone(args) {
   console.log(`cleared ${candidates.length} completed task(s).`);
 }
 
+function formatBytes(bytes) {
+  const mb = Number(bytes || 0) / (1024 * 1024);
+  return mb >= 1 ? `${mb.toFixed(1)} MB` : `${Math.round(Number(bytes || 0) / 1024)} KB`;
+}
+
+// Test runs that forgot ATRIS_TASKS_DB left rows in the shared database
+// under temp folders. Default is a read-only count; --yes backs up, then
+// removes those rows and their history. Real project rows are never touched.
+function cmdPruneTestJunk(args) {
+  const taskDb = getTaskDb();
+  const prune = require('../lib/task-prune');
+  const dbPath = taskDb.getDbPath();
+  const apply = hasFlag(args, '--yes') && !hasFlag(args, '--dry-run');
+  const vacuum = apply && hasFlag(args, '--vacuum');
+  if (!apply) {
+    const plan = prune.dryRun(dbPath);
+    const { rows, ...summary } = plan;
+    if (wantsJson(args)) {
+      printJson({ ok: true, action: 'prune-test-junk', dry_run: true, ...summary });
+      return;
+    }
+    if (plan.missing) {
+      console.log(`no task database at ${dbPath}. nothing to prune.`);
+      return;
+    }
+    const r = plan.remove;
+    console.log('prune-test-junk dry run: nothing was changed.');
+    console.log(`database: ${dbPath} (${formatBytes(plan.db_bytes)}, ${plan.total_tasks} tasks)`);
+    console.log(`would remove ${r.tasks} test task(s) from temp folders, ${r.history_rows} history row(s), `
+      + `${r.stray_history_rows} stray history row(s), ${r.part_uses} part use row(s).`);
+    for (const g of plan.groups) {
+      console.log(`  ${g.prefix.padEnd(22)} ${String(g.tasks).padStart(7)} tasks  ${String(g.history_rows + g.stray_history_rows).padStart(8)} history rows`);
+    }
+    const k = plan.kept;
+    console.log(`kept: ${k.folder_exists} temp task(s) whose folder still exists, ${k.recent} active in the last ${plan.grace_hours} hour(s), `
+      + `${k.held} with history from a real project, ${k.stray_held + k.stray_recent} leftover history set(s) that are recent or name a real project.`);
+    if (r.tasks || r.stray_history_rows) {
+      console.log('run with --yes to remove them. a backup copy is written next to the database first.');
+    }
+    return;
+  }
+
+  if (vacuum && !wantsJson(args)) {
+    console.log('note: --vacuum rewrites the whole file and needs every other atris process idle; it waits a few seconds, then gives up.');
+  }
+  let result;
+  try {
+    result = prune.applyPrune(dbPath, { vacuum });
+  } catch (err) {
+    failTask('atris task prune-test-junk', 'prune_failed', `prune-test-junk stopped: ${err && err.message || err}`, 1);
+  }
+  if (wantsJson(args)) {
+    printJson({ ok: true, action: 'prune-test-junk', dry_run: false, ...result });
+    return;
+  }
+  if (result.missing) {
+    console.log(`no task database at ${dbPath}. nothing to prune.`);
+    return;
+  }
+  const r = result.removed;
+  console.log(`backup: ${result.backup_path} (${result.backup_tasks} tasks)`);
+  console.log(`removed ${r.tasks} test task(s), ${r.history_rows} history row(s), `
+    + `${r.stray_history_rows} stray history row(s), ${r.part_uses} part use row(s).`);
+  const sk = result.skipped;
+  if (sk.held || sk.changed_since_backup || sk.recent || sk.folder_exists) {
+    console.log(`left ${sk.changed_since_backup} that changed after the backup, ${sk.recent} that became active, `
+      + `${sk.folder_exists} whose folder came back, and ${sk.held} with real-project history.`);
+  }
+  console.log(`database now has ${result.total_tasks} tasks, ${formatBytes(result.bytes_after)} on disk`
+    + (result.vacuumed ? ' after vacuum.' : '. run again with --yes --vacuum to shrink the file.'));
+}
+
 function cmdReapMissionBlockers(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
@@ -10463,6 +10542,13 @@ function stampReadyVerifyMetadata(taskDb, db, taskId, verify) {
   if (!row) return;
   const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
   metadata.verify = verify;
+  // A real verify stamped at ready means the creation-time degraded flag is
+  // stale: clear it so `task show` stops warning about a missing check. A
+  // diff-only verify keeps the flag; it still cannot fail on real breakage.
+  if (verify.toLowerCase() !== 'git diff --check') {
+    delete metadata.verification_status;
+    delete metadata.verification_degraded_reason;
+  }
   db.prepare(`
     UPDATE tasks
        SET metadata = ?,
@@ -13369,6 +13455,7 @@ async function runTaskCommand(args) {
     case 'fail':   return cmdDone([...rest, '--failed']);
     case 'archive': return cmdArchive(rest);
     case 'clear-done': return cmdClearDone(rest);
+    case 'prune-test-junk': return cmdPruneTestJunk(rest);
     case 'keep': return cmdKeep(rest);
     case 'reap-mission-blockers':
     case 'reap-blockers':
@@ -13465,6 +13552,8 @@ async function run(args) {
 
 module.exports = {
   run,
+  chooseTaskOwner,
+  readTeamMembers,
   createTaskApiServer,
   taskDayGroups,
   taskDayTextGroups,

package/commands/transactions.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// atris transactions: every order, fee, trade, and wallet send, newest first.
+// Read only. Backend: GET /api/transactions.
+
+const { apiRequestJson } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+const { NOT_LOGGED_IN, oneLine, printResult } = require('../lib/developer-api');
+const { parseFlags, formatCents, errorFrom, commerceToken } = require('../lib/commerce');
+
+const TX_KINDS = ['ticket', 'shop', 'flight', 'test_purchase', 'fee', 'trade', 'wallet_send'];
+
+function showTransactionsHelp(log = console.log) {
+  log(`usage: atris transactions [--since YYYY-MM-DD] [--kind k[,k]] [--limit n] [--include-quotes] [--json]
+
+list what you bought, paid in fees, traded, or sent, newest first. read only.
+
+  --since   only rows on or after this date, like 2026-09-01
+  --kind    ${TX_KINDS.join(', ')}
+  --limit   1 to 200 (default 50)
+  --include-quotes  also list quotes nobody approved`);
+}
+
+function clip(text, width) {
+  const s = String(text == null ? '' : text).replace(/\s+/g, ' ').trim();
+  return s.length > width ? `${s.slice(0, width - 1)}…` : s;
+}
+
+function whenText(value) {
+  const s = String(value || '');
+  const m = s.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2})/);
+  return m ? `${m[1]} ${m[2]}` : clip(s, 16);
+}
+
+function renderTransactions(data = {}) {
+  const rows = Array.isArray(data.transactions) ? data.transactions : [];
+  const lines = [];
+  if (!rows.length) lines.push('No transactions yet.');
+  else {
+    const table = rows.map((r) => [
+      whenText(r.when),
+      clip(r.kind, 12),
+      clip(r.what, 40),
+      formatCents(r.amount_cents, r.currency),
+      clip(r.state, 16),
+    ]);
+    const head = ['WHEN', 'KIND', 'WHAT', 'AMOUNT', 'STATE'];
+    const widths = head.map((h, i) => Math.max(h.length, ...table.map((row) => row[i].length)));
+    const fmt = (row) => row.map((cell, i) => (i === 3 ? cell.padStart(widths[i]) : cell.padEnd(widths[i])))
+      .join('  ').trimEnd();
+    lines.push(fmt(head));
+    for (const row of table) lines.push(fmt(row));
+  }
+  const down = Object.entries(data.sources || {}).filter(([, v]) => v !== 'ok').map(([k]) => k);
+  if (down.length) lines.push('', `Partial list: could not load ${down.join(', ')}.`);
+  return lines.join('\n');
+}
+
+function buildQuery(flags) {
+  const params = new URLSearchParams();
+  if (flags.since != null) {
+    const since = String(flags.since).trim();
+    if (!/^\d{4}-\d{2}-\d{2}/.test(since)) return { ok: false, error: '--since must be a date like 2026-09-01' };
+    params.set('since', since);
+  }
+  const rawKind = flags.kind != null ? flags.kind : flags.kinds;
+  if (rawKind != null) {
+    const kinds = String(rawKind).split(',').map((k) => k.trim().toLowerCase()).filter(Boolean);
+    const bad = kinds.filter((k) => !TX_KINDS.includes(k));
+    if (bad.length || !kinds.length) return { ok: false, error: `--kind must be one of ${TX_KINDS.join(', ')}` };
+    params.set('kinds', kinds.join(','));
+  }
+  if (flags.limit != null) {
+    const limit = Number(flags.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 200) return { ok: false, error: '--limit must be a number from 1 to 200' };
+    params.set('limit', String(limit));
+  }
+  if (flags.include_quotes === true) params.set('include_quotes', 'true');
+  const qs = params.toString();
+  return { ok: true, path: qs ? `/transactions?${qs}` : '/transactions' };
+}
+
+async function transactionsCommand(args = [], deps = {}) {
+  const io = { log: deps.log || console.log, err: deps.err || console.error };
+  const { flags, pos } = parseFlags(args);
+  if (flags.help || pos[0] === 'help') {
+    showTransactionsHelp(io.log);
+    return 0;
+  }
+  const json = flags.json === true;
+  const fail = (error, status) => {
+    printResult({ json, ok: false, error, payload: { ok: false, error, ...(status ? { status } : {}) } }, io);
+    return 1;
+  };
+
+  const query = buildQuery(flags);
+  if (!query.ok) return fail(query.error);
+
+  const load = deps.loadCredentials || loadCredentials;
+  const request = deps.apiRequestJson || apiRequestJson;
+  const token = commerceToken(load(), 'transactions:read', deps.now ? deps.now() : Date.now());
+  if (!token) return fail(NOT_LOGGED_IN);
+
+  try {
+    const result = await request(query.path, { method: 'GET', token });
+    if (!result || !result.ok) return fail(errorFrom(result), result && result.status);
+    const data = result.data || {};
+    printResult({ json, ok: true, text: renderTransactions(data), payload: { ok: true, ...data } }, io);
+    return 0;
+  } catch (error) {
+    return fail(oneLine(error && error.message));
+  }
+}
+
+module.exports = { transactionsCommand };

package/commands/truth.js

@@ -7,7 +7,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateHome } = require('../lib/state-home');
 const { execFileSync } = require('child_process');
 const taskDb = require('../lib/task-db');
 const { parseScopeFlag } = require('../lib/cli-scope');
@@ -172,7 +172,7 @@ function loadFeatures(cwd) {
 }
 
 function loadHeartbeats() {
-  const hbDir = path.join(os.homedir(), '.atris', 'heartbeat');
+  const hbDir = path.join(stateHome(), '.atris', 'heartbeat');
   const registry = readJson(path.join(hbDir, 'registry.json'));
   const state = readJson(path.join(hbDir, 'state.json')) || {};
   if (!registry || !Array.isArray(registry.jobs)) return [];

package/commands/x-search.js

@@ -4,7 +4,9 @@ const fs = require('fs');
 const path = require('path');
 const { apiRequestJson } = require('../utils/api');
 const { ensureBilledCommandAuth } = require('./auth');
+const { spawnSync } = require('child_process');
 const applyGate = require('../lib/apply-gate');
+const { checkXPosts, annotateContent, formatTally } = require('../lib/x-post-check');
 const {
   fileTeachExperiment,
   extractTeachNumbers,
@@ -23,9 +25,10 @@ const KEEP_RULE = 'keep only if measure.py moves 0→1. scores 1 only when the f
 
 function showXSearchHelp(output = console.log, commandName = 'atris x-search') {
   output('');
-  output(`Usage: ${commandName} "<query>" [--limit N] [--days N] [--save] [--json]`);
-  output(`       ${commandName} person --name <name> [--handle <h>] [--company <c>] [--context <text>] [--save] [--json]`);
+  output(`Usage: ${commandName} "<query>" [--limit N] [--days N] [--save] [--json] [--no-check]`);
+  output(`       ${commandName} person --name <name> [--handle <h>] [--company <c>] [--context <text>] [--save] [--json] [--no-check]`);
   output(`       ${commandName} unsave <query-or-source>`);
+  output(`       ${commandName} bench [--quick|--free]`);
   output('');
   output(`Search X/Twitter via Atris (${COST_HINT}).`);
   output('Requires login. Same auth path as atris youtube process.');
@@ -33,13 +36,15 @@ function showXSearchHelp(output = console.log, commandName = 'atris x-search') {
   output('--save files a brief only when the result is rich.');
   output('unsave deletes the filed brief, apply stub, and matching experiment pack (no paid calls).');
   output('Empty or failed search prints credits refunded only when the server marks a refund.');
+  output('Each quoted post is looked up on X for free and marked checked, unverified, or unknown.');
   output('');
   output('Options:');
   output('  --limit <n>         Max results hint (search only)');
   output('  --days <n>          Only tweets from the last N days (search only)');
   output('  --save              File brief, journal, apply; rich results mint a keep/revert experiment');
   output('  --unsave            Delete filed brief, apply stub, and matching experiment pack (no paid calls)');
-  output('  --json              Print the raw JSON response');
+  output('  --json              Print the raw JSON response (plus a checks list)');
+  output('  --no-check          Skip looking up the quoted posts on X');
   output('  -h, --help          This help');
   output('');
   output('Person options:');
@@ -55,6 +60,7 @@ function showXSearchHelp(output = console.log, commandName = 'atris x-search') {
   output(`  ${commandName} person --name "Leah Bonvissuto" --handle leahbon`);
   output(`  ${commandName} unsave "MCP agents"`);
   output(`  ${commandName} --unsave "MCP agents"`);
+  output(`  ${commandName} bench --free`);
   output('');
 }
 
@@ -81,6 +87,7 @@ function parseSearchArgs(argv = []) {
     json: false,
     save: false,
     unsave: false,
+    check: true,
     query: null,
     limit: null,
     daysBack: null,
@@ -100,6 +107,8 @@ function parseSearchArgs(argv = []) {
       options.json = true;
     } else if (arg === '--save') {
       options.save = true;
+    } else if (arg === '--no-check') {
+      options.check = false;
     } else if (arg === '--unsave') {
       options.unsave = true;
     } else if (arg === '--limit') {
@@ -153,6 +162,7 @@ function parsePersonArgs(argv = []) {
     help: false,
     json: false,
     save: false,
+    check: true,
     name: null,
     handle: null,
     company: null,
@@ -173,6 +183,8 @@ function parsePersonArgs(argv = []) {
       options.json = true;
     } else if (arg === '--save') {
       options.save = true;
+    } else if (arg === '--no-check') {
+      options.check = false;
     } else if (arg === '--name') {
       options.name = readValue(args, i, arg);
       i++;
@@ -592,23 +604,26 @@ function ensureXSearchApply({ cwd, source, packRel, now, output } = {}) {
   });
 }
 
-function formatXSearchResult(data) {
+// check is the result of checkXPosts. With it, each post carries its own
+// link or warning, and citations no post uses are listed as other sources.
+function formatXSearchResult(data, check = null) {
   const lines = [];
   const content = xSearchContent(data);
   const citations = xSearchCitations(data);
 
   if (content) {
-    lines.push(content);
+    lines.push(check ? annotateContent(content, check) : content);
   } else if (data?.message) {
     lines.push(String(data.message).trim());
   } else {
     lines.push('X search completed');
   }
 
-  if (citations.length) {
+  const listed = check ? check.otherSources : citations;
+  if (listed.length) {
     lines.push('');
-    lines.push('Citations:');
-    for (const cite of citations) {
+    lines.push(check ? 'Other sources:' : 'Citations:');
+    for (const cite of listed) {
       lines.push(`  ${cite}`);
     }
   }
@@ -619,9 +634,54 @@ function formatXSearchResult(data) {
     lines.push(...creditLines);
   }
 
+  if (check) {
+    lines.push('');
+    lines.push(formatTally(check.tally));
+  }
+
   return lines.join('\n');
 }
 
+// Look the quoted posts up on X. Free, and never fatal: any failure means no
+// check, and the original output prints unchanged.
+async function checkXSearchPosts(data, options, deps = {}) {
+  if (options.check === false) return null;
+  try {
+    return await (deps.checkXPosts || checkXPosts)({
+      content: xSearchContent(data),
+      citations: xSearchCitations(data),
+      fetchPost: deps.fetchPost,
+      fetch: deps.fetch,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function renderXSearchResult(data, check) {
+  if (check) {
+    try {
+      return formatXSearchResult(data, check);
+    } catch {
+      // fall through to the original output
+    }
+  }
+  return formatXSearchResult(data);
+}
+
+function runXSearchBench(argv, deps = {}) {
+  const run = (deps.spawnSync || spawnSync)(
+    process.execPath,
+    [path.join(__dirname, '..', 'scripts', 'det', 'xsearch-bench.js'), ...argv],
+    { stdio: 'inherit' },
+  );
+  if (run.error) {
+    (deps.output || console.error)(`bench did not start: ${run.error.message}`);
+    return 1;
+  }
+  return typeof run.status === 'number' ? run.status : 1;
+}
+
 function formatEmptyXSearchResult(data) {
   const lines = ['no results'];
   const creditLines = formatCreditsLines(xSearchCredits(data));
@@ -634,6 +694,11 @@ function formatEmptyXSearchResult(data) {
 
 async function xSearchCommand(argv = process.argv.slice(3), deps = {}) {
   const output = deps.output || ((line = '') => console.log(line));
+  if (argv[0] === 'bench') {
+    const code = runXSearchBench(argv.slice(1), deps);
+    if (!deps.output && !deps.spawnSync) process.exit(code);
+    return code;
+  }
   let options;
   try {
     options = parseXSearchArgs(argv);
@@ -655,10 +720,14 @@ async function xSearchCommand(argv = process.argv.slice(3), deps = {}) {
   try {
     const data = await runXSearch(options, deps);
     const hasResults = xSearchHasResults(data);
+    const check = hasResults ? await checkXSearchPosts(data, options, deps) : null;
     if (options.json) {
-      output(JSON.stringify(data, null, 2));
+      const withChecks = check && data && typeof data === 'object' && !Array.isArray(data)
+        ? { ...data, checks: check.checks }
+        : data;
+      output(JSON.stringify(withChecks, null, 2));
     } else {
-      output(hasResults ? formatXSearchResult(data) : formatEmptyXSearchResult(data));
+      output(hasResults ? renderXSearchResult(data, check) : formatEmptyXSearchResult(data));
     }
     if (!hasResults) {
       if (
@@ -734,5 +803,7 @@ module.exports = {
   xSearchExperimentSlug,
   xSearchExperimentRel,
   unsaveXSearch,
+  formatXSearchResult,
+  runXSearchBench,
   xSearchCommand,
 };

package/commands/youtube.js

@@ -5,6 +5,7 @@ const { spawnSync } = require('child_process');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const https = require('https');
 
 const YTNOTES_USAGE = 'usage: ytnotes <youtube-url> [youtube-url-or-playlist...] [auto|gemini|haiku|atris-fast|grok|codex|cursor]';
@@ -40,6 +41,7 @@ function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output(`       ${commandName} watch list`);
   output(`       ${commandName} watch remove <number>`);
   output(`       ${commandName} watch tick`);
+  output(`       ${commandName} bench [--quick] [--case <name>]`);
   output(`       ${commandName} <youtube-url> [options]`);
   output('');
   output('search = free local discovery (ytsearch / yt-dlp), returns youtu.be links; rich free search writes one apply and a failing keep/revert pack; thin hands off to teach');
@@ -50,6 +52,7 @@ function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('process = 5 credits cloud knowledge (needs a filled Apply); rich process writes one apply and a failing keep/revert pack');
   output('digest = one decision page from this week\'s video briefs; rich digest writes one apply and a failing keep/revert pack');
   output('watch = subscribed channels turn into briefs without a human; add hands off to tick; tick hands off to teach when it briefed');
+  output('bench = run notes on real videos, uncached, and grade what a user gets; --quick runs the short video and the stranger checks');
   output('Process a YouTube video through Atris using timestamped transcript-first analysis.');
   output('Falls back to cloud video processing when local captions are unavailable.');
   output('');
@@ -2254,7 +2257,7 @@ function searchCacheTtlMs(deps = {}) {
 
 function resolveSearchCachePath(deps = {}) {
   if (deps.searchCachePath) return deps.searchCachePath;
-  const homeDir = deps.homeDir || os.homedir();
+  const homeDir = deps.homeDir || stateHome();
   return path.join(homeDir, '.atris', LOCAL_SEARCH_CACHE_FILE);
 }
 
@@ -3851,6 +3854,20 @@ async function runYoutubeTeach(args = [], deps = {}) {
   return applyCode;
 }
 
+// Bench the notes feature end to end. The script prints its own lines.
+function runYoutubeBench(argv, deps = {}) {
+  const run = (deps.spawnSync || spawnSync)(
+    process.execPath,
+    [path.join(__dirname, '..', 'scripts', 'det', 'ytrail-bench.js'), ...argv],
+    { stdio: 'inherit' },
+  );
+  if (run.error) {
+    (deps.output || console.error)(`bench did not start: ${run.error.message}`);
+    return 1;
+  }
+  return typeof run.status === 'number' ? run.status : 1;
+}
+
 async function youtubeCommand(argv = process.argv.slice(3), deps = {}) {
   const output = deps.output || ((line = '') => console.log(line));
   if (argv[0] === 'search') {
@@ -3880,6 +3897,11 @@ async function youtubeCommand(argv = process.argv.slice(3), deps = {}) {
     if (!deps.output && !deps.runner) process.exit(code);
     return code;
   }
+  if (argv[0] === 'bench') {
+    const code = runYoutubeBench(argv.slice(1), deps);
+    if (!deps.output && !deps.spawnSync) process.exit(code);
+    return code;
+  }
   if (argv[0] === 'watch') {
     const code = await watchCommand(argv.slice(1), { ...deps, output });
     if (!deps.output && !deps.fetcher && !deps.runner && !deps.briefFiler) process.exit(code);
@@ -3978,5 +4000,6 @@ module.exports = {
   searchApplyRel,
   firstRichWatchLesson,
   fileTeachExperiment,
+  runYoutubeBench,
   youtubeCommand,
 };

package/lib/autoland.js

@@ -7,6 +7,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { stateHome } = require('./state-home');
 const os = require('os');
 const { spawnSync } = require('child_process');
 const { computeTrustTier } = require('./trust-tiers');
@@ -189,7 +190,7 @@ function buildCronLine(root) {
   const node = process.execPath;
   const bin = path.join(root, 'bin', 'atris.js');
   const cliBin = fs.existsSync(bin) ? bin : 'atris';
-  const logDir = path.join(os.homedir(), '.atris', 'overnight');
+  const logDir = path.join(stateHome(), '.atris', 'overnight');
   const logFile = path.join(logDir, `autoland-${path.basename(root)}.log`);
   const invoke = cliBin.endsWith('.js') ? `${node} ${cliBin}` : cliBin;
   return `14 * * * * cd ${root} && ${invoke} autoland tick >> ${logFile} 2>&1 # ${cronMarker(root)}`;
@@ -210,7 +211,7 @@ function cronInstalled(root) {
 }
 
 function installCron(root) {
-  fs.mkdirSync(path.join(os.homedir(), '.atris', 'overnight'), { recursive: true });
+  fs.mkdirSync(path.join(stateHome(), '.atris', 'overnight'), { recursive: true });
   const marker = cronMarker(root);
   const kept = readCrontab().split(/\r?\n/).filter((line) => line.trim() && !line.includes(marker));
   const next = `${kept.join('\n')}${kept.length ? '\n' : ''}${buildCronLine(root)}\n`;

package/lib/ax-auto-lane.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const fs = require('node:fs');
-const os = require('node:os');
 const path = require('node:path');
+const { stateHome } = require('./state-home');
 
 const SHORT_LOOKUP_MAX_CHARS = 140;
 const LONG_INPUT_MIN_CHARS = 1200;
@@ -75,7 +75,7 @@ function overrideMatches(text, override) {
 function loadOverrides(filePath) {
   const resolved = filePath
     || process.env.ATRIS_ROUTER_OVERRIDES_PATH
-    || path.join(os.homedir(), '.atris', 'router-overrides.json');
+    || path.join(stateHome(), '.atris', 'router-overrides.json');
   try {
     const parsed = JSON.parse(fs.readFileSync(resolved, 'utf8'));
     return Array.isArray(parsed) ? parsed : [];

package/lib/brief-rules.js

@@ -0,0 +1,11 @@
+'use strict';
+
+// Rule lines every builder brief carries (lib/codex-flight.js buildPrompt and
+// lib/fleet.js buildFleetPrompt). The text lives here once so the two briefs
+// cannot drift apart.
+const SHARED_BRIEF_RULES = [
+  '- Keep one concern per PR; split anything larger into separate PRs because git history guides future agents and small PRs are cheap to revert and bisect.',
+  '- A guard, limit, or cache must hold on every path to the thing it protects; grep for the other callers, templates, and writers, and test at least one path you were not pointed at.',
+];
+
+module.exports = { SHARED_BRIEF_RULES };

package/lib/chat-log-scan.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('./state-home');
 
 const SCHEMA = 'atris.chat_scan.v1';
 const PROMPT_LINE = /^(?:max|pro|fast|code-fast)\s*›\s*(.+)$/i;
@@ -73,7 +74,7 @@ function axLogDirs(cwd = process.cwd(), options = {}) {
   const local = path.join(cwd, 'atris', 'runs');
   if (fs.existsSync(local)) dirs.push(local);
   if (options.global) {
-    const home = path.join(os.homedir(), '.atris', 'runs');
+    const home = path.join(stateHome(), '.atris', 'runs');
     if (fs.existsSync(home) && home !== local) dirs.push(home);
   }
   return dirs;

package/lib/ci-runner.js

@@ -2,6 +2,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { stateHome } = require('./state-home');
 const os = require('node:os');
 const https = require('node:https');
 const { spawn, spawnSync } = require('node:child_process');
@@ -9,7 +10,7 @@ const { spawn, spawnSync } = require('node:child_process');
 const RUNNER_VERSION = '2.336.0';
 const GITHUB_API_VERSION = '2026-03-10';
 
-function usageFilePath(home = os.homedir()) {
+function usageFilePath(home = stateHome()) {
   return path.join(home, '.atris', 'ci', 'usage.jsonl');
 }
 
@@ -309,7 +310,7 @@ async function ensureRunner(options = {}) {
   const version = options.version || RUNNER_VERSION;
   const platform = options.platform || process.platform;
   const arch = options.arch || process.arch;
-  const home = options.home || os.homedir();
+  const home = options.home || stateHome();
   const log = options.log || console.log;
   const asset = runnerAssetName(platform, arch, version);
   const runnerPlatform = platform === 'darwin' ? 'osx' : platform;