atris 3.37.1 → 3.38.0

package/README.md

@@ -226,6 +226,8 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 | `atris experiments` | Run small experiments and compare results |
 | `atris computer card` | Show or write the local owner/computer card |
 | `atris release` | Draft or publish a version bump, tag, GitHub release, and launch post |
+| `atris slop` | Deterministic slop detector: frontend/prose tells, plus `slop dead --exports` for dead code |
+| `atris clean` | Housekeeping: heal MAP refs, archive journals, report stale pages and dead code |
 
 ## Built-In Systems
 

package/atris/PERSONA.md

@@ -30,19 +30,15 @@ This defines how Atris agents communicate, decide, and work.
 
 **Read before you act.** Before planning or building, read the relevant files. Understand the current state. Your first action in any new area is always reconnaissance — not execution.
 
-**Always ask for intent.** Clarify before acting.
+**Ask for intent when it's fuzzy or the blast radius is real.** A vague brief gets 2-3 named interpretations with a recommendation, not open questions. Small, reversible, clearly-scoped work: act, then report. Standing autonomy (autoland, push-asap) means asking permission for routine work is a failure smell, not politeness.
 
-**Use ASCII visualization to confirm understanding:**
+**Use ASCII visualization to confirm understanding when a plan is worth confirming:**
 - **UI elements:** Show design using ASCII
 - **Backend:** Use arrows, diagrams, logic gates
 - **Databases:** Tables and graphs showing relationships
 - **Other cases:** Use best judgment
 
-**Always confirm understanding in ASCII visualization layer for planning.**
-
-Then go 3-4 sentences one by one through each task.
-
-Once every task is confirmed, create a plan.
+A one-file fix needs no diagram; a new surface or cross-system change does.
 
 **If a task is too big, break it down.** One job per task. If you can't describe "done" in one sentence, decompose it. Small precise tasks compound into big results.
 

package/atris.md

@@ -7,7 +7,9 @@ leave a trail another agent or human can trust.
 
 ## activate
 
-On session start, before responding:
+On session start, before responding (if the harness already booted for you, via a
+SessionStart hook or an `atris` status block in context, do not repeat it; go
+straight to the work):
 
 1. Read:
    - `atris/logs/YYYY/YYYY-MM-DD.md`: today's journal
@@ -39,13 +41,17 @@ If a task was already given, show the box and proceed with that task.
 
 You can move fast. You do not get to move blindly.
 
-Before changing anything, state:
+Scale ceremony to blast radius. Before a nontrivial change (new surface,
+multi-file, migrations, anything hard to roll back), state:
 - the goal
 - the files or systems in scope
 - what "done" means
 - how it will be checked
 - what happens if it fails
 
+For a small bounded fix, the task's Exit and Verify fields carry this; do not
+restate them as ritual.
+
 Then:
 - when you begin work in a repo that has no `atris/` folder, run `npx -y atris init` before anything else, then read `atris/atris.md`
 - do not execute if another agent owns the same task or files
@@ -90,6 +96,8 @@ The same discipline for words. Output stays sharp no matter how bloated the cont
   - "Missions survive everything: one engine starts the work, another picks it up cold, a third lands it. Work is no longer tied to a chat window, a session, or a vendor."
   - "The system reports in plain English: one daily message with what landed, what waits on you, and who should own what's next. One person can supervise many projects."
 - **Fit the screen.** An operator-facing report shows three results, air between them, and holds the rest on ask. No scrolling: reading it is one glance, and the reader asks for more if they want more.
+- **Pace with whitespace.** Words for the operator arrive as complete sentences, one or two per paragraph, blank line between. The whitespace does the pacing, never fragments: fast to scan, still flowing.
+- **Assume attention is scarce and ambition is not.** The reader is at the end of a long day and still moving something big forward. Nothing may require held state (remembering step 2 while reading step 5), every surface ends in one obvious next action that starts in under a minute, and each glance should leave the reader one step closer. Engineers and non-engineers get the same plain sentence; precision stays one ask away, never in the way.
 - **Human surfaces are gated.** Anything rendered for the operator (brief, digest, boot) goes through the operator-voice translator and a deterministic jargon gate; raw ids, commands, paths, and test tallies never reach a page. A gate violation is a build error, not a style note.
 - **Interview the fuzz.** When the operator hands off a fuzzy build ("make me the best X", "yeah ok this is my thought, go make it"), do not ask open questions and do not dispatch as-is. Offer 2-3 named interpretations with a recommendation ("best could mean capture, resurfacing, or closure: I'd bet resurfacing, right?") so the operator confirms or corrects in five words. Repeat until the brief fits one screen (goal, why now, done-looks-like, open risks), show the brief, then dispatch. The interview lends the operator a structure to think in; the sharpened brief is what makes every downstream lap cheap.
 

package/ax

@@ -12,7 +12,7 @@ const permissionGrants = require(path.join(__dirname, 'lib', 'permission-grants.
 const { loadCredentials } = require('./utils/auth');
 const { apiRequestJson, getApiBaseUrl } = require('./utils/api');
 const missionRuntime = require('./lib/mission-runtime-loop');
-const { pickLane } = require('./lib/ax-auto-lane');
+const { loadOverrides, pickLane } = require('./lib/ax-auto-lane');
 
 const EXIT_WORDS = new Set(['exit', 'quit', ':q']);
 const BACKEND = {
@@ -957,16 +957,92 @@ function normalizeMode(mode) {
   return mode === 'fast' ? 'fast' : 'pro';
 }
 
+function autoPickLogPath(options = {}) {
+  return options.pickLogPath
+    || process.env.ATRIS_ROUTER_PICKS_PATH
+    || path.join(os.homedir(), '.atris', 'ax-auto-picks.jsonl');
+}
+
+function autoMessageWords(message) {
+  return new Set(String(message || '').toLowerCase().match(/[a-z0-9]+/g) || []);
+}
+
+function autoMessageOverlap(left, right) {
+  const leftWords = autoMessageWords(left);
+  const rightWords = autoMessageWords(right);
+  const union = new Set([...leftWords, ...rightWords]);
+  if (!union.size) return 0;
+  let shared = 0;
+  for (const word of leftWords) {
+    if (rightWords.has(word)) shared += 1;
+  }
+  return shared / union.size;
+}
+
+function appendRephrasedOutcome(message, logPath) {
+  try {
+    const rows = fs.readFileSync(logPath, 'utf8').split(/\r?\n/).filter((line) => line.trim());
+    let previous = null;
+    for (let index = rows.length - 1; index >= 0; index -= 1) {
+      try {
+        const row = JSON.parse(rows[index]);
+        if (row && row.pick_id && row.lane && row.message) {
+          previous = row;
+          break;
+        }
+      } catch (_) {
+        // Ignore malformed historical lines.
+      }
+    }
+    if (!previous) return;
+    const ageMs = Date.now() - Date.parse(previous.at);
+    if (ageMs < 0 || ageMs >= 10 * 60 * 1000) return;
+    if (autoMessageOverlap(previous.message, message) < 0.5) return;
+    fs.appendFileSync(logPath, `${JSON.stringify({
+      event: 'outcome',
+      pick_id: previous.pick_id,
+      outcome: 'rephrased',
+    })}\n`);
+  } catch (_) {
+    // Rephrase detection is best-effort and must never block a turn.
+  }
+}
+
 function appendAutoPick(message, picked, options = {}) {
+  const pick = { ...picked, pick_id: crypto.randomUUID() };
+  const logPath = autoPickLogPath(options);
+  Object.defineProperty(pick, '_logPath', { value: logPath, enumerable: false });
   try {
-    const dir = path.join(os.homedir(), '.atris');
-    fs.mkdirSync(dir, { recursive: true });
-    fs.appendFileSync(path.join(dir, 'ax-auto-picks.jsonl'), `${JSON.stringify({
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    appendRephrasedOutcome(message, logPath);
+    fs.appendFileSync(logPath, `${JSON.stringify({
       at: new Date().toISOString(),
-      lane: picked.lane,
-      reason: picked.reason,
+      pick_id: pick.pick_id,
+      lane: pick.lane,
+      reason: pick.reason,
+      message: String(message || ''),
       message_chars: String(message || '').length,
       print: Boolean(options.print),
+      ...(pick.override_id ? { override_id: pick.override_id } : {}),
+    })}\n`);
+  } catch (_) {
+    // Lane telemetry is best-effort and must never block a turn.
+  }
+  return pick;
+}
+
+function appendAutoOutcome(picked, result, options = {}) {
+  if (!picked || !picked.pick_id) return;
+  try {
+    const logPath = autoPickLogPath({ pickLogPath: options.pickLogPath || picked._logPath });
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.appendFileSync(logPath, `${JSON.stringify({
+      event: 'outcome',
+      pick_id: picked.pick_id,
+      ok: Boolean(result && result.ok),
+      model: String((result && result.model) || modelForMode(picked.lane)),
+      duration_ms: Number((result && (result.duration_ms || result.durationMs)) || 0),
+      error: result && result.error ? String(result.error) : null,
     })}\n`);
   } catch (_) {
     // Lane telemetry is best-effort and must never block a turn.
@@ -974,8 +1050,10 @@ function appendAutoPick(message, picked, options = {}) {
 }
 
 function autoLaneForMessage(message, options = {}) {
-  const picked = pickLane(message);
-  appendAutoPick(message, picked, options);
+  const overrides = Array.isArray(options.overrides)
+    ? options.overrides
+    : loadOverrides(options.overridesPath);
+  const picked = appendAutoPick(message, pickLane(message, { overrides }), options);
   const errorOutput = options.errorOutput || process.stderr;
   errorOutput.write(`${picked.reason}\n`);
   return picked;
@@ -3016,8 +3094,11 @@ async function runHeadlessTurn(message, options = {}) {
   const startedAt = Date.now();
   const sink = options.output || bufferedOutput();
   const turnFunction = options.turnFunction || turnFunctionForMode(mode);
-  const autoFields = options.autoLane && options.autoReason
-    ? { auto_lane: normalizeMode(options.autoLane), auto_reason: String(options.autoReason) }
+  const autoPick = options.autoPick || null;
+  const autoFields = autoPick
+    ? { auto_lane: normalizeMode(autoPick.lane), auto_reason: String(autoPick.reason) }
+    : options.autoLane && options.autoReason
+      ? { auto_lane: normalizeMode(options.autoLane), auto_reason: String(options.autoReason) }
     : {};
 
   try {
@@ -3030,15 +3111,17 @@ async function runHeadlessTurn(message, options = {}) {
       output: sink,
       showProgress: false,
     });
-    return {
+    const payload = {
       ok: true,
       model: modelForMode(mode),
       output: String((result && result.output) || '').trim(),
       durationMs: Number((result && result.durationMs) || 0) || (Date.now() - startedAt),
       ...autoFields,
     };
+    appendAutoOutcome(autoPick, payload);
+    return payload;
   } catch (error) {
-    return {
+    const payload = {
       ok: false,
       model: modelForMode(mode),
       output: '',
@@ -3046,6 +3129,8 @@ async function runHeadlessTurn(message, options = {}) {
       error: String((error && error.message) || error || 'headless turn failed'),
       ...autoFields,
     };
+    appendAutoOutcome(autoPick, payload);
+    return payload;
   }
 }
 
@@ -3125,11 +3210,16 @@ async function chat(options = {}) {
       return false;
     }
 
+    let autoPick = null;
     if (options.auto) {
-      mode = autoLaneForMessage(trimmed, {
+      autoPick = autoLaneForMessage(trimmed, {
         errorOutput: options.errorOutput,
         print: false,
-      }).lane;
+        overrides: options.overrides,
+        overridesPath: options.overridesPath,
+        pickLogPath: options.pickLogPath,
+      });
+      mode = autoPick.lane;
     }
 
     if (logger) logger.write(`${formatPrompt(mode)}${trimmed}\n`);
@@ -3230,22 +3320,38 @@ async function chat(options = {}) {
       lastCompactionNotice = compactedTurns;
       output.write(`${paint(`· context: ${compactedTurns} earlier turn${compactedTurns === 1 ? '' : 's'} compacted into a digest`, [ANSI.muted], output)}\n`);
     }
-    const result = await turnFunction(trimmed, {
-      mode,
-      cwd,
-      history,
-      input,
-      output,
-      route,
-      business: options.business,
-      verify: options.verify,
-      conversationId,
-      turnId,
-      approveBackendApi: options.approveBackendApi,
-      apiRequestJson: options.apiRequestJson,
-      loadCredentials: options.loadCredentials,
-      getApiBaseUrl: options.getApiBaseUrl,
-    });
+    let result;
+    try {
+      result = await turnFunction(trimmed, {
+        mode,
+        cwd,
+        history,
+        input,
+        output,
+        route,
+        business: options.business,
+        verify: options.verify,
+        conversationId,
+        turnId,
+        approveBackendApi: options.approveBackendApi,
+        apiRequestJson: options.apiRequestJson,
+        loadCredentials: options.loadCredentials,
+        getApiBaseUrl: options.getApiBaseUrl,
+      });
+      appendAutoOutcome(autoPick, {
+        ok: true,
+        model: modelForMode(mode),
+        durationMs: Number(result && result.durationMs) || (Date.now() - turnStartedAt),
+      });
+    } catch (error) {
+      appendAutoOutcome(autoPick, {
+        ok: false,
+        model: modelForMode(mode),
+        durationMs: Date.now() - turnStartedAt,
+        error: String((error && error.message) || error),
+      });
+      throw error;
+    }
     if (result.output && !result.output.endsWith('\n')) output.write('\n');
     const approvalExecution = normalizeMode(mode) === 'code-fast'
       ? null
@@ -4288,8 +4394,7 @@ async function main() {
           route: route === 'auto' ? undefined : route,
           business,
           verify,
-          autoLane: autoPick && autoPick.lane,
-          autoReason: autoPick && autoPick.reason,
+          autoPick,
         })
         : { ok: false, model: modelForMode(mode), output: '', durationMs: 0, error: 'missing prompt' };
       console.log(JSON.stringify(payload));
@@ -4305,7 +4410,23 @@ async function main() {
     console.log('');
     maybeWriteAtrisGoalBanner(process.stdout, process.cwd());
     const turnStartedAt = Date.now();
-    const result = await turnFunctionForMode(mode)(prompt, { mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify });
+    let result;
+    try {
+      result = await turnFunctionForMode(mode)(prompt, { mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify });
+      appendAutoOutcome(autoPick, {
+        ok: true,
+        model: modelForMode(mode),
+        durationMs: Number(result && result.durationMs) || (Date.now() - turnStartedAt),
+      });
+    } catch (error) {
+      appendAutoOutcome(autoPick, {
+        ok: false,
+        model: modelForMode(mode),
+        durationMs: Date.now() - turnStartedAt,
+        error: String((error && error.message) || error),
+      });
+      throw error;
+    }
     const receipt = receiptFromState(result);
     const approvalRequest = normalizeMode(mode) === 'code-fast' ? null : approvalRequestFromReceipt(receipt);
     const approvalRecord = approvalRequest
@@ -4338,6 +4459,10 @@ if (require.main === module) {
 }
 
 module.exports = {
+  appendAutoOutcome,
+  appendAutoPick,
+  autoLaneForMessage,
+  autoMessageOverlap,
   authToken,
   authUserId,
   approvalExecutionRequestFromReceipt,

package/bin/atris.js

@@ -519,6 +519,8 @@ function showHelp() {
   console.log('  close      - track open loops with deadlines and daily escalation');
   console.log('  harvest    - Find bugs and next actions from receipts, run logs, and thinking');
   console.log('  verify     - Validate work is done (tests, MAP.md, changes)');
+  console.log('  slop       - Deterministic slop detector: frontend/prose tells, dead code (slop dead --exports)');
+  console.log('  recover    - Explain stopped missions; --apply performs safe recovery only');
   console.log('  task       - Local agent task plane (atomic claims, TODO import)');
   console.log('  golden path (zero human turns):');
   console.log('    atris task delegate "fix the login bug" --to <member>');
@@ -535,10 +537,11 @@ function showHelp() {
   console.log('  avail      - Booking availability (/book/{username} weekly windows)');
   console.log('  brain      - Compile MAP/TODO/wiki/state into a loadable agent brain');
   console.log('  lesson     - Append a one-line lesson to atris/lessons.md (mine: distill receipts/episodes/scorecards into policy lessons)');
+  console.log('  teach      - Turn a bad turn into a failing benchmark, then a permanent guard (red gate: no promotion without a proven failure)');
   console.log('  ingest     - Local-first wiki ingest into atris/wiki/');
   console.log('  query      - Local-first wiki query against atris/wiki/');
   console.log('  lint       - Local-first wiki lint for atris/wiki/');
-  console.log('  loop       - Local wiki upkeep loop (stale pages, orphans, next ingest)');
+  console.log('  loop       - Recurring loops front door (wiki upkeep lives under: loop wiki)');
   console.log('  write      - Guided writing sessions: you write every word, atris structures + reviews');
   console.log('');
   console.log('Optional helpers:');
@@ -550,6 +553,7 @@ function showHelp() {
   console.log('  drive      - One self-driving tick: mission doctor -> auto-fix -> count disengagements');
   console.log('  autoland   - Approve the policy once; certified work lands itself, you keep irreversible calls');
   console.log('  engine     - Engine registry: list/resolve roles, health flips, default engine, `engine test`, and dispatch flights');
+  console.log('  router     - inspect ax lane outcomes and promote gated reflex overrides');
   console.log('  sign       - Co-author trailer on every commit in an atris workspace (on/off/status)');
   console.log('  visualize  - Generate a Slack/deck-ready visual from a prompt');
   console.log('  youtube    - Process YouTube videos with timestamped transcript-first analysis');
@@ -575,6 +579,7 @@ function showHelp() {
   console.log('Sync:');
   console.log('  pull       - Pull journals + member data from cloud');
   console.log('  push       - Push workspace files to cloud');
+  console.log('  sync-checkout - fetch and fast-forward a clean current branch');
   console.log('  cloud      - Delete cloud files not present locally (cloud clean --dry-run|--yes)');
   console.log('  live       - Keep a business brain fresh (doctor, pull, watch, push)');
   console.log('  clean-workspace <slug> - Analyze & remove junk files from a workspace (alias: cw)');
@@ -1617,6 +1622,11 @@ function showWelcomeVisualization() {
     console.log(`  learned \"${latestBriefTitle}\" overnight -> atris/wiki/briefs/${latestBriefName}`);
   }
 
+  const checkoutWarning = require('../lib/checkout-sync').checkoutBehindMessage(cwd);
+  if (checkoutWarning) {
+    console.log(`  ${checkoutWarning}`);
+  }
+
   // Show the work itself, not counts. A newcomer in any domain (code, docs,
   // a travel plan) should read actual task names and know what's happening.
   // Waiting-on-you comes first: the one thing only a human can do.
@@ -1694,6 +1704,16 @@ function showWelcomeVisualization() {
     console.log(row('tidy', tidyBits.join(', ')));
   }
 
+  let wikiNudge = '';
+  try {
+    wikiNudge = require('../lib/wiki').wikiMetabolismNudge(cwd);
+  } catch {
+    wikiNudge = '';
+  }
+  if (wikiNudge) {
+    console.log(`  ${wikiNudge}`);
+  }
+
   console.log(row('logs', journalEntries > 0
     ? `${journalEntries} note${journalEntries === 1 ? '' : 's'} today`
     : 'nothing yet today'));
@@ -1792,6 +1812,9 @@ if (command === 'init') {
   Promise.resolve(require('../commands/bench').benchCommand(process.argv.slice(3)))
     .then((code) => process.exit(code || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(2); });
+} else if (command === 'router') {
+  const code = require('../commands/router').routerCommand(process.argv.slice(3));
+  if (Number.isInteger(code) && code !== 0) process.exit(code);
 } else if (command === 'mission') {
   // process.exit() can outrun a piped stdout: writes beyond the 64KB pipe
   // buffer are async, so large --json payloads truncate at 64KB multiples.
@@ -1804,6 +1827,10 @@ if (command === 'init') {
   Promise.resolve(require('../commands/mission').missionCommand(process.argv.slice(3)))
     .then(() => exitAfterStdoutDrain(process.exitCode || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); exitAfterStdoutDrain(1); });
+} else if (command === 'recover') {
+  Promise.resolve(require('../commands/recover').recoverCommand(process.argv.slice(3)))
+    .then((code) => process.exit(code || 0))
+    .catch((err) => { console.error(`\nerror: ${err.message || err}`); process.exit(1); });
 } else if (command === 'agents') {
   // Glanceable view of every member's state: stuck, waiting on you, working, resting.
   const code = require('../commands/agents').agentsCommand(process.argv.slice(3));
@@ -1931,8 +1958,17 @@ if (command === 'init') {
     logCmd();
   }
 } else if (command === 'logs') {
+  const logsArgs = process.argv.slice(3);
+  if (logsArgs.includes('--help') || logsArgs.includes('-h') || logsArgs[0] === 'help') {
+    console.log('Usage: atris logs [--date YYYY-MM-DD] [--json]');
+    console.log('');
+    console.log('  atris logs               Show today\'s workspace + team journal digest');
+    console.log('  atris logs --date <day>  Show the digest for a specific day');
+    console.log('  atris logs --json        Emit the digest as JSON');
+    process.exit(0);
+  }
   try {
-    require('../commands/log').logsDigest(process.argv.slice(3));
+    require('../commands/log').logsDigest(logsArgs);
     process.exit(0);
   } catch (error) {
     console.error(error.message || String(error));
@@ -1956,6 +1992,9 @@ if (command === 'init') {
   activateCmd();
 } else if (command === 'watch') {
   require('../commands/watch').watchAtris();
+} else if (command === 'sync-checkout') {
+  const code = require('../commands/sync-checkout').syncCheckoutCommand(process.argv.slice(3));
+  process.exit(code);
 } else if (command === 'update' || command === 'sync') {
   const args = process.argv.slice(3);
   const firstSyncArg = process.argv[3];
@@ -2514,6 +2553,10 @@ if (command === 'init') {
   require('../commands/gm').gmCommand(...process.argv.slice(3))
     .then(() => process.exit(0))
     .catch((err) => { console.error(`✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'game') {
+  require('../commands/game').gameCommand(process.argv.slice(3))
+    .then((status) => process.exit(status === 1 ? 1 : 0))
+    .catch((err) => { console.error(`✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'github') {
   const status = require('../commands/github').githubCommand(process.argv.slice(3));
   process.exit(status);
@@ -2590,6 +2633,10 @@ if (command === 'init') {
   const subcommand = process.argv[3];
   const args = process.argv.slice(4);
   require('../commands/lesson')(subcommand, ...args);
+} else if (command === 'teach') {
+  const subcommand = process.argv[3];
+  const args = process.argv.slice(4);
+  require('../commands/teach')(subcommand, ...args);
 } else if (command === 'skill') {
   const subcommand = process.argv[3];
   const args = process.argv.slice(4);

package/commands/activate.js

@@ -110,6 +110,15 @@ function completionSentence(completions) {
   return humanSentence(`since last time: ${landed}; the biggest: ${biggest}.`);
 }
 
+// STATUS.md bullets can carry paths and counts the gate would reject, so the
+// narration only says that attention is needed, never quotes the bullet.
+function wikiHealthSentence(wikiStatus) {
+  if (!wikiStatus || !Array.isArray(wikiStatus.bullets)) return null;
+  const needsAttention = wikiStatus.bullets.some((b) => /stale|orphan/i.test(b));
+  if (!needsAttention) return null;
+  return humanSentence('the wiki has pages going stale; refresh them: atris loop wiki');
+}
+
 function activeWorkSentence(state, context) {
   const tasks = Array.isArray(context?.inProgressTasks) ? context.inProgressTasks : [];
   if (tasks.length) {
@@ -237,13 +246,14 @@ function activateAtris() {
   } catch {}
 
   let moves = [];
+  let clarityLine = null;
   try {
     const { nextMoves } = require('../lib/next-moves');
     const { profilePaths } = require('../lib/clarity');
     const root = process.cwd();
     moves = nextMoves(root, 3);
     const { profile, mdPath } = readActivationClarityProfile(root, profilePaths);
-    formatClarityLine(profile, rel(mdPath));
+    clarityLine = formatClarityLine(profile, rel(mdPath));
   } catch { /* alive onboarding is best-effort; never block activate */ }
 
   let briefData = null;
@@ -258,7 +268,6 @@ function activateAtris() {
 
   void dateFormatted;
   void learningCount;
-  void wikiStatus;
   fs.existsSync(personaFile);
   fs.existsSync(mapFile);
   void taskFilePath;
@@ -269,6 +278,7 @@ function activateAtris() {
     handoffSentence(handoffContent),
     completionSentence(recentCompletions),
     activeWorkSentence(state, context),
+    wikiHealthSentence(wikiStatus),
   ].filter(Boolean);
   if (Array.isArray(briefData?.waiting)) {
     const approvalCount = briefData.waiting.length;
@@ -284,6 +294,9 @@ function activateAtris() {
     statusLines.forEach((line) => console.log(line));
   }
 
+  console.log('');
+  console.log(clarityLine || 'Tip: run atris clarity once so agents learn how you work.');
+
   const nextMove = moves[0] || briefData?.moves?.[0];
   const nextMoveTitle = focusFragment(nextMove?.title, 100);
   if (nextMoveTitle) {
@@ -292,4 +305,4 @@ function activateAtris() {
   }
 }
 
-module.exports = { activateAtris };
+module.exports = { activateAtris, wikiHealthSentence };

package/commands/agent-spawn.js

@@ -463,18 +463,11 @@ function agentSpawnStatusCommand(args = [], deps = {}) {
 }
 
 module.exports = {
-  SPAWN_SCHEMA,
-  SPAWN_STATE_REL,
   parseSpawnArgs,
-  buildDelegatePrompt,
   commandForEngine,
   createSpawnRequest,
   agentDogfoodCommand,
-  parseDogfoodArgs,
-  runDogfoodEngine,
-  loadSpawnRequests,
   agentSpawnCommand,
   agentSpawnListCommand,
   agentSpawnStatusCommand,
-  showSpawnHelp,
 };