atris 3.34.0 → 3.36.0

package/lib/autoland.js

@@ -9,11 +9,43 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { spawnSync } = require('child_process');
+const { computeTrustTier } = require('./trust-tiers');
 
 const DEFAULT_DIGEST_HOUR = 9;
 const DEFAULT_ALARM_HOURS = 24;
-const OPERATOR_WHY = /\b(sav(?:e|es|ing)|burn(?:s|ing)?|wast(?:e|es|ing)|cost(?:s|ing)?|prevent\w*|stop(?:s|ping)?|break(?:s|ing)?|fail(?:s|ing)?|slow(?:s|er)?|faster|cheaper|easier|clearer|safer|simpler|trust|revenue|users?|customers?|so that|because)\b/i;
-const AGENT_JARGON = /[a-z0-9]_[a-z0-9]|\b[a-z]+[A-Z]\w*|--[a-z]|\bCLI-\d+/;
+const OPERATOR_WHY = /\b(sav(?:e|es|ing)|burn(?:s|ing)?|wast(?:e|es|ing)|cost(?:s|ing)?|prevent\w*|reduc\w*|risk|stop(?:s|ping)?|break(?:s|ing)?|fail(?:s|ing)?|slow(?:s|er)?|faster|cheaper|easier|clearer|safer|simpler|trust|revenue|instead|rather than|so(?: that)?|because)\b/i;
+const AGENT_JARGON = /\b[a-z0-9]+(?:_[a-z0-9]+)+\b|\b[a-z]+(?:[A-Z][A-Za-z0-9]*)+\b|--[a-z][a-z-]*\b|\bCLI-\d+\b/;
+const RESULT_ULID = /\b[0-9A-HJKMNP-TV-Z]{20,}\b/;
+const RESULT_TICKET = /\b[A-Z]{2,4}-\d+\b/;
+const RESULT_FILE_PATH = /\b(?:[\w.-]+\/)*[\w.-]+\.(?:js|md|py|json|ts)(?::\d+)?\b/i;
+const RESULT_COMMAND = /--|->|\b(?:npm|node|grep|git)\s+/i;
+const SHELL_COMMAND_FRAGMENT = /\b(?:npm|node|git|grep)\s+[^\s,;]+|->/i;
+const TRAILING_FRAGMENT_WORDS = new Set([
+  'after',
+  'and',
+  'as',
+  'at',
+  'because',
+  'before',
+  'by',
+  'for',
+  'from',
+  'in',
+  'into',
+  'of',
+  'on',
+  'or',
+  'over',
+  'so',
+  'than',
+  'that',
+  'the',
+  'to',
+  'under',
+  'with',
+  'without',
+]);
+const COMPLETE_TRAILING_PHRASE = /\b(?:enough|what|which)\s+to\s+(?:act|focus|work)\s+on[.!?]$/i;
 
 function policyPath(root) {
   return path.join(root, '.atris', 'policy', 'autoland.json');
@@ -36,9 +68,29 @@ function writeJson(file, value) {
   fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
 }
 
+// Default is ON: agents are good enough that a growing review queue is
+// latency, not safety — the denied tags keep the irreversible lanes human.
+// A missing policy file means "on, owner inferred"; only an explicit
+// `atris autoland off` (enabled: false) turns it off.
+function inferOwner(root) {
+  const git = spawnSync('git', ['config', 'user.name'], { cwd: root, encoding: 'utf8' });
+  const name = git.status === 0 ? String(git.stdout || '').trim() : '';
+  return name || os.userInfo().username;
+}
+
+function defaultPolicy(root) {
+  return {
+    enabled: true,
+    enabled_by: inferOwner(root),
+    enabled_at: null,
+    daily_experiment: true,
+    default: true,
+  };
+}
+
 function readPolicy(root) {
   const policy = readJson(policyPath(root), null);
-  if (!policy || typeof policy !== 'object') return null;
+  if (!policy || typeof policy !== 'object') return defaultPolicy(root);
   return policy;
 }
 
@@ -134,8 +186,10 @@ function waitingOnHuman(tasks, now = Date.now()) {
     .map((t) => ({
       ref: t.display_id || t.legacy_ref || t.id,
       title: String(t.title || '').slice(0, 200),
+      result: String(t.result || t.metadata?.result || '').slice(0, 220),
       tag: String(t.tag || ''),
       hours: waitingHours(t, now),
+      member: String(t.claimed_by || t.assigned_to || '').trim(),
     }))
     .sort((a, b) => b.hours - a.hours);
 }
@@ -149,8 +203,9 @@ function acceptedInLastDay(tasks, now = Date.now()) {
     const entry = {
       ref: t.display_id || t.legacy_ref || t.id,
       title: String(t.title || '').slice(0, 120),
+      result: String(t.result || t.metadata?.result || '').slice(0, 220),
       happened: String(t.review?.landing?.happened || t.metadata?.landing_happened || '').slice(0, 300),
-      member: String(t.claimed_by || t.assigned_to || '').trim(),
+      member: String(t.claimed_by || t.metadata?.executed_by || t.assigned_to || '').trim(),
     };
     if (t.metadata?.auto_accepted_at) auto.push(entry);
     else human.push(entry);
@@ -162,6 +217,83 @@ function plur(n, word) {
   return `${n} ${word}${n === 1 ? '' : 's'}`;
 }
 
+function pauseReasonDigestLabel(reason) {
+  if (reason === 'auth-required') return 'awaiting login';
+  if (reason === 'model-unavailable') return 'awaiting an available model';
+  if (reason === 'rate-limit-exceeded-wall') return 'waiting for the rate-limit reset';
+  if (reason === 'stale' || reason === 'paused-idle') return 'stale after the idle window';
+  return 'paused for operator action';
+}
+
+function normalizeReasonTally(value) {
+  const tally = {};
+  if (!value || typeof value !== 'object') return tally;
+  for (const [reason, count] of Object.entries(value)) {
+    const cleanReason = String(reason || '').trim();
+    const n = Number(count) || 0;
+    if (cleanReason && n > 0) tally[cleanReason] = (tally[cleanReason] || 0) + n;
+  }
+  return tally;
+}
+
+function heldReasonTally(janitor) {
+  const holds = janitor?.mission_holds && typeof janitor.mission_holds === 'object'
+    ? Object.values(janitor.mission_holds)
+    : [];
+  const tally = {};
+  for (const hold of holds) {
+    const reason = String(hold?.reason || '').trim();
+    if (reason) tally[reason] = (tally[reason] || 0) + 1;
+  }
+  if (holds.length > 0) return tally;
+  return normalizeReasonTally(janitor?.missions_held_reasons);
+}
+
+function pushJanitorMissionReasonLines(lines, janitor) {
+  const held = heldReasonTally(janitor);
+  for (const [reason, count] of Object.entries(held).sort()) {
+    lines.push(`held: ${plur(count, 'mission')} ${pauseReasonDigestLabel(reason)} (${reason})`);
+  }
+  const stopped = normalizeReasonTally(janitor?.mission_stop_reasons || janitor?.missions_stopped_reasons);
+  for (const [reason, count] of Object.entries(stopped).sort()) {
+    lines.push(`stopped: ${plur(count, 'mission')} ${pauseReasonDigestLabel(reason)} (${reason})`);
+  }
+}
+
+function pushLandingSweepLines(lines, landingSweep) {
+  if (!landingSweep || typeof landingSweep !== 'object') return;
+  const stale = Array.isArray(landingSweep.stale) ? landingSweep.stale : [];
+  const staleCount = Number(landingSweep.stale_count) || stale.length;
+  if (staleCount > 0) {
+    const oldest = stale[0];
+    const oldestText = oldest
+      ? `; oldest: ${oldest.name} (${Number(oldest.activityHours || oldest.ageHours || 0)}h)`
+      : '';
+    lines.push(`stuck in the air past 48h: ${plur(staleCount, 'piece')} need${staleCount === 1 ? 's' : ''} a human${oldestText}; inspect: atris land`);
+  }
+  const human = Array.isArray(landingSweep.human) ? landingSweep.human : [];
+  const humanCount = Number(landingSweep.human_count) || human.length;
+  if (humanCount > 0) {
+    const first = human[0] ? ` ${finishThought(human[0], 130)}` : '';
+    const more = humanCount > 1 ? `; ${humanCount - 1} more` : '';
+    lines.push(`cleanup needs a human:${first}${more}`);
+  }
+}
+
+function pushWaitingWishLines(lines, waitingWishes) {
+  const wishes = (Array.isArray(waitingWishes) ? waitingWishes : [])
+    .filter((wish) => wish && String(wish.text || '').trim());
+  if (!wishes.length) return;
+  lines.push(`${plur(wishes.length, 'wish')} waiting on you:`);
+  for (const wish of wishes.slice(0, 2)) {
+    const text = finishThought(String(wish.text || '').replace(/[.\s]+$/, ''), 90);
+    const need = cutAtWord(String(wish.need || 'answer the open question before it can start'), 120);
+    lines.push(`- ${text}: ${need}`);
+  }
+  const hidden = Math.max(0, wishes.length - 2);
+  if (hidden > 0) lines.push(`- ${plur(hidden, 'more wish')} waiting on an answer`);
+}
+
 function cutAtWord(text, max) {
   const clean = String(text || '').replace(/\s+/g, ' ').trim();
   if (clean.length <= max) return clean;
@@ -170,19 +302,63 @@ function cutAtWord(text, max) {
   return `${cut.slice(0, lastSpace > max * 0.6 ? lastSpace : max)}...`;
 }
 
+function stripDanglingFragment(text) {
+  let out = String(text || '').replace(/\s+/g, ' ').trim();
+  while (out.includes('(') && out.lastIndexOf('(') > out.lastIndexOf(')')) {
+    out = out.slice(0, out.lastIndexOf('(')).trim();
+  }
+  out = out.replace(/[,\s;:]+$/g, '').trim();
+  while (out) {
+    const withoutPunctuation = out.replace(/[.!?]+$/g, '').trim();
+    const word = (withoutPunctuation.match(/[A-Za-z]+$/) || [''])[0].toLowerCase();
+    if (!TRAILING_FRAGMENT_WORDS.has(word)) break;
+    out = withoutPunctuation.slice(0, Math.max(0, withoutPunctuation.length - word.length)).replace(/[,\s;:]+$/g, '').trim();
+  }
+  return out;
+}
+
 // A line ends where a thought ends. Long lines close at their last complete
 // clause inside the budget and read whole: no ellipsis, nothing dangling.
 // Only when a line has no clause boundary at all does a word cut remain.
 function finishThought(text, max = 160) {
-  const clean = String(text || '').replace(/\s+/g, ' ').trim().replace(/[,;:\s]+$/, '');
+  const clean = stripDanglingFragment(String(text || '').replace(/\s+/g, ' ').trim().replace(/[,;:\s]+$/, ''));
   if (clean.length <= max) return clean;
   const cut = clean.slice(0, max);
   const sentence = Math.max(cut.lastIndexOf('. '), cut.lastIndexOf('! '), cut.lastIndexOf('? '));
-  if (sentence > max * 0.3) return cut.slice(0, sentence + 1);
+  if (sentence > max * 0.3) return stripDanglingFragment(cut.slice(0, sentence + 1));
   const clause = Math.max(cut.lastIndexOf(', '), cut.lastIndexOf('; '), cut.lastIndexOf(' ('), cut.lastIndexOf(': '));
-  if (clause > max * 0.45) return cut.slice(0, clause);
+  if (clause > max * 0.45) return stripDanglingFragment(cut.slice(0, clause));
   const space = cut.lastIndexOf(' ');
-  return `${cut.slice(0, space > max * 0.6 ? space : max)}...`;
+  return stripDanglingFragment(cut.slice(0, space > max * 0.6 ? space : max));
+}
+
+function digestMoveLine(move) {
+  if (move.kind === 'mission_ready') {
+    const title = String(move.title || '').trim();
+    const boundary = title.search(/[:,]\s+/);
+    const clause = (boundary >= 0 ? title.slice(0, boundary) : title).trim();
+    const clauseWords = clause.split(/\s+/).filter(Boolean).length;
+    const afterColon = boundary >= 0 && title[boundary] === ':'
+      ? title.slice(boundary + 1).replace(/\([^)]*\)/g, '').trim()
+      : '';
+    const candidate = afterColon && clauseWords <= 5 ? finishThought(afterColon, 80) : clause;
+    const completeClause = candidate && candidate.length <= 80
+      ? candidate.charAt(0).toLowerCase() + candidate.slice(1).replace(/[.!?]+$/g, '')
+      : '';
+    const label = finishThought(completeClause || String(move.label || '').replace(/^#\d+\s+/, ''), 80);
+    return label
+      ? `review proof${move.owner ? ` from ${move.owner}` : ''} for ${label} so finished work can leave the queue`
+      : 'review the finished mission proof so accepted work can leave the queue';
+  }
+  return `${finishThought(move.title, 140)}${move.owner ? ` (best fit: ${move.owner})` : ''}`;
+}
+
+function historicalLandingText(text, max = 160) {
+  const clean = String(text || '')
+    .replace(/\s+/g, ' ')
+    .replace(/\bas exists and not empty\b/gi, 'as a saved file that exists and is not empty')
+    .trim();
+  return finishThought(clean, max);
 }
 
 function operatorReady(text) {
@@ -194,28 +370,86 @@ function hasAgentJargon(text) {
   return AGENT_JARGON.test(String(text || ''));
 }
 
+function explainResult(text) {
+  const raw = String(text || '');
+  const value = raw.replace(/\s+/g, ' ').trim();
+  if (!value) return { ok: false, reason: 'result must say what someone can do now and why it matters.' };
+  if (raw.includes('\n') || raw.includes('\r')) return { ok: false, reason: 'result must be one sentence, not a paragraph.' };
+  if (value.length < 30) return { ok: false, reason: 'result is too short to explain what changed for a human.' };
+  if (value.length > 180) return { ok: false, reason: 'result must stay under 180 characters so it survives briefs.' };
+  if (!/[.!?]$/.test(value)) return { ok: false, reason: 'result must end as a complete sentence with a period, question mark, or exclamation point.' };
+  const sentenceStops = value.match(/[.!?]/g) || [];
+  if (sentenceStops.length !== 1) return { ok: false, reason: 'result must be exactly one complete sentence.' };
+  if (RESULT_ULID.test(value)) return { ok: false, reason: 'result should explain the gain, not include database ids.' };
+  if (RESULT_TICKET.test(value)) return { ok: false, reason: 'result should not include ticket ids.' };
+  if (RESULT_FILE_PATH.test(value)) return { ok: false, reason: 'result should not include file paths.' };
+  if (RESULT_COMMAND.test(value)) return { ok: false, reason: 'result should not include command syntax or flags.' };
+  const finalWord = (value.replace(/[.!?]+$/g, '').match(/[A-Za-z]+$/) || [''])[0].toLowerCase();
+  if (TRAILING_FRAGMENT_WORDS.has(finalWord) && !COMPLETE_TRAILING_PHRASE.test(value)) {
+    return { ok: false, reason: 'result ends mid-thought; finish the sentence with the actual human gain.' };
+  }
+  if (!operatorReady(value)) {
+    return { ok: false, reason: 'result needs a plain operator why: say who can do what now, and why it saves time, reduces risk, increases trust, or helps users.' };
+  }
+  return { ok: true, reason: null };
+}
+
 // One line per piece, in the work's own words: the landing sentence beats
 // the task title, because titles are written for the queue, not for a text.
 // The cut is generous on purpose: a specific sentence the reader trusts
 // (what happened + how big + how we know) beats a short one they must chase.
 function digestLine(item) {
+  const result = String(item.result || '').replace(/^completed:\s*/i, '').split(/(?<=[.!?])\s+/)[0] || '';
   const happened = String(item.happened || '').replace(/^completed:\s*/i, '').split(/(?<=[.!?])\s+/)[0] || '';
-  const title = String(item.title || '').replace(/^Mission XP:\s*/i, '');
-  const source = happened.length >= 12 ? happened : title;
+  const title = clarify(String(item.title || '').replace(/^Mission XP:\s*/i, ''));
+  const source = result.length >= 12 ? result : (happened.length >= 12 && operatorReady(happened) ? happened : (operatorReady(title) ? title : ''));
+  if (!source) return '';
   const line = finishThought(source.replace(/[.\s]+$/, ''), 160);
+  if (!operatorReady(line) && source === result && happened.length >= 12 && operatorReady(happened)) {
+    const fallback = finishThought(happened.replace(/[.\s]+$/, ''), 160);
+    if (operatorReady(fallback)) return fallback.charAt(0).toLowerCase() + fallback.slice(1);
+  }
   return line.charAt(0).toLowerCase() + line.slice(1);
 }
 
-// A rough sentence still beats a count: when a landing sentence carries agent
-// vocabulary, strip what a reader can't use (flag dashes, ids, underscores)
-// and show it anyway. Content always ships; the gate only changes how it reads.
-function dejargon(line) {
-  return String(line || '')
-    .replace(/--([a-z][a-z-]*)/g, '$1')
-    .replace(/\bCLI-\d+\b/g, '')
-    .replace(/([a-z0-9])_([a-z0-9])/gi, '$1 $2')
-    .replace(/\s+/g, ' ')
-    .trim();
+function unexplainedSummaryRows(items, label) {
+  const count = (items || []).length;
+  if (count === 0) return [];
+  if (label === 'landed') {
+    return [`${plur(count, 'landed result')} stayed hidden because ${count === 1 ? 'its outcome was' : 'their outcomes were'} unclear`];
+  }
+  if (label === 'in review') {
+    return [`${plur(count, 'review')} stayed hidden because ${count === 1 ? 'its next action was' : 'their next actions were'} unclear`];
+  }
+  return [`${plur(count, label)} stayed hidden because ${count === 1 ? 'its meaning was' : 'their meanings were'} unclear`];
+}
+
+function missionDigestLine(mission, max = 160) {
+  const visibleGoal = mission?.visible_goal?.desired_objective
+    || mission?.goal?.visible_goal?.desired_objective
+    || (typeof mission?.visible_goal === 'string' ? mission.visible_goal : '');
+  const objective = visibleGoal || mission?.objective || '';
+  return finishThought(clarify(objective, max), max);
+}
+
+// Some older surfaces still need a readable fallback for rough text, but the
+// digest paths above now hide agent-speak until a result sentence exists.
+function dejargon(line, options = {}) {
+  let value = String(line || '')
+    .replace(/--([a-z][a-z-]*)/g, (_match, flag) => flag.replace(/-/g, ' '))
+    .replace(/\b[a-z0-9]+(?:_[a-z0-9]+)+\b/gi, match => match.replace(/_/g, ' '))
+    .replace(/\b[a-z]+(?:[A-Z][A-Za-z0-9]*)+\b/g, match => match.replace(/([a-z0-9])([A-Z])/g, '$1 $2'));
+  if (options.preserveTickets !== true) value = value.replace(/\bCLI-\d+\b/g, '');
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+// The clarity gate in one call: strip what an operator can't act on (flag
+// dashes, task ids, snake_case) and close the sentence on a whole clause, so
+// any title or line borrowed from the queue reaches a human actionable at a
+// glance. One sentence in, one operator-ready sentence out — content always
+// ships, the gate only changes how it reads.
+function clarify(text, max = 160) {
+  return finishThought(dejargon(text), max);
 }
 
 // The mission loop files a check-off every time it stops instead of
@@ -225,16 +459,33 @@ function isCleanStop(item) {
     || /^(Mission XP:\s*)?Decide and start the next useful mission/i.test(String(item.title || ''));
 }
 
+function hiddenMoveText(count, { more = false } = {}) {
+  const label = plur(count, `${more ? 'more queued ' : 'queued '}move`);
+  return count === 1
+    ? `${label} stays hidden until its owner writes a clear next action`
+    : `${label} stay hidden until their owners write clear next actions`;
+}
+
+function memberTrustLabel(member, root) {
+  if (!member) return '';
+  const tier = computeTrustTier(member, root);
+  if (tier === 'trusted') return ` (${member})`;
+  if (tier === 'standard') return ` (${member}, newer, spot-checked)`;
+  return ` (${member}, needs review)`;
+}
+
 // Short enough for one iMessage, plain enough to read walking to the car.
 // Every line answers: what happened, how big, how we know. It names the work
 // because "7 things landed" tells the score, not the story — and it always
 // ends with what's waiting and what to do next, because those are the only
 // lines that ask anything of the reader.
-function composeDigest({ accepted, waiting, landed, project, nextMoves = [] }) {
+function composeDigest({ accepted, waiting, protectedWaiting = [], waitingWishes = [], landed, project, nextMoves = [], acceptAll = false, reapError = null, janitor = null, landingSweep = null, fullStory = false, root = process.cwd() }) {
   const lines = [];
-  lines.push(`atris ${project}: yesterday`);
+  lines.push(`atris ${project}: last 24 hours`);
   const autoCount = accepted.auto.length;
   const humanCount = accepted.human.length;
+  const wishWaits = (Array.isArray(waitingWishes) ? waitingWishes : [])
+    .filter((wish) => wish && String(wish.text || '').trim());
   if (autoCount > 0) {
     // Three results, air between them, the rest on ask: the whole message
     // fits a laptop screen with no scrolling. Reading it is one glance.
@@ -242,36 +493,68 @@ function composeDigest({ accepted, waiting, landed, project, nextMoves = [] }) {
     const work = accepted.auto
       .filter((item) => !isCleanStop(item))
       .map((item) => ({ item, line: digestLine(item) }));
-    // Operator-ready sentences lead; rough ones get de-jargoned and still
-    // shown. An empty report is the one thing a report must never be.
-    const ready = work.filter(({ line }) => operatorReady(line));
-    const rough = work.filter(({ line }) => !operatorReady(line))
-      .map(({ item, line }) => ({ item, line: dejargon(line) }));
-    const visibleWork = [...ready, ...rough].slice(0, 3);
-    const held = Math.max(0, work.length - visibleWork.length) + (stops.length > 0 ? 1 : 0);
+    const ready = work.filter(({ line }) => line && operatorReady(line));
+    const unexplainedWork = work.filter(({ line }) => !line || !operatorReady(line));
+    const visibleWork = ready.slice(0, 3);
+    const held = Math.max(0, ready.length - visibleWork.length) + (stops.length > 0 ? 1 : 0);
     if (visibleWork.length > 0) {
-      lines.push('landed on their own (verified twice, proof on file):');
+      // The header states the actual bar: under accept-all the claim
+      // "verified twice" would be a lie the operator builds trust on.
+      lines.push(acceptAll
+        ? `${autoCount} landed; ${plur(ready.length, 'clear result')}, protected lanes held back for you:`
+        : `${autoCount} landed; ${plur(ready.length, 'clear result')}, each verified twice with proof on file:`);
       for (const { item, line } of visibleWork) {
         lines.push('');
-        lines.push(`- ${line || item.ref}${item.member ? ` (${item.member})` : ''}`);
+        lines.push(`- ${line || item.ref}${memberTrustLabel(item.member, root)}`);
       }
       lines.push('');
-      if (held > 0) lines.push(`${plur(held, 'more result')} when you want them: atris autoland digest`);
+      if (held > 0) {
+        lines.push(fullStory
+          ? `${plur(held, 'more result')} in the full story below`
+          : `${plur(held, 'more result')} when you want them: atris autoland digest`);
+      }
+    } else {
+      lines.push(`${autoCount} landed with proof on file; no clear result was ready to show:`);
     }
+    for (const row of unexplainedSummaryRows(unexplainedWork, 'landed')) lines.push(row);
   }
   if (autoCount + humanCount === 0) lines.push('nothing finished in the last day');
   if (waiting.length > 0) {
     // The only lines that ask the reader to act, so they name what's asking.
-    lines.push(`waiting on you (approve or bounce: atris task reviews):`);
-    for (const item of waiting.slice(0, 2)) {
-      lines.push(`- ${finishThought(dejargon(item.title), 140)}${item.hours >= 12 ? ` (${item.hours}h)` : ''}`);
+    const waitingWork = waiting.map((item) => ({ item, line: digestLine(item) }));
+    const explainedWaiting = waitingWork.filter(({ line }) => line && operatorReady(line));
+    const unexplainedWaiting = waitingWork.filter(({ line }) => !line || !operatorReady(line));
+    lines.push(`task approvals waiting on you (${explainedWaiting.length} clear next actions/${waiting.length} total; approve or bounce: atris task reviews):`);
+    for (const { item, line } of explainedWaiting.slice(0, 2)) {
+      lines.push(`- ${finishThought(line, 140)}${item.hours >= 12 ? ` (${item.hours}h)` : ''}`);
     }
-    if (waiting.length > 2) lines.push(`- and ${waiting.length - 2} more`);
-  } else {
-    lines.push('waiting on you: nothing');
+    for (const row of unexplainedSummaryRows(unexplainedWaiting, 'in review')) lines.push(`- ${row}`);
+    const hiddenWaiting = Math.max(0, explainedWaiting.length - 2);
+    if (hiddenWaiting > 0) lines.push(`- ${hiddenWaiting} more clear review actions`);
   }
+  const protectedCount = Array.isArray(protectedWaiting) ? protectedWaiting.length : 0;
+  if (protectedCount > 0) {
+    lines.push(`${plur(protectedCount, 'protected review')} waiting on you; inspect: atris task reviews`);
+  } else if (waiting.length === 0 && wishWaits.length === 0) {
+    lines.push('task approvals waiting on you: nothing');
+  }
+  pushWaitingWishLines(lines, wishWaits);
   if (landed && landed.branches > 0) {
-    lines.push(`in the air: ${plur(landed.branches, 'piece')}${landed.due > 0 ? `, ${landed.due} overdue` : ', all fresh'} (atris land)`);
+    const staleCount = Number(landingSweep?.stale_count) || (Array.isArray(landingSweep?.stale) ? landingSweep.stale.length : 0);
+    const freshness = landed.due > 0
+      ? `, ${landed.due} overdue`
+      : (staleCount > 0 ? `, ${staleCount} stale` : ', all fresh');
+    lines.push(`in the air: ${plur(landed.branches, 'piece')}${freshness} (atris land)`);
+  }
+  if (reapError) lines.push(`cleanup trouble: the landing sweep failed (${reapError}) - run: atris land --reap`);
+  pushLandingSweepLines(lines, landingSweep);
+  // The janitor's day in one line: stale paused missions stopped and merged
+  // worktrees cleared since the last digest. Silence when it did nothing.
+  const missionsStopped = Number(janitor?.missions_stopped) || 0;
+  const worktreesReaped = Number(janitor?.worktrees_reaped) || 0;
+  if (janitor) pushJanitorMissionReasonLines(lines, janitor);
+  if (missionsStopped > 0 || worktreesReaped > 0) {
+    lines.push(`tidied up: ${plur(missionsStopped, 'stale mission')} stopped, ${plur(worktreesReaped, 'merged worktree')} cleared`);
   }
   // nextMoves: array of {title, owner}, or {moves, unexplained} where
   // unexplained counts queue items whose sentence carries no operator why.
@@ -285,13 +568,13 @@ function composeDigest({ accepted, waiting, landed, project, nextMoves = [] }) {
   if (moves.length > 0) {
     lines.push('next, if you agree:');
     for (const move of moves) {
-      lines.push(`- ${finishThought(move.title, 140)}${move.owner ? ` (best fit: ${move.owner})` : ''}`);
+      lines.push(`- ${digestMoveLine(move)}`);
     }
-    if (unexplained > 0) lines.push(`- ${plur(unexplained, 'more idea')} that can't explain themselves yet (atris now)`);
+    if (unexplained > 0) lines.push(`- ${hiddenMoveText(unexplained, { more: true })}`);
   } else if (unexplained > 0) {
-    lines.push(`${plur(unexplained, 'idea')} in the queue can't explain themselves yet (atris now)`);
+    lines.push(hiddenMoveText(unexplained));
   }
-  if (!lines.some((line) => line.includes('atris autoland digest'))) {
+  if (!fullStory && !lines.some((line) => line.includes('atris autoland digest'))) {
     lines.push('the full story: atris autoland digest');
   }
   return lines.join('\n');
@@ -300,7 +583,7 @@ function composeDigest({ accepted, waiting, landed, project, nextMoves = [] }) {
 // The moment something lands, the operator hears it in one glance: the
 // landing sentence each piece wrote for a day-one PM at finish time, its
 // author, nothing else. Rough sentences get de-jargoned, never hidden.
-function composeLiveUpdate({ landedRefs, tasks, project }) {
+function composeLiveUpdate({ landedRefs, tasks, project, root = process.cwd() }) {
   const byRef = new Map((tasks || []).map((t) => [String(t.display_id || t.legacy_ref || t.id), t]));
   const items = (landedRefs || []).map((ref) => {
     const t = byRef.get(String(ref));
@@ -308,21 +591,27 @@ function composeLiveUpdate({ landedRefs, tasks, project }) {
     return {
       ref: String(ref),
       title: String(t.title || '').slice(0, 200),
+      result: String(t.result || t.metadata?.result || '').slice(0, 220),
       happened: String(t.review?.landing?.happened || t.metadata?.landing_happened || '').slice(0, 300),
-      member: String(t.claimed_by || t.assigned_to || '').trim(),
+      member: String(t.claimed_by || t.metadata?.executed_by || t.assigned_to || '').trim(),
     };
   }).filter((item) => !isCleanStop(item));
   if (!items.length) return '';
   const lines = [`atris ${project}: just landed`];
-  for (const item of items.slice(0, 3)) {
-    const raw = digestLine(item);
-    const line = operatorReady(raw) ? raw : dejargon(raw);
+  const work = items.map((item) => ({ item, line: digestLine(item) }));
+  const ready = work.filter(({ line }) => line && operatorReady(line));
+  const unexplained = work.filter(({ line }) => !line || !operatorReady(line));
+  for (const { item, line } of ready.slice(0, 3)) {
+    lines.push('');
+    lines.push(`- ${finishThought(line, 160)}${memberTrustLabel(item.member, root)}`);
+  }
+  for (const row of unexplainedSummaryRows(unexplained, 'landed')) {
     lines.push('');
-    lines.push(`- ${finishThought(line, 160)}${item.member ? ` (${item.member})` : ''}`);
+    lines.push(row);
   }
-  if (items.length > 3) {
+  if (ready.length > 3) {
     lines.push('');
-    lines.push(`and ${plur(items.length - 3, 'more piece')}: atris autoland digest`);
+    lines.push(`and ${plur(ready.length - 3, 'more piece')}: atris autoland digest`);
   }
   return lines.join('\n');
 }
@@ -331,7 +620,7 @@ function composeAlarm({ waiting, project, alarmHours }) {
   const worst = waiting[0];
   return [
     `atris ${project}: ${plur(waiting.length, 'piece')} of finished work ${waiting.length === 1 ? 'has' : 'have'} been waiting on you for over ${alarmHours}h`,
-    `oldest: ${worst.ref} (${worst.hours}h) — ${worst.title}`,
+    `oldest: ${worst.ref} (${worst.hours}h), ${worst.title}`,
     'approve or bounce: atris task reviews',
   ].join('\n');
 }
@@ -367,17 +656,29 @@ module.exports = {
   DEFAULT_DIGEST_HOUR,
   acceptedInLastDay,
   buildCronLine,
+  clarify,
   composeAlarm,
   composeDigest,
   composeLiveUpdate,
   cronInstalled,
   cronMarker,
   dueForAlarm,
+  digestLine,
+  dejargon,
+  explainResult,
   installCron,
   liveAcceptAuthorization,
   markAlerted,
+  missionDigestLine,
   operatorReady,
   hasAgentJargon,
+  voicePatterns: Object.freeze({
+    agentJargon: AGENT_JARGON,
+    filePath: RESULT_FILE_PATH,
+    rawUlid: RESULT_ULID,
+    shellCommand: SHELL_COMMAND_FRAGMENT,
+  }),
+  historicalLandingText,
   policyPath,
   readPolicy,
   readState,

package/lib/ax-auto-lane.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const SHORT_LOOKUP_MAX_CHARS = 140;
+const LONG_INPUT_MIN_CHARS = 1200;
+const TINY_MESSAGE_MAX_CHARS = 20;
+const GREETING_MAX_CHARS = 40;
+const DECISION_FACTOR_MIN_COMMAS = 3;
+const TRADEOFF_DEPTH_MIN_CHARS = 100;
+
+const LOOKUP_WORD_RE = /\b(?:what|who|when|where|list|show|define|convert)\b/i;
+// Words that turn a lookup-shaped message into a judgment call: never fast.
+const JUDGMENT_WORD_RE = /\b(?:should|tradeoffs?|better|best|recommend|worth)\b/i;
+const HEAVY_REASONING_RE = /\b(?:design(?:s|ed|ing)?|architect(?:s|ed|ing)?|prov(?:e|es|ed|ing)|analy(?:ze|zes|zed|zing|se|ses|sed|sing)|compar(?:e|es|ed|ing)|plan(?:s|ned|ning)?|sketch(?:es|ed|ing)?)\b/i;
+const DECISION_PHRASE_RE = /\b(?:should|whether|decide|deciding)\b/i;
+const ARGUE_BOTH_RE = /\bargue\b|\bboth sides\b|\bsteelman\b/i;
+const CODE_EDIT_RE = /\b(?:fix(?:es|ed|ing)?|refactor(?:s|ed|ing)?|renam(?:e|es|ed|ing)|debug(?:s|ged|ging)?)\b/i;
+const CODE_DIAGNOSIS_RE = /\bwhy\b|\bwrong\b|\bfail(?:s|ed|ing)?\b|\bresolv(?:e|es|ed|ing)?\b|\bbroken\b|\bnot work/i;
+const CODE_CONTEXT_RE = /```|(?:^|\n)\s*(?:traceback\b|(?:[a-z]+)?(?:error|exception):|at\s+\S+\s+\()/im;
+const ERROR_EXPLAIN_RE = /\bexplain (?:this|the) error\b|\bwhat does (?:this|the) error mean\b/i;
+const TRANSFORM_START_RE = /^(?:convert|summarize|translate)\b/i;
+const GREETING_RE = /^(?:hey|hi|hello|yo|thanks|thank you|ok|okay|cool|nice|got it|great|perfect|yep|no worries)\b/i;
+
+function threshold(value, fallback) {
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+
+function pickLane(message, opts = {}) {
+  const text = String(message || '').trim();
+  const shortLookupMaxChars = threshold(opts.shortLookupMaxChars, SHORT_LOOKUP_MAX_CHARS);
+  const longInputMinChars = threshold(opts.longInputMinChars, LONG_INPUT_MIN_CHARS);
+  const questionCount = (text.match(/\?/g) || []).length;
+  const commaCount = (text.match(/,/g) || []).length;
+  const hasCodeContext = CODE_CONTEXT_RE.test(text);
+
+  if (text.length > longInputMinChars) {
+    return { lane: 'max', reason: 'max fits this long input.' };
+  }
+  if (questionCount > 1) {
+    return { lane: 'max', reason: 'max fits a request with multiple questions.' };
+  }
+  if (ARGUE_BOTH_RE.test(text)
+    || (DECISION_PHRASE_RE.test(text) && commaCount >= DECISION_FACTOR_MIN_COMMAS)) {
+    return { lane: 'max', reason: 'max fits a decision weighing several factors.' };
+  }
+  if (HEAVY_REASONING_RE.test(text)) {
+    return { lane: 'max', reason: 'max fits this reasoning-heavy request.' };
+  }
+  if (/\btrade[- ]?offs?\b/i.test(text) && text.length > TRADEOFF_DEPTH_MIN_CHARS) {
+    return { lane: 'max', reason: 'max fits this tradeoff analysis.' };
+  }
+  if (hasCodeContext && (CODE_EDIT_RE.test(text) || CODE_DIAGNOSIS_RE.test(text))) {
+    return { lane: 'code-fast', reason: 'code-fast fits this bounded code task.' };
+  }
+  if (ERROR_EXPLAIN_RE.test(text) && !hasCodeContext) {
+    return { lane: 'fast', reason: 'fast fits a plain error explanation.' };
+  }
+  if (TRANSFORM_START_RE.test(text) && text.length <= shortLookupMaxChars) {
+    return { lane: 'fast', reason: 'fast fits this small transform.' };
+  }
+  if (GREETING_RE.test(text) && text.length <= GREETING_MAX_CHARS) {
+    return { lane: 'fast', reason: 'fast fits a quick reply.' };
+  }
+  if (text.length > 0 && text.length <= TINY_MESSAGE_MAX_CHARS && !CODE_EDIT_RE.test(text)) {
+    return { lane: 'fast', reason: 'fast fits this tiny message.' };
+  }
+  if (text.length <= shortLookupMaxChars
+    && LOOKUP_WORD_RE.test(text)
+    && !JUDGMENT_WORD_RE.test(text)) {
+    return { lane: 'fast', reason: 'fast fits this short factual lookup.' };
+  }
+  return { lane: 'pro', reason: 'pro fits this general request.' };
+}
+
+module.exports = {
+  LONG_INPUT_MIN_CHARS,
+  SHORT_LOOKUP_MAX_CHARS,
+  TINY_MESSAGE_MAX_CHARS,
+  pickLane,
+};