atris 3.48.0 → 3.48.1

package/atris/CLAUDE.md

@@ -100,6 +100,8 @@ The human approves work by reading, so how you report IS the product.
 
 ## Rules (Non‑Negotiable)
 
+- YouTube link in a message: run `atris youtube notes <url>` before saying anything about the video. The transcript is the source; notes from model memory are fabrication.
+
 - Plan = ASCII visualization + approval gate. Do not execute during planning.
 - Execute step-by-step, verify as you go, update artifacts (`TODO.md`, `MAP.md`) when reality changes.
 - Delete completed tasks (validator cleans to target state = 0).

package/atris/skills/youtube/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: youtube
-description: "Process YouTube videos: extract insights, answer questions, store as knowledge. 5 credits per video. Triggers on: youtube, video, process video, watch this, learn from video."
-version: 2.3.0
+description: "A YouTube link in any message routes here. Run atris youtube notes <url> FIRST: free, about 30 seconds, quotes verified against the transcript. Never summarize a video from model memory, that is fabrication. Use atris youtube process only to store it as queryable knowledge (5 credits). Triggers on: any youtube.com or youtu.be link, youtube, video, watch this, notes on this."
+version: 2.4.0
 tags:
   - youtube
   - research

package/bin/atris.js

@@ -513,6 +513,7 @@ function showHelp() {
   console.log('  orb        - Pick next moves while engine jobs work in the background');
   console.log('  activate   - Load Atris context');
   console.log('  radar      - Show live agents joined with tasks, missions, and worktrees');
+  console.log('  who        - Show local engines and team members working, waiting, done, or stale');
   console.log('  stream     - Watch the whole team work live in one terminal');
   console.log('  team       - One team view: members, roles, engine assignments (presence for live)');
   console.log('  watch      - Turn one sentence into an always-on background watcher');
@@ -1829,6 +1830,10 @@ if (command === 'init') {
   Promise.resolve(require('../commands/team').teamCommand(process.argv.slice(3)))
     .then((code) => process.exit(code || 0))
     .catch((err) => { console.error(`\nerror: ${err.message || err}`); process.exit(1); });
+} else if (command === 'who') {
+  Promise.resolve(require('../commands/who').whoCommand(process.argv.slice(3)))
+    .then((code) => process.exit(code || 0))
+    .catch((err) => { console.error(`\nerror: ${err.message || err}`); process.exit(1); });
 } else if (command === 'wish') {
   Promise.resolve(require('../commands/wish').wishCommand(process.argv.slice(3)))
     .then((code) => process.exit(code || 0))

package/commands/dream.js

@@ -10,7 +10,7 @@ const {
 
 const DREAMS_FILE = ['.atris', 'state', 'dreams.jsonl'];
 const DAY_MS = 24 * 60 * 60 * 1000;
-const DREAM_TIMEOUT_MS = 60 * 1000;
+const DREAM_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_CONTEXT_CHARS = 7000;
 const MAX_SECTION_CHARS = 2400;
 

package/commands/engine.js

@@ -37,10 +37,11 @@ const {
   resolveEngineForRoleRanked,
   requireEngineBin,
   engineDoctorReport,
+  engineFailureHealthStatus,
   setEngineOverrides,
   setEngineHealth,
 } = require('../lib/engine-registry');
-const { FLEET_CAPABLE, runDispatchFlight } = require('../lib/fleet');
+const { DISPATCH_CAPABLE, runDispatchFlight } = require('../lib/fleet');
 const {
   buildReadOnlyEngineInvocation,
   runEngineAskCommand,
@@ -1379,12 +1380,12 @@ function parseDispatchArgs(args) {
 function runDispatchCommand(args, root) {
   const { taskIds, engine, promptFile, base, json, yolo } = parseDispatchArgs(args);
   if (!taskIds.length || !engine) {
-    console.error('usage: atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]');
+    console.error('usage: atris engine dispatch <task-id> [<task-id> ...] --engine <engine> [--prompt-file <f>] [--yolo]');
     return 2;
   }
   const canonical = canonicalEngineName(engine);
-  if (!canonical || !FLEET_CAPABLE.includes(canonical)) {
-    console.error(`engine dispatch: --engine must be one of ${FLEET_CAPABLE.join(', ')}`);
+  if (!canonical || !DISPATCH_CAPABLE.includes(canonical)) {
+    console.error(`engine dispatch: --engine must be one of ${DISPATCH_CAPABLE.join(', ')}`);
     return 2;
   }
   // Argument-shape errors surface before environment errors: --prompt-file
@@ -1407,7 +1408,13 @@ function runDispatchCommand(args, root) {
   try {
     requireEngineBin(canonical);
   } catch (err) {
-    console.error(`engine dispatch: ${err.message}`);
+    const status = engineFailureHealthStatus({ status: 'errored', reason: err.message });
+    if (status) {
+      try { setEngineHealth(canonical, status, root); } catch { /* best effort */ }
+    }
+    console.error(canonical === 'fable'
+      ? `fable handoff failed: ${err.message}`
+      : `engine dispatch: ${err.message}`);
     return 2;
   }
   return runDispatchFlight({ root, taskIds, engine: canonical, prompt: promptOverride, yolo, ...(base ? { checkoutBase: base } : {}) }).then((flight) => {

package/commands/member.js

@@ -7288,6 +7288,7 @@ function composeWakeDecision(ctx, verdict) {
     state: ctx.state,
     goal: verdict.goal,
     current_experiment: verdict.current_experiment,
+    now_file: ctx.nowFile,
   };
   if ('autonomous_problem' in verdict) result.autonomous_problem = verdict.autonomous_problem;
   result.checks = ctx.checks;
@@ -7471,6 +7472,11 @@ const WAKE_DECISION_RULES = [
 
 function wakeDecision(name, paths, { force = false, runtimeKind = memberRuntimeKind(name) } = {}) {
   const purpose = missionPurpose(paths);
+  const nowPath = path.join(paths.memberDir, 'now.md');
+  const nowFile = fs.existsSync(nowPath) ? {
+    path: path.relative(process.cwd(), nowPath),
+    excerpt: String(purpose.nowText || '').slice(0, 500),
+  } : null;
   const steering = readSteeringMemory(paths, name);
   const state = loadMemberGoals(name, paths);
   const goal = activeGoal(state);
@@ -7519,7 +7525,7 @@ function wakeDecision(name, paths, { force = false, runtimeKind = memberRuntimeK
     next_command: wakeScores.selected.next_command,
   } : null;
 
-  const ctx = { name, force, purpose, steering, state, goal, current, blocked, evidence, workspace, checks, wakeScores };
+  const ctx = { name, force, purpose, nowFile, steering, state, goal, current, blocked, evidence, workspace, checks, wakeScores };
   for (const rule of WAKE_DECISION_RULES) {
     const verdict = rule(ctx);
     if (verdict) return composeWakeDecision(ctx, verdict);
@@ -7624,6 +7630,11 @@ async function runMemberWake(name, { execute = false, confirmed = false, force =
     nextCommand = `atris member review ${name} ${experiment.id} --accept --proof "..." --value 4`;
   }
 
+  const goals = (state.goals || []).map((item) => ({
+    id: item.id || null,
+    title: item.title || null,
+    status: item.status || null,
+  }));
   const receiptPayload = {
     schema: 'atris.member_wake.v1',
     created_at: now,
@@ -7636,6 +7647,8 @@ async function runMemberWake(name, { execute = false, confirmed = false, force =
     ask: planned.ask || null,
     next_command: nextCommand,
     mission: planned.mission,
+    now_file: planned.now_file,
+    goals,
     steering: planned.steering,
     evidence: planned.evidence,
     checks: planned.checks,
@@ -7692,6 +7705,8 @@ async function runMemberWake(name, { execute = false, confirmed = false, force =
     ask: planned.ask || null,
     next_command: nextCommand,
     mission: planned.mission,
+    now_file: planned.now_file,
+    goals,
     steering: planned.steering,
     evidence: planned.evidence,
     checks: planned.checks,
@@ -8972,6 +8987,25 @@ async function memberImprovements(businessId, ...args) {
 
 // --- Command Dispatcher ---
 
+async function memberChat(name, ...rest) {
+  const paths = requireMemberDir(name);
+  const flags = rest.filter((a) => String(a).startsWith('--'));
+  const words = rest.filter((a) => !String(a).startsWith('--'));
+  const fromFlag = flags.find((f) => f.startsWith('--from='));
+  const from = fromFlag ? fromFlag.slice('--from='.length) : (process.env.USER || 'terminal');
+  const text = words.join(' ').trim();
+  if (!text) {
+    console.error('Usage: atris member chat <name> "your message" [--from=<sender>]');
+    process.exit(1);
+  }
+  // Append-only inbox the Atris desktop polls into the member's desk chat.
+  // Contract shared with obelisk src/lib/memberChatInbox.cjs: one JSON object per line.
+  const line = JSON.stringify({ at: new Date().toISOString(), from, text });
+  fs.appendFileSync(path.join(paths.memberDir, 'chat-inbox.jsonl'), `${line}\n`, 'utf8');
+  console.log(`Sent to ${paths.storageName || name}'s desk. It appears in Atris Desktop within about 15 seconds when the app is open.`);
+  return { ok: true };
+}
+
 async function memberCommand(subcommand, ...args) {
   // Subcommands that take a member name as args[0] otherwise treat `--help` as
   // a name and error with "Member '--help' not found". `create`/`new` handle
@@ -9003,6 +9037,8 @@ async function memberCommand(subcommand, ...args) {
     case 'goal-from-score':
     case 'score-goal':
       return memberGoalFromScore(args[0], ...args.slice(1));
+    case 'chat':
+      return memberChat(args[0], ...args.slice(1));
     case 'tick':
       return memberTick(args[0], ...args.slice(1));
     case 'wake':
@@ -9046,6 +9082,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('');
       console.log('Subcommands:');
       console.log('  create <name>       Scaffold a new team member (MEMBER.md + dirs) [--push]');
+      console.log('  chat <name> "..."   Send a message to this member\'s desk in Atris Desktop');
       console.log('  list                Show all team members');
       console.log('  activate <name>     Symlink member skills, show context and permissions');
       console.log('  upgrade <name>      Convert flat file (name.md) to directory format');

package/commands/task.js

@@ -6028,25 +6028,66 @@ function cmdStatus(args) {
   if (history) console.log(`history feed ${status.swarlo.feed.length} event${status.swarlo.feed.length === 1 ? '' : 's'}`);
 }
 
+function readProjectionFile(workspaceRoot) {
+  const candidatePaths = [
+    workspaceRoot ? path.join(workspaceRoot, '.atris', 'state', 'tasks.projection.json') : null,
+    path.resolve('.atris', 'state', 'tasks.projection.json'),
+  ].filter(Boolean);
+  for (const candidate of candidatePaths) {
+    try {
+      if (fs.existsSync(candidate)) {
+        const content = fs.readFileSync(candidate, 'utf8');
+        const parsed = JSON.parse(content);
+        if (parsed && Array.isArray(parsed.tasks)) return parsed;
+      }
+    } catch {}
+  }
+  return null;
+}
+
 function resolveTaskRef(taskDb, db, ref) {
   const token = String(ref || '').trim();
   if (!token) return { ok: false, reason: 'missing' };
-  const exact = taskDb.getTask(db, token);
+  const exact = db ? taskDb.getTask(db, token) : null;
   if (exact) return { ok: true, id: exact.id, row: exact };
   const normalized = taskDb.normalizeTaskRef ? taskDb.normalizeTaskRef(token) : token.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
-  const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot: taskDb.workspaceRoot() }));
-  const seen = new Set();
-  const matches = rows.filter(r => {
-    const id = String(r.id || '').toUpperCase();
-    const display = taskDb.normalizeTaskRef ? taskDb.normalizeTaskRef(r.display_id) : String(r.display_id || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
-    const legacy = taskDb.normalizeTaskRef ? taskDb.normalizeTaskRef(r.legacy_ref) : String(r.legacy_ref || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
-    const matched = id.startsWith(normalized) || display === normalized || legacy === normalized;
-    if (!matched || seen.has(r.id)) return false;
-    seen.add(r.id);
-    return true;
-  });
-  if (matches.length === 1) return { ok: true, id: matches[0].id, row: matches[0] };
-  if (matches.length > 1) return { ok: false, reason: 'ambiguous', matches };
+  const wsRoot = taskDb.workspaceRoot ? taskDb.workspaceRoot() : process.cwd();
+
+  const proj = readProjectionFile(wsRoot);
+  if (proj && Array.isArray(proj.tasks)) {
+    const seen = new Set();
+    const matches = proj.tasks.filter(r => {
+      const id = String(r.id || '').toUpperCase();
+      const display = taskDb.normalizeTaskRef ? taskDb.normalizeTaskRef(r.display_id) : String(r.display_id || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+      const legacy = taskDb.normalizeTaskRef ? taskDb.normalizeTaskRef(r.legacy_ref) : String(r.legacy_ref || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+      const matched = id.startsWith(normalized) || (display && display === normalized) || (legacy && legacy === normalized);
+      if (!matched || seen.has(r.id)) return false;
+      seen.add(r.id);
+      return true;
+    });
+    if (matches.length === 1) {
+      const match = matches[0];
+      const row = db ? (taskDb.getTask(db, match.id) || match) : match;
+      return { ok: true, id: match.id, row };
+    }
+    if (matches.length > 1) return { ok: false, reason: 'ambiguous', matches };
+  }
+
+  if (db) {
+    const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot: wsRoot }));
+    const seen = new Set();
+    const matches = rows.filter(r => {
+      const id = String(r.id || '').toUpperCase();
+      const display = taskDb.normalizeTaskRef ? taskDb.normalizeTaskRef(r.display_id) : String(r.display_id || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+      const legacy = taskDb.normalizeTaskRef ? taskDb.normalizeTaskRef(r.legacy_ref) : String(r.legacy_ref || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+      const matched = id.startsWith(normalized) || (display && display === normalized) || (legacy && legacy === normalized);
+      if (!matched || seen.has(r.id)) return false;
+      seen.add(r.id);
+      return true;
+    });
+    if (matches.length === 1) return { ok: true, id: matches[0].id, row: matches[0] };
+    if (matches.length > 1) return { ok: false, reason: 'ambiguous', matches };
+  }
   return { ok: false, reason: 'not_found' };
 }
 
@@ -6067,7 +6108,7 @@ function workspaceRefRows(taskDb, db, options = {}) {
 }
 
 function renderTaskDesk(rows, refRows = rows) {
-  const displayRows = getTaskDb().withTaskDisplayRefs(rows, refRows);
+  const displayRows = (rows && rows.length && rows[0].display_id) ? rows : getTaskDb().withTaskDisplayRefs(rows, refRows);
   const active = displayRows.filter(r => r.status !== 'done' && r.status !== 'archived');
   const done = displayRows.filter(r => r.status === 'done');
   if (rows.length === 0) {
@@ -6078,7 +6119,7 @@ function renderTaskDesk(rows, refRows = rows) {
   console.log('TASK DESK');
   console.log('');
   for (const r of active.slice(0, 12)) {
-    const explanation = taskExplanation(r);
+    const explanation = r.explanation || taskExplanation(r);
     const owner = r.claimed_by ? ` @${r.claimed_by}` : '';
     const assigned = !r.claimed_by && taskAssignee(r) ? ` -> ${taskAssignee(r)}` : '';
     const tag = r.tag ? ` #${r.tag}` : '';
@@ -6415,7 +6456,17 @@ function cmdHome(args) {
     workspaceRoot,
     limit: all ? null : 200,
   });
-  const { projection, outPath } = writeDefaultProjection(taskDb, db, { all, everywhere });
+  let projection;
+  let outPath;
+  const existingProj = readProjectionFile(workspaceRoot);
+  if (rows.length === 0 && existingProj && Array.isArray(existingProj.tasks) && existingProj.tasks.length > 0) {
+    projection = existingProj;
+    outPath = path.resolve(path.join(workspaceRoot || '.', '.atris', 'state', 'tasks.projection.json'));
+  } else {
+    const written = writeDefaultProjection(taskDb, db, { all, everywhere });
+    projection = written.projection;
+    outPath = written.outPath;
+  }
   if (wantsJson(args)) {
     printJson({
       ok: true,
@@ -6427,7 +6478,7 @@ function cmdHome(args) {
     });
     return;
   }
-  renderTaskDesk(rows, rows);
+  renderTaskDesk(projection.tasks);
 }
 
 function cmdList(args) {
@@ -7382,7 +7433,14 @@ function cmdInspect(args) {
   const db = taskDb.open();
   const taskId = requireTaskId(taskDb, db, ref, 'atris task inspect');
   const projection = enrichTaskProjection(taskDb.taskProjection(db, { taskId }));
-  const task = projection.tasks[0];
+  let task = projection.tasks[0];
+  if (!task) {
+    const wsRoot = scopedWorkspaceRoot(taskDb, args) || process.cwd();
+    const proj = readProjectionFile(wsRoot);
+    if (proj && Array.isArray(proj.tasks)) {
+      task = proj.tasks.find(t => t.id === taskId) || null;
+    }
+  }
   if (!task) {
     failTask('atris task inspect', 'not_found', `task not found: ${ref}`, 1);
   }
@@ -7411,7 +7469,14 @@ function cmdShow(args) {
   const db = taskDb.open();
   const taskId = requireTaskId(taskDb, db, id, 'atris task show');
   const projection = enrichTaskProjection(taskDb.taskProjection(db, { taskId }));
-  const task = projection.tasks[0];
+  let task = projection.tasks[0];
+  if (!task) {
+    const wsRoot = scopedWorkspaceRoot(taskDb, args) || process.cwd();
+    const proj = readProjectionFile(wsRoot);
+    if (proj && Array.isArray(proj.tasks)) {
+      task = proj.tasks.find(t => t.id === taskId) || null;
+    }
+  }
   if (!task) {
     console.error(`task not found: ${id}`);
     process.exit(1);
@@ -7550,7 +7615,14 @@ function cmdReviewChat(args) {
 
 function taskDetail(taskDb, db, taskId) {
   const detailedProjection = taskDb.taskProjection(db, { taskId });
-  const detailedTask = detailedProjection.tasks[0] || null;
+  let detailedTask = detailedProjection.tasks[0] || null;
+  if (!detailedTask) {
+    const wsRoot = taskDb.workspaceRoot ? taskDb.workspaceRoot() : process.cwd();
+    const proj = readProjectionFile(wsRoot);
+    if (proj && Array.isArray(proj.tasks)) {
+      detailedTask = proj.tasks.find(t => t.id === taskId) || null;
+    }
+  }
   if (!detailedTask) return null;
   const workspaceRoot = detailedTask.workspace_root || taskDb.workspaceRoot();
   const contextProjection = enrichTaskProjection(taskDb.taskProjection(db, {
@@ -7558,7 +7630,7 @@ function taskDetail(taskDb, db, taskId) {
     limit: 5000,
   }));
   const enrichedTask = contextProjection.tasks.find(task => task.id === detailedTask.id) || null;
-  if (!enrichedTask) return enrichTaskProjection(detailedProjection).tasks[0] || null;
+  if (!enrichedTask) return enrichTaskProjection(detailedProjection).tasks[0] || detailedTask;
   return {
     ...enrichedTask,
     current_version: detailedTask.current_version,

package/commands/who.js

@@ -0,0 +1,176 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const { repoRoot } = require('./stream');
+const {
+  buildWorkforcePresence,
+  isFinishedReceipt,
+  parsePsOutput,
+  receiptEngine,
+  renderWorkforcePresence,
+} = require('../lib/workforce-presence');
+
+function readJson(file, fsModule = fs, fallback = null) {
+  try {
+    return JSON.parse(fsModule.readFileSync(file, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function readJsonLines(file, fsModule = fs) {
+  let text;
+  try {
+    text = fsModule.readFileSync(file, 'utf8');
+  } catch {
+    return [];
+  }
+  return String(text)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function collectTasks(root, fsModule = fs) {
+  const payload = readJson(path.join(root, '.atris', 'state', 'tasks.projection.json'), fsModule, {});
+  return Array.isArray(payload?.tasks) ? payload.tasks : [];
+}
+
+function collectMissions(root, fsModule = fs) {
+  const rows = readJsonLines(path.join(root, '.atris', 'state', 'missions.jsonl'), fsModule);
+  const latestById = new Map();
+  for (const row of rows) {
+    const id = String(row?.id || '').trim();
+    if (id) latestById.set(id, row);
+  }
+  return [...latestById.values()];
+}
+
+function collectReceipts(root, fsModule = fs) {
+  const runsDir = path.join(root, 'atris', 'runs');
+  let names;
+  try {
+    names = fsModule.readdirSync(runsDir).filter((name) => name.endsWith('.json')).sort();
+  } catch {
+    return [];
+  }
+  const receipts = [];
+  for (const name of names) {
+    const receiptPath = path.join(runsDir, name);
+    const receipt = readJson(receiptPath, fsModule);
+    if (!receipt || !receiptEngine(receipt)) continue;
+    let mtimeMs = 0;
+    try { mtimeMs = fsModule.statSync(receiptPath).mtimeMs; } catch {}
+    receipts.push({ name, path: receiptPath, mtimeMs, receipt });
+  }
+  return receipts;
+}
+
+function collectProcesses(deps = {}) {
+  if (Array.isArray(deps.processes)) return deps.processes;
+  const execFile = deps.execFile || execFileSync;
+  try {
+    const output = execFile('ps', ['-eo', 'pid=,ppid=,lstart=,command='], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return parsePsOutput(output);
+  } catch {
+    return [];
+  }
+}
+
+function collectWorkforcePresence(deps = {}) {
+  const fsModule = deps.fs || fs;
+  const root = deps.root || repoRoot(deps.cwd || process.cwd());
+  const receipts = Array.isArray(deps.receipts) ? deps.receipts : collectReceipts(root, fsModule);
+  return buildWorkforcePresence({
+    nowMs: typeof deps.now === 'function' ? deps.now() : Date.now(),
+    staleAfterMs: deps.staleAfterMs,
+    processes: collectProcesses(deps),
+    tasks: Array.isArray(deps.tasks) ? deps.tasks : collectTasks(root, fsModule),
+    missions: Array.isArray(deps.missions) ? deps.missions : collectMissions(root, fsModule),
+    receipts,
+  });
+}
+
+function archiveFinishedRuns(root, receipts, fsModule = fs) {
+  const archiveDir = path.join(root, 'atris', 'runs', 'archive');
+  const finished = receipts.filter((entry) => isFinishedReceipt(entry.receipt));
+  const summary = {
+    schema: 'atris.workforce_clear.v1',
+    archive_dir: path.relative(root, archiveDir),
+    archived: 0,
+    failed: [],
+  };
+  if (!finished.length) return summary;
+  fsModule.mkdirSync(archiveDir, { recursive: true });
+  for (const entry of finished) {
+    const destination = path.join(archiveDir, entry.name);
+    if (fsModule.existsSync(destination)) {
+      summary.failed.push({ receipt: entry.name, reason: 'archive destination already exists' });
+      continue;
+    }
+    try {
+      fsModule.renameSync(entry.path, destination);
+      summary.archived += 1;
+    } catch (error) {
+      summary.failed.push({ receipt: entry.name, reason: error.message || String(error) });
+    }
+  }
+  return summary;
+}
+
+function helpText() {
+  return [
+    'atris who - show local engines and team members from live process and final run state',
+    '',
+    'usage: atris who [--json]',
+    'usage: atris who --clear [--json]',
+    '',
+    '--clear archives finished run receipts under atris/runs/archive/.',
+  ].join('\n');
+}
+
+function whoCommand(args = [], deps = {}) {
+  const write = deps.write || process.stdout.write.bind(process.stdout);
+  const error = deps.error || process.stderr.write.bind(process.stderr);
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    write(`${helpText()}\n`);
+    return 0;
+  }
+  if (args.some((arg) => !['--json', '--clear'].includes(arg))) {
+    error('usage: atris who [--json] [--clear]\n');
+    return 2;
+  }
+
+  const fsModule = deps.fs || fs;
+  const root = deps.root || repoRoot(deps.cwd || process.cwd());
+  const receipts = Array.isArray(deps.receipts) ? deps.receipts : collectReceipts(root, fsModule);
+  if (args.includes('--clear')) {
+    const summary = archiveFinishedRuns(root, receipts, fsModule);
+    if (args.includes('--json')) write(`${JSON.stringify(summary, null, 2)}\n`);
+    else if (summary.failed.length) write(`archived ${summary.archived} finished runs; ${summary.failed.length} could not be archived.\n`);
+    else if (summary.archived) write(`archived ${summary.archived} finished run${summary.archived === 1 ? '' : 's'} in ${summary.archive_dir}.\n`);
+    else write('no finished runs to clear.\n');
+    return summary.failed.length ? 1 : 0;
+  }
+
+  const presence = collectWorkforcePresence({ ...deps, root, receipts });
+  const output = args.includes('--json')
+    ? JSON.stringify(presence, null, 2)
+    : renderWorkforcePresence(presence);
+  write(`${output}\n`);
+  return 0;
+}
+
+module.exports = {
+  whoCommand,
+};

package/commands/worktree.js

@@ -160,6 +160,8 @@ function listWorktrees(root = repoRoot()) {
 // Duplicate flight guard. On 2026-08-07 two agents were dispatched onto the
 // same map rewrite 44 seconds apart: fleet dispatch claims a task first, but a
 // direct `worktree start` had no pre-check beyond the target path existing.
+// Refuse only the same task slug. A shared word on an unrelated flight is not
+// a collision (dispatch-cli-900 must not block dispatch-cli-901).
 const AGENT_FLIGHT_NAME_PATTERN = /^codex\/(.+)-(\d{8}-\d{6})$/;
 const FLIGHT_WINDOW_MS = 24 * 60 * 60 * 1000;
 const FLIGHT_STOPWORDS = new Set([
@@ -234,10 +236,10 @@ function inFlightAgentFlights({ root = repoRoot(), now = new Date(), windowMs =
   return [...flights.values()].sort((a, b) => b.stampMs - a.stampMs);
 }
 
-function collidingFlights(flights, tokens) {
-  const wanted = new Set(tokens);
-  if (!wanted.size) return [];
-  return flights.filter((flight) => flight.tokens.some((token) => wanted.has(token)));
+function collidingFlights(flights, taskSlug) {
+  const wanted = String(taskSlug || '').trim().toLowerCase();
+  if (!wanted) return [];
+  return flights.filter((flight) => String(flight.taskSlug || '').toLowerCase() === wanted);
 }
 
 function describeFlightAge(flight, nowMs = Date.now()) {
@@ -511,7 +513,7 @@ function startWorktree(args) {
   const active = flights.filter((flight) => flight.kind === 'worktree');
   const repoName = path.basename(findPrimaryRoot(root));
   console.log(`flights: ${active.length} active agent ${active.length === 1 ? 'worktree' : 'worktrees'} for ${repoName}`);
-  const collisions = collidingFlights(flights, taskTokens(slugify(task, 'task', 36)));
+  const collisions = collidingFlights(flights, slugify(task, 'task', 36));
   if (collisions.length) {
     const label = force ? 'warning' : 'refusing';
     for (const flight of collisions) {

package/lib/engine-registry.js

@@ -33,6 +33,7 @@ function engineFailureHealthStatus(result) {
   if (/usage[ _-]?limit|purchase more credits|insufficient credits|credit(?:s)?[ _-]?(?:out|limit)|rate[ _-]?limit|not authenticated|please log in|login required|auth(?:entication)?[ _-]?expired|payment required|subscription/.test(signalText)) {
     return 'credit_out';
   }
+  if (/not installed|command not found|\benoent\b/.test(signalText)) return 'not_installed';
   if (/timeout|model-unavailable/.test(signalText)) return 'not_installed';
   return 'error';
 }

package/lib/fleet.js

@@ -208,7 +208,7 @@ function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = fal
     if (sealed && engineName === 'codex') {
       cmd = cmd.replace(/\bexec\b/, 'exec --sandbox workspace-write --ephemeral --ignore-user-config --ignore-rules');
     }
-    if (sealed && engineName === 'claude') {
+    if (sealed && (engineName === 'claude' || engineName === 'fable')) {
       cmd = `${cmd} --safe-mode --no-session-persistence --permission-mode acceptEdits --settings '${JSON.stringify({ sandbox: { enabled: true, autoAllowBashIfSandboxed: true } })}'`;
     }
     if (sealed && engineName === 'cursor') cmd = `${cmd} --sandbox enabled`;
@@ -218,7 +218,7 @@ function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = fal
     }
     if (engineName === 'devin') return cmd.replace(/^devin -p /, 'devin -p --permission-mode dangerous ');
     if (yolo && engineName === 'codex') cmd = cmd.replace(/\bexec\b/, `exec ${YOLO_ENGINE_FLAGS.codex}`);
-    if (yolo && engineName === 'claude') cmd = `${cmd} ${YOLO_ENGINE_FLAGS.claude}`;
+    if (yolo && (engineName === 'claude' || engineName === 'fable')) cmd = `${cmd} ${YOLO_ENGINE_FLAGS.claude}`;
     if (engineName === 'codex') cmd = wrapCodexWithWatchdog(cmd, watchdogPath, watchdogReceiptPath);
     return cmd;
   } finally {
@@ -561,6 +561,25 @@ function detectDeadEngineDispatch(result) {
   return { reason: 'nonzero_exit', exitCode };
 }
 
+function plainDispatchFailureCause(result, failure = {}) {
+  const reason = String(failure.reason || failure.stage || '').trim();
+  const output = dispatchResultOutput(result);
+  if (reason === 'no_output') return 'the engine returned no output';
+  if (/not authenticated|please log in|login required|auth(?:entication)?[ _-]?expired/i.test(output)) {
+    return 'the engine login expired';
+  }
+  if (/spawn[^\n]*enoent|enoent[^\n]*spawn|failed to spawn/i.test(output)) {
+    return 'the engine could not start';
+  }
+  if (reason === 'timeout') return 'the engine timed out';
+  if (reason === 'cancelled') return 'the engine run was cancelled';
+  if (reason === 'unknown') return 'the engine exited without a status';
+  if (reason === 'signalled') return `the engine stopped with ${failure.signal || 'a signal'}`;
+  const detail = String(failure.detail || output || '').trim().split('\n')[0].trim();
+  if (detail) return detail.replace(/[.]+$/, '');
+  return (reason || 'the engine failed').replace(/_/g, ' ');
+}
+
 function recordDispatchEngineHealth(result, failure, root) {
   if (!result || !result.engine) return null;
   const status = failure
@@ -1081,6 +1100,7 @@ module.exports = {
   shipWithRetry,
   shipFailureDetail,
   get FLEET_CAPABLE() { return FLEET_CAPABLE; },
+  get DISPATCH_CAPABLE() { return DISPATCH_CAPABLE; },
   get runFleetFlight() { return runFleetFlight; },
   get focusedCheck() { return focusedCheck; },
   get dispatchCheck() { return dispatchCheck; },
@@ -1122,6 +1142,7 @@ module.exports = {
 // Engines that can edit a repo headlessly. atris-fast (ax) is a chat lane,
 // not a repo worker — it keeps owning normal mission ticks, not fleet builds.
 const FLEET_CAPABLE = ['claude', 'codex', 'cursor', 'devin', 'grok'];
+const DISPATCH_CAPABLE = [...FLEET_CAPABLE, 'fable'];
 
 let receiptSequence = 0;
 function nowStamp() {
@@ -2658,6 +2679,18 @@ async function runFleetFlight({
 // ---------------------------------------------------------------------------
 // T5 — one-command dispatch: `atris engine dispatch <task-id> --engine <name>`
 
+// A claim taken before the engine starts must not stay held if the flight
+// refuses or errors first. Release through the same task plane the claim used.
+function releaseUnstartedDispatchClaim(cli, { taskId, actor, detail }) {
+  const released = cli(['task', 'release', taskId, '--as', actor]);
+  const releasedOk = Boolean(released && released.status === 0);
+  const suffix = releasedOk
+    ? 'claim released, safe to retry'
+    : `claim release failed: ${String(released && (released.stderr || released.stdout) || 'unknown').trim().slice(0, 80)}`;
+  const base = String(detail || '').trim().slice(0, 200);
+  return { released: releasedOk, detail: base ? `${base}. ${suffix}` : suffix };
+}
+
 // The manual version of this loop took 6 Bash calls per task the night this
 // was written: claim, worktree start, prompt file, engine -p, verify, ship.
 // One or more explicit task ids build in parallel isolated worktrees on ONE
@@ -2693,8 +2726,8 @@ async function runDispatchFlight({
   scoutAsk = null,
 } = {}) {
   if (!engine) throw new Error('runDispatchFlight: engine is required');
-  if (!FLEET_CAPABLE.includes(engine)) {
-    throw new Error(`runDispatchFlight: engine "${engine}" cannot build headlessly (capable: ${FLEET_CAPABLE.join(', ')})`);
+  if (!DISPATCH_CAPABLE.includes(engine)) {
+    throw new Error(`runDispatchFlight: engine "${engine}" cannot build headlessly (capable: ${DISPATCH_CAPABLE.join(', ')})`);
   }
   const ids = [...new Set((taskIds || []).map((id) => String(id).trim()).filter(Boolean))];
   if (!ids.length) throw new Error('runDispatchFlight: at least one task id is required');
@@ -2760,51 +2793,71 @@ async function runDispatchFlight({
       log(`    x ${taskId} claim failed`);
       continue;
     }
-    let landingWorktreePath = '';
-    let remoteBoundary = null;
-    if (enforceRemoteBoundary) {
-      remoteBoundary = prepareReviewSandbox({ root, taskId, engine });
-    } else {
-      const started = cli(['worktree', 'start', '--agent', engine, '--task', `dispatch-${taskId.toLowerCase()}`, ...startBaseArgs]);
-      const wt = (started.stdout.match(/next: cd (.+)/) || [])[1];
-      if (!wt) {
-        flight.paused.push({ task: taskId, stage: 'worktree_start', detail: String(started.stderr || '').slice(0, 200) });
-        log(`    ✗ ${taskId} worktree start failed`);
+    try {
+      let landingWorktreePath = '';
+      let remoteBoundary = null;
+      if (enforceRemoteBoundary) {
+        remoteBoundary = prepareReviewSandbox({ root, taskId, engine });
+      } else {
+        const started = cli(['worktree', 'start', '--agent', engine, '--task', `dispatch-${taskId.toLowerCase()}`, ...startBaseArgs]);
+        const wt = (started.stdout.match(/next: cd (.+)/) || [])[1];
+        if (!wt) {
+          const released = releaseUnstartedDispatchClaim(cli, {
+            taskId,
+            actor: taskActor,
+            detail: String(started.stderr || '').slice(0, 200),
+          });
+          flight.paused.push({ task: taskId, stage: 'worktree_start', detail: released.detail });
+          log(`    ✗ ${taskId} worktree start failed`);
+          continue;
+        }
+        landingWorktreePath = wt.trim();
+      }
+      if (enforceRemoteBoundary && (!remoteBoundary || remoteBoundary.ok !== true)) {
+        const released = releaseUnstartedDispatchClaim(cli, {
+          taskId,
+          actor: taskActor,
+          detail: String(remoteBoundary && remoteBoundary.detail || 'could not prepare a sealed review sandbox').slice(-500),
+        });
+        flight.paused.push({
+          task: taskId,
+          stage: 'remote_quarantine',
+          detail: released.detail,
+          worktree: null,
+        });
+        log(`    paused ${taskId} because its sealed review sandbox could not be prepared`);
         continue;
       }
-      landingWorktreePath = wt.trim();
-    }
-    if (enforceRemoteBoundary && (!remoteBoundary || remoteBoundary.ok !== true)) {
-      flight.paused.push({
-        task: taskId,
-        stage: 'remote_quarantine',
-        detail: String(remoteBoundary && remoteBoundary.detail || 'could not prepare a sealed review sandbox').slice(-500),
-        worktree: null,
+      const worktreePath = enforceRemoteBoundary ? remoteBoundary.worktreePath : landingWorktreePath;
+      const startCommit = yolo ? readStartCommit({ worktreePath }) : '';
+      const basePrompt = promptOverride || buildFleetPrompt(task, { worktreePath, yolo });
+      const safetyPrompt = reviewOnly
+        ? `${basePrompt}\n\nSafety boundary: edit and test this checkout only. Do not push, merge, deploy, publish, send messages, change cloud state, install dependencies, or use credentials.`
+        : basePrompt;
+      const trustedPrompt = trustedVerifier
+        ? `${safetyPrompt}\n\nTrusted verifier (run it bare before reporting done): ${trustedVerifier}`
+        : promptOverride;
+      prepared.push({
+        task,
+        taskId,
+        worktreePath,
+        landingWorktreePath,
+        engine,
+        remoteBoundary,
+        remoteMasterBefore: remoteBoundary ? remoteBoundary.protectedMaster : '',
+        startCommit,
+        ...(trustedPrompt ? { prompt: trustedPrompt } : {}),
       });
-      log(`    paused ${taskId} because its sealed review sandbox could not be prepared`);
-      continue;
+      log(`    building ${taskId} in ${path.basename(worktreePath)}`);
+    } catch (err) {
+      const released = releaseUnstartedDispatchClaim(cli, {
+        taskId,
+        actor: taskActor,
+        detail: String(err && err.message || err).slice(0, 200),
+      });
+      flight.paused.push({ task: taskId, stage: 'prepare', detail: released.detail });
+      log(`    ✗ ${taskId} prepare failed`);
     }
-    const worktreePath = enforceRemoteBoundary ? remoteBoundary.worktreePath : landingWorktreePath;
-    const startCommit = yolo ? readStartCommit({ worktreePath }) : '';
-    const basePrompt = promptOverride || buildFleetPrompt(task, { worktreePath, yolo });
-    const safetyPrompt = reviewOnly
-      ? `${basePrompt}\n\nSafety boundary: edit and test this checkout only. Do not push, merge, deploy, publish, send messages, change cloud state, install dependencies, or use credentials.`
-      : basePrompt;
-    const trustedPrompt = trustedVerifier
-      ? `${safetyPrompt}\n\nTrusted verifier (run it bare before reporting done): ${trustedVerifier}`
-      : promptOverride;
-    prepared.push({
-      task,
-      taskId,
-      worktreePath,
-      landingWorktreePath,
-      engine,
-      remoteBoundary,
-      remoteMasterBefore: remoteBoundary ? remoteBoundary.protectedMaster : '',
-      startCommit,
-      ...(trustedPrompt ? { prompt: trustedPrompt } : {}),
-    });
-    log(`    building ${taskId} in ${path.basename(worktreePath)}`);
   }
 
   const dispatch = dispatcher || ((entry) => new Promise((resolve) => {
@@ -2828,6 +2881,10 @@ async function runDispatchFlight({
   }));
   const restaffState = { used: false };
 
+  if (engine === 'fable' && prepared.length) {
+    log(`  fable handoff started: receipt ${path.relative(root, receiptPath)}`);
+  }
+
   const results = await Promise.all(prepared.map((entry) => {
     const startedAtMs = Date.now();
     return dispatchEntryWithRestaff({
@@ -3343,6 +3400,12 @@ async function runDispatchFlight({
   flight.finished_at = new Date().toISOString();
   writeDispatchReceipt(flight, receiptPath, { ids, reviewOnly, enforceRemoteBoundary });
   log('');
+  if (engine === 'fable' && flight.paused.length) {
+    const paused = flight.paused[0];
+    const failed = results.find(({ entry }) => entry.taskId === paused.task);
+    const cause = plainDispatchFailureCause(failed && failed.result, paused);
+    log(`  fable handoff failed: ${cause}. receipt: ${path.relative(root, receiptPath)}`);
+  }
   const completedLabel = reviewOnly ? `${flight.ready.length} proof ready` : `${flight.landed.length} landed`;
   log(`  dispatch over: ${completedLabel}, ${flight.paused.length} paused - receipt: ${path.relative(root, flight.receipt)}`);
   log('');

package/lib/known-commands.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const knownCommands = ['init', 'log', 'logs', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
+const knownCommands = ['init', 'log', 'logs', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',

package/lib/task-db.js

@@ -369,8 +369,8 @@ function withTaskDisplayRefs(rows, refRows = rows) {
     const ids = sorted.map(row => row && row.id);
     sorted.forEach((row, index) => {
       refs.set(row.id, {
-        display_id: taskDisplayRef(row, index),
-        legacy_ref: shortestUniqueTaskRef(row.id, ids, 8),
+        display_id: row.display_id || taskDisplayRef(row, index),
+        legacy_ref: row.legacy_ref || shortestUniqueTaskRef(row.id, ids, 8),
       });
     });
   }

package/lib/workforce-presence.js

@@ -0,0 +1,448 @@
+'use strict';
+
+const DEFAULT_STALE_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
+const PROCESS_START_TOLERANCE_MS = 30 * 60 * 1000;
+const ACTIVE_TASK_STATUSES = new Set(['claimed', 'do', 'doing', 'in_progress', 'review']);
+const ACTIVE_MISSION_STATUSES = new Set(['planning', 'active', 'running', 'ready']);
+const RUNNING_RECEIPT_STATUSES = new Set(['active', 'in_progress', 'running', 'started', 'working']);
+const TERMINAL_RECEIPT_STATUSES = new Set([
+  'cancelled',
+  'completed',
+  'done',
+  'failed',
+  'landed',
+  'no_output',
+  'passed',
+  'presumed_dead',
+  'succeeded',
+  'timed_out',
+]);
+const WORK_TOKEN_STOP_WORDS = new Set([
+  'agent', 'build', 'building', 'engine', 'local', 'mission', 'process', 'running', 'task', 'working',
+]);
+
+function timestampMs(value) {
+  if (value == null || value === '') return 0;
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) return 0;
+    return value > 1000000000000 ? value : value * 1000;
+  }
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && String(value).trim()) return timestampMs(numeric);
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function isoTimestamp(value) {
+  const ms = timestampMs(value);
+  return ms ? new Date(ms).toISOString() : null;
+}
+
+function ageSeconds(value, nowMs) {
+  const ms = timestampMs(value);
+  return ms ? Math.max(0, Math.floor((nowMs - ms) / 1000)) : null;
+}
+
+function normalizeEngine(value) {
+  const engine = String(value || '').trim().toLowerCase();
+  if (!engine) return '';
+  if (engine === 'cursor-agent' || engine === 'cursor agent') return 'cursor';
+  if (engine === 'claude-code') return 'claude';
+  return engine.replace(/[^a-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
+}
+
+function engineForCommand(command) {
+  const text = String(command || '');
+  if (/ChatGPT\.app|Codex Framework\.framework|Claude\.app/.test(text)) return '';
+  const executable = text.trim().split(/\s+/)[0] || '';
+  const name = executable.split('/').pop().toLowerCase();
+  if (name === 'cursor-agent') return 'cursor';
+  if (/^codex(?:-|$)/.test(name)) return 'codex';
+  if (name === 'grok') return 'grok';
+  if (name === 'devin') return 'devin';
+  if (name === 'droid') return 'droid';
+  if (name === 'agy') return 'agy';
+  if (name === 'claude' && /(^|\s)(?:-p|--print)(?:\s|$)/.test(text)) return 'claude';
+  return '';
+}
+
+function parsePsOutput(text) {
+  const allRows = [];
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 8) continue;
+    const pid = Number(parts[0]);
+    const ppid = Number(parts[1]);
+    const command = parts.slice(7).join(' ');
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    const started = Date.parse(parts.slice(2, 7).join(' '));
+    allRows.push({
+      pid,
+      ppid: Number.isInteger(ppid) && ppid > 0 ? ppid : null,
+      command,
+      started_at: Number.isFinite(started) ? new Date(started).toISOString() : null,
+    });
+  }
+  const byPid = new Map(allRows.map((row) => [row.pid, row]));
+  const engineRows = allRows
+    .map((row) => ({ ...row, engine: engineForCommand(row.command) }))
+    .filter((row) => row.engine);
+  const parentPids = new Set(engineRows.map((row) => row.ppid).filter(Boolean));
+  return engineRows
+    .filter((row) => !parentPids.has(row.pid))
+    .map((row) => {
+      const ancestorPids = [];
+      let parent = row.ppid;
+      while (parent && !ancestorPids.includes(parent) && ancestorPids.length < 64) {
+        ancestorPids.push(parent);
+        parent = byPid.get(parent)?.ppid || null;
+      }
+      return { ...row, ancestor_pids: ancestorPids };
+    });
+}
+
+function normalizeProcesses(processes) {
+  const byPid = new Map();
+  for (const row of Array.isArray(processes) ? processes : []) {
+    const pid = Number(row?.pid);
+    const engine = normalizeEngine(row?.engine) || engineForCommand(row?.command);
+    if (!Number.isInteger(pid) || pid <= 0 || !engine) continue;
+    byPid.set(pid, {
+      pid,
+      ppid: Number(row?.ppid) || null,
+      engine,
+      command: String(row?.command || ''),
+      started_at: isoTimestamp(row?.started_at || row?.start || row?.at),
+      ancestor_pids: (Array.isArray(row?.ancestor_pids) ? row.ancestor_pids : [])
+        .map(Number)
+        .filter((value) => Number.isInteger(value) && value > 0),
+    });
+  }
+  return [...byPid.values()].sort((left, right) => left.pid - right.pid);
+}
+
+function taskRef(task) {
+  return String(task?.display_id || task?.legacy_ref || task?.id || '').trim();
+}
+
+function taskOwner(task) {
+  return String(task?.claimed_by || task?.assigned_to || task?.metadata?.assigned_to || '').trim();
+}
+
+function taskActivity(task) {
+  return task?.updated_at || task?.claimed_at || task?.created_at || null;
+}
+
+function receiptTaskRefs(receipt) {
+  const values = [receipt?.task_id, receipt?.task];
+  if (Array.isArray(receipt?.tasks)) values.push(...receipt.tasks);
+  if (Array.isArray(receipt?.task_ids)) values.push(...receipt.task_ids);
+  if (Array.isArray(receipt?.results)) values.push(...receipt.results.map((row) => row?.task || row?.task_id));
+  return [...new Set(values.map((value) => {
+    if (value && typeof value === 'object') return value.display_id || value.id || value.task;
+    return value;
+  }).map((value) => String(value || '').trim()).filter(Boolean))];
+}
+
+function receiptEngine(receipt) {
+  return normalizeEngine(
+    receipt?.engine
+      || receipt?.engines?.[0]
+      || receipt?.results?.find((row) => row?.engine)?.engine,
+  );
+}
+
+function receiptStatus(receipt) {
+  return String(receipt?.status || '').trim().toLowerCase();
+}
+
+function isRunningReceipt(receipt) {
+  return !receipt?.finished_at && RUNNING_RECEIPT_STATUSES.has(receiptStatus(receipt));
+}
+
+function isFinishedReceipt(receipt) {
+  if (!receipt || isRunningReceipt(receipt)) return false;
+  return Boolean(receipt.finished_at || TERMINAL_RECEIPT_STATUSES.has(receiptStatus(receipt)));
+}
+
+function receiptStartedAt(receipt, fallback) {
+  return receipt?.started_at || receipt?.at || receipt?.created_at || fallback || null;
+}
+
+function receiptFinishedAt(receipt, fallback) {
+  return receipt?.finished_at || receipt?.completed_at || receipt?.updated_at || fallback || null;
+}
+
+function finalResult(receipt) {
+  if (typeof receipt?.result === 'string') return receipt.result.trim();
+  if (receipt?.result && typeof receipt.result === 'object') {
+    const kind = String(receipt.result.kind || '').trim();
+    if (typeof receipt.result.passed === 'boolean') return `${kind || 'result'} ${receipt.result.passed ? 'passed' : 'failed'}`;
+    if (kind) return kind;
+  }
+  if (receipt?.summary && typeof receipt.summary === 'object') {
+    const answered = Number(receipt.summary.answered) || 0;
+    const failed = Number(receipt.summary.failed) || 0;
+    if (answered || failed) return `${answered} answered, ${failed} failed`;
+  }
+  return receiptStatus(receipt) || 'finished';
+}
+
+function taskLookup(tasks) {
+  const byRef = new Map();
+  for (const task of tasks) {
+    for (const ref of [task?.id, task?.display_id, task?.legacy_ref]) {
+      const key = String(ref || '').trim().toLowerCase();
+      if (key) byRef.set(key, task);
+    }
+  }
+  return byRef;
+}
+
+function firstTaskForRefs(refs, byRef) {
+  for (const ref of refs) {
+    const task = byRef.get(String(ref).toLowerCase());
+    if (task) return task;
+  }
+  return null;
+}
+
+function rowTask(refs, task) {
+  return taskRef(task) || refs[0] || null;
+}
+
+function baseRow({ member, task, title, engine, source, at, nowMs }) {
+  return {
+    member: member || null,
+    task: task || null,
+    title: title || null,
+    engine: engine || null,
+    source,
+    at: isoTimestamp(at),
+    age_seconds: ageSeconds(at, nowMs),
+  };
+}
+
+function buildWorkforcePresence(input = {}) {
+  const nowMs = timestampMs(input.nowMs ?? input.now ?? Date.now()) || Date.now();
+  const staleAfterMs = Number(input.staleAfterMs) > 0 ? Number(input.staleAfterMs) : DEFAULT_STALE_AFTER_MS;
+  const tasks = (Array.isArray(input.tasks) ? input.tasks : [])
+    .filter((task) => ACTIVE_TASK_STATUSES.has(String(task?.status || '').toLowerCase()) && taskOwner(task));
+  const missions = (Array.isArray(input.missions) ? input.missions : [])
+    .filter((mission) => ACTIVE_MISSION_STATUSES.has(String(mission?.status || '').toLowerCase()));
+  const receipts = Array.isArray(input.receipts) ? input.receipts : [];
+  const processes = normalizeProcesses(input.processes);
+  const byTaskRef = taskLookup(tasks);
+  const usedPids = new Set();
+  const representedTasks = new Set();
+  const working = [];
+  const waiting = [];
+  const done = [];
+  const stale = [];
+
+  const claimProcess = (engine, pid, expectedStart) => {
+    const wantedPid = Number(pid);
+    if (Number.isInteger(wantedPid) && wantedPid > 0) {
+      const exact = processes.find((row) => (
+        row.pid === wantedPid || row.ancestor_pids.includes(wantedPid)
+      ) && row.engine === engine && !usedPids.has(row.pid) && (
+        !timestampMs(expectedStart)
+        || !timestampMs(row.started_at)
+        || Math.abs(timestampMs(row.started_at) - timestampMs(expectedStart)) <= PROCESS_START_TOLERANCE_MS
+      ));
+      if (exact) usedPids.add(exact.pid);
+      return exact || null;
+    }
+    return null;
+  };
+  const workTokens = (value) => new Set(
+    (String(value || '').toLowerCase().match(/[a-z][a-z0-9]{4,}/g) || [])
+      .filter((token) => !WORK_TOKEN_STOP_WORDS.has(token)),
+  );
+  const processMatchesWork = (row, refs, title) => {
+    const command = String(row.command || '').toLowerCase();
+    if (refs.some((ref) => command.includes(String(ref).toLowerCase()))) return true;
+    const titleTokens = workTokens(title);
+    const commandTokens = workTokens(command);
+    return [...titleTokens].some((token) => commandTokens.has(token));
+  };
+  const claimMatchingProcess = (engine, refs, title) => {
+    const candidate = processes.find((row) => (
+      (!engine || row.engine === engine)
+      && !usedPids.has(row.pid)
+      && processMatchesWork(row, refs, title)
+    ));
+    if (candidate) usedPids.add(candidate.pid);
+    return candidate || null;
+  };
+
+  for (const entry of receipts) {
+    const receipt = entry?.receipt || entry;
+    const engine = receiptEngine(receipt);
+    if (!engine) continue;
+    const refs = receiptTaskRefs(receipt);
+    const task = firstTaskForRefs(refs, byTaskRef);
+    const member = String(receipt?.member || receipt?.owner || receipt?.actor || taskOwner(task) || '').trim();
+    const taskValue = rowTask(refs, task);
+    const startedAt = receiptStartedAt(receipt, entry?.mtimeMs);
+    const common = baseRow({
+      member,
+      task: taskValue,
+      title: task?.title || receipt?.objective || '',
+      engine,
+      source: 'receipt',
+      at: startedAt,
+      nowMs,
+    });
+    if (isRunningReceipt(receipt)) {
+      const processRow = claimProcess(engine, receipt.pid, startedAt)
+        || claimMatchingProcess(engine, refs, task?.title || receipt?.objective || '');
+      const row = {
+        ...common,
+        pid: processRow?.pid || Number(receipt.pid) || null,
+        receipt: entry?.name || receipt?.receipt || null,
+      };
+      if (processRow) working.push(row);
+      else if (Number(receipt.pid) > 0 || nowMs - timestampMs(startedAt) > staleAfterMs) {
+        stale.push({ ...row, reason: 'run has no live process' });
+      } else {
+        waiting.push({ ...row, reason: 'run has not started a local process' });
+      }
+      if (taskValue) representedTasks.add(String(taskValue).toLowerCase());
+      continue;
+    }
+    if (isFinishedReceipt(receipt)) {
+      done.push({
+        ...common,
+        at: isoTimestamp(receiptFinishedAt(receipt, entry?.mtimeMs)),
+        age_seconds: ageSeconds(receiptFinishedAt(receipt, entry?.mtimeMs), nowMs),
+        run_status: receiptStatus(receipt) || 'finished',
+        result: finalResult(receipt),
+        receipt: entry?.name || receipt?.receipt || null,
+      });
+    }
+  }
+
+  for (const mission of missions) {
+    const refs = Array.isArray(mission?.task_ids) ? mission.task_ids.map(String) : [];
+    if (refs.some((ref) => representedTasks.has(ref.toLowerCase()))) continue;
+    const task = firstTaskForRefs(refs, byTaskRef);
+    const engine = normalizeEngine(mission?.runner || mission?.engine || mission?.executed_by);
+    const member = String(mission?.owner || mission?.member || taskOwner(task) || '').trim();
+    const at = mission?.last_tick_at || mission?.updated_at || mission?.created_at;
+    const common = baseRow({
+      member,
+      task: rowTask(refs, task),
+      title: task?.title || mission?.objective || mission?.name || '',
+      engine,
+      source: 'mission',
+      at,
+      nowMs,
+    });
+    const processRow = engine
+      ? claimProcess(engine, mission?.pid, at) || claimMatchingProcess(engine, refs, common.title)
+      : null;
+    if (processRow) working.push({ ...common, pid: processRow.pid, mission: mission?.id || null });
+    else if (nowMs - timestampMs(at) > staleAfterMs) stale.push({ ...common, reason: 'mission has no live process', mission: mission?.id || null });
+    else waiting.push({ ...common, reason: 'mission is waiting for a local process', mission: mission?.id || null });
+    for (const ref of refs) representedTasks.add(ref.toLowerCase());
+  }
+
+  for (const task of tasks) {
+    const ref = taskRef(task);
+    if (representedTasks.has(ref.toLowerCase())) continue;
+    const engine = normalizeEngine(task?.executed_by || task?.metadata?.executed_by || task?.metadata?.engine);
+    const at = taskActivity(task);
+    const common = baseRow({
+      member: taskOwner(task),
+      task: ref,
+      title: task?.title || '',
+      engine,
+      source: 'task',
+      at,
+      nowMs,
+    });
+    const processRow = claimProcess(engine, task?.pid || task?.metadata?.pid, at)
+      || claimMatchingProcess(engine, [ref], '');
+    if (processRow) working.push({ ...common, engine: processRow.engine, pid: processRow.pid });
+    else if (nowMs - timestampMs(at) > staleAfterMs) stale.push({ ...common, reason: 'claim is older than seven days with no live process' });
+    else waiting.push({ ...common, reason: 'claim has no live process yet' });
+  }
+
+  const unowned = processes
+    .filter((row) => !usedPids.has(row.pid))
+    .map((row) => ({
+      engine: row.engine,
+      pid: row.pid,
+      command: row.command,
+      started_at: row.started_at,
+      age_seconds: ageSeconds(row.started_at, nowMs),
+      reason: 'no matching claim, mission, or run receipt',
+    }));
+
+  const newestFirst = (left, right) => timestampMs(right.at || right.started_at) - timestampMs(left.at || left.started_at);
+  working.sort(newestFirst);
+  waiting.sort(newestFirst);
+  done.sort(newestFirst);
+  stale.sort(newestFirst);
+
+  return {
+    schema: 'atris.workforce_presence.v1',
+    generated_at: new Date(nowMs).toISOString(),
+    stale_after_seconds: Math.round(staleAfterMs / 1000),
+    totals: {
+      working: working.length,
+      waiting: waiting.length,
+      done: done.length,
+      stale: stale.length,
+      unowned: unowned.length,
+    },
+    working,
+    waiting,
+    done,
+    stale,
+    unowned,
+  };
+}
+
+function formatAge(seconds) {
+  if (seconds == null) return 'age unknown';
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+
+function rowSubject(row) {
+  const member = row.member || 'unassigned';
+  const task = row.task || row.title || 'local work';
+  return `${member}: ${row.engine || 'unknown engine'} on ${task}`;
+}
+
+function renderWorkforcePresence(presence) {
+  const lines = [];
+  const section = (name, rows, render, limit = rows.length) => {
+    lines.push(`${name}:`);
+    if (!rows.length) lines.push('  none');
+    else rows.slice(0, limit).forEach((row) => lines.push(`  ${render(row)}`));
+    if (rows.length > limit) lines.push(`  ${rows.length - limit} more; clear finished runs with atris who --clear`);
+  };
+  section('working', presence.working, (row) => `${rowSubject(row)} (${formatAge(row.age_seconds)}, pid ${row.pid || '?'})`);
+  section('waiting', presence.waiting, (row) => `${rowSubject(row)} (${formatAge(row.age_seconds)}), ${row.reason}`);
+  section('done', presence.done, (row) => `${rowSubject(row)} (${formatAge(row.age_seconds)}), ${row.run_status}: ${row.result}`, 10);
+  section('stale', presence.stale, (row) => `${rowSubject(row)} (${formatAge(row.age_seconds)}), ${row.reason}`);
+  section('unowned', presence.unowned, (row) => `${row.engine} pid ${row.pid} (${formatAge(row.age_seconds)}), ${row.reason}`);
+  const totals = presence.totals;
+  lines.push(`totals: ${totals.working} working, ${totals.waiting} waiting, ${totals.done} done, ${totals.stale} stale, ${totals.unowned} unowned`);
+  return lines.join('\n');
+}
+
+module.exports = {
+  buildWorkforcePresence,
+  isFinishedReceipt,
+  parsePsOutput,
+  receiptEngine,
+  renderWorkforcePresence,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.48.0",
+  "version": "3.48.1",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {