atris 3.31.0 → 3.33.3

package/commands/truth.js

@@ -1,13 +1,15 @@
 // atris truth — one table of what is actually proven, blocked, or stale.
 // Rolls up sources that already exist; writes nothing. SQL/state is truth, this is the render.
 //   1. .atris/state/missions.jsonl        — mission states (dedupe by id, latest wins)
-//   2. ~/.atris/tasks.db                  — task counts by status
+//   2. ~/.atris/tasks.db                  — task counts by status, scoped to this workspace unless --all is passed
 //   3. atris/features/*/                  — validate.md frontmatter + newest proof/ receipt age
 //   4. ~/.atris/heartbeat/{registry,state}.json — declared loops vs last_run / fails
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { execFileSync } = require('child_process');
+const taskDb = require('../lib/task-db');
 
 const STALE_DAYS = 7;
 
@@ -38,19 +40,71 @@ function loadMissions(cwd) {
       if (id) seen.set(id, rec);
     } catch { /* skip bad lines */ }
   }
-  return [...seen.values()].filter((m) => m.status && m.status !== 'complete' && m.status !== 'archived');
+  // stopped = killed-on-purpose = a closed loop; only genuinely open states count
+  return [...seen.values()].filter((m) => m.status && !['complete', 'archived', 'stopped'].includes(m.status));
 }
 
-function loadTaskCounts() {
+function gitCommonWorkspaceRoot(cwd) {
+  try {
+    const common = execFileSync('git', ['rev-parse', '--git-common-dir'], {
+      cwd: cwd || process.cwd(),
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    if (!common) return null;
+    const gitDir = path.resolve(cwd || process.cwd(), common);
+    return path.basename(gitDir) === '.git' ? path.dirname(gitDir) : null;
+  } catch {
+    return null;
+  }
+}
+
+function workspaceRootCandidates(cwd) {
+  const primary = taskDb.workspaceRoot(cwd || process.cwd());
+  const candidates = [primary];
+  const commonRoot = gitCommonWorkspaceRoot(primary);
+  if (commonRoot && commonRoot !== primary) candidates.push(commonRoot);
+  return candidates;
+}
+
+function countsFromRows(rows) {
+  const counts = {};
+  for (const r of rows) counts[r.status] = Number(r.n || 0);
+  return counts;
+}
+
+function taskCountRows(db, workspaceRoot) {
+  return workspaceRoot
+    ? db.prepare('SELECT status, COUNT(*) n FROM tasks WHERE workspace_root = ? GROUP BY status').all(workspaceRoot)
+    : db.prepare('SELECT status, COUNT(*) n FROM tasks GROUP BY status').all();
+}
+
+function loadTaskCounts({ cwd, all = false } = {}) {
+  const candidates = all ? [null] : workspaceRootCandidates(cwd || process.cwd());
   try {
     const { DatabaseSync } = require('node:sqlite');
-    const db = new DatabaseSync(path.join(os.homedir(), '.atris', 'tasks.db'), { readOnly: true });
-    const rows = db.prepare('SELECT status, COUNT(*) n FROM tasks GROUP BY status').all();
+    const dbPath = taskDb.getDbPath();
+    if (!fs.existsSync(dbPath)) return { counts: null, workspaceRoot: candidates[0] || null };
+    const db = new DatabaseSync(dbPath, { readOnly: true });
+    for (const workspaceRoot of candidates) {
+      const rows = taskCountRows(db, workspaceRoot);
+      if (all || rows.length > 0) {
+        db.close();
+        return { counts: countsFromRows(rows), workspaceRoot };
+      }
+    }
     db.close();
-    const counts = {};
-    for (const r of rows) counts[r.status] = r.n;
-    return counts;
-  } catch { return null; }
+    return { counts: {}, workspaceRoot: candidates[0] || null };
+  } catch { return { counts: null, workspaceRoot: candidates[0] || null }; }
+}
+
+function taskScopeLabel(scope) {
+  return scope.kind === 'global' ? 'global' : 'workspace';
+}
+
+function taskScopeLine(scope) {
+  if (scope.kind === 'global') return 'global';
+  return `${taskScopeLabel(scope)} (${scope.workspace_root})`;
 }
 
 function loadFeatures(cwd) {
@@ -110,9 +164,14 @@ function truthCommand(args = []) {
   const cwd = process.cwd();
   const json = args.includes('--json');
   const summary = args.includes('--summary');
+  const all = args.includes('--all');
 
   const missions = loadMissions(cwd);
-  const tasks = loadTaskCounts();
+  const taskCounts = loadTaskCounts({ cwd, all });
+  const scope = all
+    ? { kind: 'global' }
+    : { kind: 'workspace', workspace_root: taskCounts.workspaceRoot };
+  const tasks = taskCounts.counts;
   const features = loadFeatures(cwd);
   const heartbeats = loadHeartbeats();
 
@@ -124,6 +183,7 @@ function truthCommand(args = []) {
   const result = {
     ok: true,
     generated_at: new Date().toISOString(),
+    scope,
     missions_active: missions.map((m) => ({ id: m.id || m.mission_id, status: m.status, owner: m.owner })),
     tasks,
     features: featureTally,
@@ -139,11 +199,12 @@ function truthCommand(args = []) {
 
   const line = (s) => console.log(s);
   if (summary) {
-    line(`truth: features ${featureTally.proven || 0} proven / ${featureTally.stale || 0} stale / ${featureTally.blocked || 0} blocked / ${featureTally.unproven || 0} unproven · loops ${loopTally.proven || 0} live / ${(loopTally.stale || 0) + (loopTally['never-ran'] || 0)} stale / ${loopTally.blocked || 0} failing · missions ${missions.length} active`);
+    line(`truth [${taskScopeLabel(scope)}]: features ${featureTally.proven || 0} proven / ${featureTally.stale || 0} stale / ${featureTally.blocked || 0} blocked / ${featureTally.unproven || 0} unproven · loops ${loopTally.proven || 0} live / ${(loopTally.stale || 0) + (loopTally['never-ran'] || 0)} stale / ${loopTally.blocked || 0} failing · missions ${missions.length} active`);
     return 0;
   }
 
   line('ATRIS TRUTH — live state, not belief\n');
+  line(`Scope: ${taskScopeLine(scope)}`);
 
   line(`Missions active: ${missions.length}`);
   for (const m of missions) line(`  ${m.status.padEnd(8)} ${m.owner || '?'}  ${m.id || m.mission_id}`);

package/lib/autoland.js

@@ -12,6 +12,8 @@ const { spawnSync } = require('child_process');
 
 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+/;
 
 function policyPath(root) {
   return path.join(root, '.atris', 'policy', 'autoland.json');
@@ -131,7 +133,7 @@ function waitingOnHuman(tasks, now = Date.now()) {
     .filter((t) => t.review?.agent_certified === true || t.metadata?.agent_certified === true)
     .map((t) => ({
       ref: t.display_id || t.legacy_ref || t.id,
-      title: String(t.title || '').slice(0, 90),
+      title: String(t.title || '').slice(0, 200),
       tag: String(t.tag || ''),
       hours: waitingHours(t, now),
     }))
@@ -168,16 +170,54 @@ function cutAtWord(text, max) {
   return `${cut.slice(0, lastSpace > max * 0.6 ? lastSpace : max)}...`;
 }
 
+// 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]+$/, '');
+  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);
+  const clause = Math.max(cut.lastIndexOf(', '), cut.lastIndexOf('; '), cut.lastIndexOf(' ('), cut.lastIndexOf(': '));
+  if (clause > max * 0.45) return cut.slice(0, clause);
+  const space = cut.lastIndexOf(' ');
+  return `${cut.slice(0, space > max * 0.6 ? space : max)}...`;
+}
+
+function operatorReady(text) {
+  const value = String(text || '');
+  return OPERATOR_WHY.test(value) && !AGENT_JARGON.test(value);
+}
+
+function hasAgentJargon(text) {
+  return AGENT_JARGON.test(String(text || ''));
+}
+
 // 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 happened = String(item.happened || '').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 line = cutAtWord(source.replace(/[.\s]+$/, ''), 72);
+  const line = finishThought(source.replace(/[.\s]+$/, ''), 160);
   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();
+}
+
 // The mission loop files a check-off every time it stops instead of
 // inventing work; those all say the same thing, so they collapse into one line.
 function isCleanStop(item) {
@@ -185,40 +225,105 @@ function isCleanStop(item) {
     || /^(Mission XP:\s*)?Decide and start the next useful mission/i.test(String(item.title || ''));
 }
 
-// Short enough for one iMessage, plain enough to read over coffee — and it
-// names the work, because "7 things landed" tells the score, not the story.
-function composeDigest({ accepted, waiting, landed, project }) {
+// 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 = [] }) {
   const lines = [];
-  lines.push(`atris ${project} daily`);
+  lines.push(`atris ${project}: yesterday`);
   const autoCount = accepted.auto.length;
   const humanCount = accepted.human.length;
   if (autoCount > 0) {
-    lines.push('got their final sign-off on their own (checked twice, proof on file):');
+    // Three results, air between them, the rest on ask: the whole message
+    // fits a laptop screen with no scrolling. Reading it is one glance.
     const stops = accepted.auto.filter(isCleanStop);
-    const work = accepted.auto.filter((item) => !isCleanStop(item));
-    for (const item of work.slice(0, 4)) lines.push(`- ${digestLine(item) || item.ref}`);
-    if (work.length > 4) lines.push(`- and ${work.length - 4} more`);
-    if (stops.length > 0) lines.push(`- ${plur(stops.length, 'check')} that the loop stops cleanly instead of inventing work`);
+    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);
+    if (visibleWork.length > 0) {
+      lines.push('landed on their own (verified twice, proof on file):');
+      for (const { item, line } of visibleWork) {
+        lines.push('');
+        lines.push(`- ${line || item.ref}${item.member ? ` (${item.member})` : ''}`);
+      }
+      lines.push('');
+      if (held > 0) lines.push(`${plur(held, 'more result')} when you want them: atris autoland digest`);
+    }
   }
-  if (humanCount > 0) lines.push(`you approved ${plur(humanCount, 'piece')} yourself`);
   if (autoCount + humanCount === 0) lines.push('nothing finished in the last day');
-  const byMember = new Map();
-  for (const item of [...accepted.auto, ...accepted.human]) {
-    if (!item.member || isCleanStop(item)) continue;
-    byMember.set(item.member, (byMember.get(item.member) || 0) + 1);
-  }
-  if (byMember.size > 0) {
-    lines.push(`workers: ${Array.from(byMember, ([who, n]) => `${who} landed ${n}`).join(', ')}`);
-  }
   if (waiting.length > 0) {
-    lines.push(`waiting on you: ${waiting.length} (oldest ${waiting[0].hours}h) — atris task reviews`);
+    // 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)` : ''}`);
+    }
+    if (waiting.length > 2) lines.push(`- and ${waiting.length - 2} more`);
   } else {
-    lines.push('nothing is waiting on you');
+    lines.push('waiting on you: nothing');
   }
   if (landed && landed.branches > 0) {
-    lines.push(`${plur(landed.branches, 'piece')} of work still in the air${landed.due > 0 ? `, ${landed.due} overdue` : ''} — atris land`);
+    lines.push(`in the air: ${plur(landed.branches, 'piece')}${landed.due > 0 ? `, ${landed.due} overdue` : ', all fresh'} (atris land)`);
+  }
+  // nextMoves: array of {title, owner}, or {moves, unexplained} where
+  // unexplained counts queue items whose sentence carries no operator why.
+  // Those are counted, not shown — a raw title the reader can't act on is
+  // noise here and a writing bug at its source.
+  const nextInfo = Array.isArray(nextMoves)
+    ? { moves: nextMoves, unexplained: 0 }
+    : (nextMoves || { moves: [], unexplained: 0 });
+  const moves = (nextInfo.moves || []).filter((move) => move && move.title).slice(0, 3);
+  const unexplained = Number(nextInfo.unexplained || 0);
+  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})` : ''}`);
+    }
+    if (unexplained > 0) lines.push(`- ${plur(unexplained, 'more idea')} that can't explain themselves yet (atris now)`);
+  } else if (unexplained > 0) {
+    lines.push(`${plur(unexplained, 'idea')} in the queue can't explain themselves yet (atris now)`);
+  }
+  if (!lines.some((line) => line.includes('atris autoland digest'))) {
+    lines.push('the full story: atris autoland digest');
+  }
+  return lines.join('\n');
+}
+
+// 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 }) {
+  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));
+    if (!t) return { title: String(ref) };
+    return {
+      ref: String(ref),
+      title: String(t.title || '').slice(0, 200),
+      happened: String(t.review?.landing?.happened || t.metadata?.landing_happened || '').slice(0, 300),
+      member: String(t.claimed_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);
+    lines.push('');
+    lines.push(`- ${finishThought(line, 160)}${item.member ? ` (${item.member})` : ''}`);
+  }
+  if (items.length > 3) {
+    lines.push('');
+    lines.push(`and ${plur(items.length - 3, 'more piece')}: atris autoland digest`);
   }
-  lines.push('the full story: atris autoland digest');
   return lines.join('\n');
 }
 
@@ -264,12 +369,15 @@ module.exports = {
   buildCronLine,
   composeAlarm,
   composeDigest,
+  composeLiveUpdate,
   cronInstalled,
   cronMarker,
   dueForAlarm,
   installCron,
   liveAcceptAuthorization,
   markAlerted,
+  operatorReady,
+  hasAgentJargon,
   policyPath,
   readPolicy,
   readState,