atris 3.15.56 → 3.16.0

package/commands/now.js

@@ -2,7 +2,10 @@ const fs = require('fs');
 const path = require('path');
 
 const NOW_PATH = path.join('atris', 'now.md');
+const TASK_EPISODES_PATH = path.join('.atris', 'state', 'task_episodes.jsonl');
+const CAREER_XP_RECEIPTS_PATH = path.join('.atris', 'state', 'career_xp_receipts.jsonl');
 const EXECUTABLE_TASK_STATUSES = new Set(['open', 'claimed']);
+const TASK_RECEIPT_EVENTS = new Set(['proof_ready', 'reviewed', 'completed']);
 
 function formatLocalDate(date = new Date()) {
   const year = String(date.getFullYear());
@@ -115,6 +118,87 @@ function countJournalCompletedReceipts(filePath) {
   return countMatches(filePath, /^-\s+\*\*C\d+:/gm);
 }
 
+function readJsonlRows(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  return fs.readFileSync(filePath, 'utf8')
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function localDateKey(value) {
+  if (!value) return null;
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) return null;
+  return formatLocalDate(date);
+}
+
+function normalizeRoot(value) {
+  if (!value) return null;
+  try {
+    return fs.realpathSync(value);
+  } catch {
+    return path.resolve(String(value));
+  }
+}
+
+function rowMatchesWorkspace(rowRoot, root) {
+  if (!rowRoot) return true;
+  return normalizeRoot(rowRoot) === normalizeRoot(root);
+}
+
+function taskReceiptProof(row) {
+  return String(
+    row?.proof
+    || row?.proof_ref
+    || row?.review?.proof
+    || row?.state?.metadata?.latest_agent_proof
+    || '',
+  ).trim();
+}
+
+function taskReceiptKey(row, fallback) {
+  const episodeId = row?.episode_id || row?.source_episode_id;
+  if (episodeId) return `episode:${episodeId}`;
+  if (row?.receipt_id) return `receipt:${row.receipt_id}`;
+  if (row?.task_id || row?.source_task_id) return `task:${row.task_id || row.source_task_id}:${fallback}`;
+  return `row:${fallback}`;
+}
+
+function countTaskReceiptsToday(root = process.cwd(), date = new Date()) {
+  const targetDay = formatLocalDate(date);
+  const stateDir = path.join(root, '.atris', 'state');
+  const seen = new Set();
+
+  for (const row of readJsonlRows(path.join(stateDir, 'task_episodes.jsonl'))) {
+    if (localDateKey(row?.created_at) !== targetDay) continue;
+    if (!rowMatchesWorkspace(row?.workspace_root, root)) continue;
+    if (!taskReceiptProof(row)) continue;
+    const eventType = String(row?.action?.event_type || '').toLowerCase();
+    if (eventType && !TASK_RECEIPT_EVENTS.has(eventType)) continue;
+    seen.add(taskReceiptKey(row, seen.size));
+  }
+
+  for (const row of readJsonlRows(path.join(stateDir, 'career_xp_receipts.jsonl'))) {
+    if (localDateKey(row?.accepted_at || row?.created_at || row?.ts) !== targetDay) continue;
+    if (!rowMatchesWorkspace(row?.workspace_root, root)) continue;
+    if (!taskReceiptProof(row)) continue;
+    const source = String(row?.source_type || row?.receipt_id || row?.source || '').toLowerCase();
+    if (!source.includes('task')) continue;
+    seen.add(taskReceiptKey(row, seen.size));
+  }
+
+  return seen.size;
+}
+
 function currentJournalPath(root = process.cwd()) {
   const now = new Date();
   const year = String(now.getFullYear());
@@ -129,7 +213,8 @@ function renderDefaultNow(root = process.cwd()) {
   const journalPath = currentJournalPath(root);
   const openTodoCount = countOpenWorkItems(root, todoPath);
   const inboxCount = countMatches(journalPath, /^-\s+\*\*I\d+:/gm);
-  const completedCount = countJournalCompletedReceipts(journalPath);
+  const taskReceiptCount = countTaskReceiptsToday(root);
+  const completedCount = taskReceiptCount || countJournalCompletedReceipts(journalPath);
   const generated = todayIso();
 
   return `# now
@@ -330,11 +415,14 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
 
 module.exports = {
   NOW_PATH,
+  TASK_EPISODES_PATH,
+  CAREER_XP_RECEIPTS_PATH,
   ensureNowFile,
   formatLocalDate,
   countJournalCompletedReceipts,
   countOpenWorkItems,
   countOpenTodoItems,
+  countTaskReceiptsToday,
   findChildWorkspaces,
   isGeneratedNowFile,
   nowAtris,

package/commands/radar.js

@@ -114,26 +114,19 @@ function loadTasks(root, deps) {
   if (!deps.exists(file)) return [];
   const payload = safeJson(deps.readFile(file, 'utf8'), {});
   const tasks = Array.isArray(payload.tasks) ? payload.tasks : [];
-  return tasks.map(task => {
-    const messages = Array.isArray(task.messages) ? task.messages : [];
-    const row = {
-      id: task.id,
-      display_id: task.display_id,
-      legacy_ref: task.legacy_ref,
-      title: task.title,
-      status: task.status,
-      tag: task.tag,
-      workspace_root: task.workspace_root,
-      claimed_by: task.claimed_by,
-      assigned_to: task.metadata?.assigned_to || task.assigned_to || null,
-      metadata: task.metadata || {},
-    };
-    Object.defineProperty(row, 'routing_text', {
-      enumerable: false,
-      value: messages.map(message => message && message.content).filter(Boolean).join(' '),
-    });
-    return row;
-  });
+  return tasks.map(task => ({
+    id: task.id,
+    display_id: task.display_id,
+    legacy_ref: task.legacy_ref,
+    title: task.title,
+    status: task.status,
+    tag: task.tag,
+    workspace_root: task.workspace_root,
+    claimed_by: task.claimed_by,
+    assigned_to: task.metadata?.assigned_to || task.assigned_to || null,
+    metadata: task.metadata || {},
+    messages: Array.isArray(task.messages) ? task.messages : [],
+  }));
 }
 
 function findTaskWorkspaceRoot(cwd, deps) {
@@ -172,7 +165,7 @@ function untaskedAction(agent, taskWorkspaceRoot, tasks) {
   if (reason === 'cwd unknown') return `inspect pid ${pid} cwd with lsof`;
   if (reason === 'no active task') return `cd ${shellQuote(taskWorkspaceRoot)} && atris task next --as ${actor}`;
   if (reason === 'empty task projection') return `cd ${shellQuote(taskWorkspaceRoot)} && atris task new "<small concrete title>" --tag ops`;
-  return `inspect ${agent.cwd || 'unknown cwd'} for missing Atris task plane or close pid ${pid} if idle`;
+  return `inspect ${agent.cwd || 'unknown cwd'} for missing Atris task plane or close pid ${pid} only with operator approval if idle`;
 }
 
 function readJsonFile(file, deps, fallback = null) {
@@ -340,8 +333,6 @@ function loadBusinessCollaboration(root, deps, team = {}) {
   const episodes = countJsonLines(path.join(root, '.atris', 'state', 'episodes.jsonl'), deps);
   const scorecards = countJsonLines(path.join(root, '.atris', 'state', 'scorecards.jsonl'), deps);
   const computerDirs = countDirectoryEntries(path.join(root, 'atris', 'computers'), deps, name => !name.startsWith('.'));
-  const runtimeComputer = runtime && (runtime.workspace_id || runtime.business_id || runtime.scope === 'local-business-computer') ? 1 : 0;
-  const computers = Math.max(computerDirs, runtimeComputer);
   const hasOnboarding = ingestPacks > 0 || starterBriefs > 0 || onePagers > 0;
   const hasProofLoop = events > 0 || episodes > 0 || scorecards > 0 || localReceipts > 0;
   const hasTeam = Number(team.total || 0) > 0;
@@ -370,7 +361,7 @@ function loadBusinessCollaboration(root, deps, team = {}) {
     } : null,
     onboarding: { packs: ingestPacks, starter_briefs: starterBriefs, first_loops: firstLoops, one_pagers: onePagers, reports },
     proof: { events, episodes, scorecards, receipts: localReceipts },
-    computers,
+    computers: computerDirs,
     team_members: Number(team.total || 0),
     active_goal_members: Number(team.active_goal_members || 0),
     share_ready: missing.length === 0,
@@ -418,15 +409,47 @@ function taskRef(task) {
   return task ? (task.display_id || task.legacy_ref || task.id || '-') : '-';
 }
 
-function taskForCwd(tasks, cwd, workspaceRoot = cwd) {
+function taskOwnerMatchesAgent(task, agent) {
+  const actor = String(agent?.agent || '').toLowerCase();
+  if (!actor) return false;
+  return [
+    task.assigned_to,
+    task.claimed_by,
+    task.metadata?.assigned_to,
+    task.metadata?.claimed_by,
+    task.metadata?.owner,
+  ]
+    .filter(Boolean)
+    .some(owner => String(owner).toLowerCase() === actor);
+}
+
+function taskForCwd(tasks, cwd, workspaceRoot = cwd, agent = null) {
   if (!cwd && !workspaceRoot) return null;
   const matchesWorkspace = task => !task.workspace_root || task.workspace_root === cwd || task.workspace_root === workspaceRoot;
-  return tasks.find(task => matchesWorkspace(task) && task.status === 'claimed')
-    || tasks.find(task => matchesWorkspace(task) && task.status === 'open')
-    || tasks.find(task => matchesWorkspace(task) && task.status === 'review')
+  const candidates = tasks.filter(matchesWorkspace);
+  const firstByStatus = status => {
+    const statusMatches = candidates.filter(task => task.status === status);
+    return statusMatches.find(task => taskOwnerMatchesAgent(task, agent)) || statusMatches[0] || null;
+  };
+  return firstByStatus('claimed')
+    || firstByStatus('open')
+    || firstByStatus('review')
     || null;
 }
 
+function taskBindingForProjection(task) {
+  if (!task) return { task_source: null, task_scope: null };
+  return {
+    task_source: 'repo_task_projection',
+    task_scope: 'repo',
+  };
+}
+
+function taskSourceLabel(sources = []) {
+  if (sources.includes('repo_task_projection')) return 'repo projection; verify ownership';
+  return sources.filter(Boolean).join(', ');
+}
+
 function ownerForTask(task) {
   if (!task) return '-';
   return task.assigned_to || task.claimed_by || task.metadata?.assigned_to || '-';
@@ -449,33 +472,21 @@ function taskSessionAction(agent, task, taskWorkspaceRoot) {
     : 'atris task reviews --limit 5';
   if (task.status === 'review') {
     if (task.metadata?.agent_certified) {
-      return `handoff complete for ${ref}; close pid ${pid} or claim fresh work as ${actor}`;
+      return `handoff complete for ${ref}; claim fresh work as ${actor} or close pid ${pid} only with operator approval`;
     }
     return `review or hand off ${ref}: ${reviewCommand}`;
   }
-  if (ownerActionRequired(task)) return `owner-gated ${ref}; close pid ${pid} or wait for owner action`;
+  if (ownerActionRequired(task)) return `owner-gated ${ref}; wait for owner action, do not start duplicate work; close pid ${pid} only with operator approval`;
   return null;
 }
 
-function summarize(tasks, missions, worktrees, agents) {
-  const count = (rows, pred) => rows.filter(pred).length;
-  return {
-    agents: { total: agents.length, active: count(agents, a => a.status === 'active'), stopped: count(agents, a => a.status !== 'active') },
-    tasks: {
-      open: count(tasks, t => t.status === 'open'),
-      claimed: count(tasks, t => t.status === 'claimed'),
-      review: count(tasks, t => t.status === 'review'),
-      certifiedReview: count(tasks, t => t.status === 'review' && t.metadata && t.metadata.agent_certified),
-    },
-    missions: { running: count(missions, m => m.status === 'running'), stale: count(missions, m => m.stale) },
-    worktrees: { total: worktrees.length, dirty: count(worktrees, w => Number(w.dirty) > 0) },
-  };
-}
-
 function ownerActionRequired(task) {
   const metadata = task?.metadata || {};
   if (metadata.owner_action_required === true || metadata.agent_executable === false) return true;
   if (String(metadata.agent_executable || '').toLowerCase() === 'false') return true;
+  const recentMessages = Array.isArray(task?.messages)
+    ? task.messages.slice(-8).map(message => message?.content || message?.payload?.content || '')
+    : [];
   const text = [
     task?.title,
     task?.tag,
@@ -485,12 +496,32 @@ function ownerActionRequired(task) {
     metadata.latest_agent_proof,
     metadata.latest_agent_lesson,
     task?.routing_text,
+    ...recentMessages,
   ].filter(Boolean).join(' ').toLowerCase();
   if (text.includes('owner_action_required') || text.includes('agent_executable=false')) return true;
   if (text.includes('owner-only') || text.includes('owner only') || text.includes('not agent-executable')) return true;
+  const productionGateEligible = !['radar', 'task-plane', 'review'].includes(String(task?.tag || '').toLowerCase());
+  if (productionGateEligible && (text.includes('human/production gated') || text.includes('production execution proof is still missing'))) return true;
+  if (productionGateEligible && text.includes('remaining blocker') && text.includes('deploy receipt') && text.includes('live canary')) return true;
+  if (productionGateEligible && text.includes('human approval required') && (text.includes('production deploy') || text.includes('feedback mutation'))) return true;
   return text.includes('owner') && text.includes('billing') && (text.includes('spending limit') || text.includes('failed payments'));
 }
 
+function summarize(tasks, missions, worktrees, agents) {
+  const count = (rows, pred) => rows.filter(pred).length;
+  return {
+    agents: { total: agents.length, active: count(agents, a => a.status === 'active'), stopped: count(agents, a => a.status !== 'active') },
+    tasks: {
+      open: count(tasks, t => t.status === 'open'),
+      claimed: count(tasks, t => t.status === 'claimed'),
+      review: count(tasks, t => t.status === 'review'),
+      certifiedReview: count(tasks, t => t.status === 'review' && t.metadata && t.metadata.agent_certified),
+    },
+    missions: { running: count(missions, m => m.status === 'running'), stale: count(missions, m => m.stale) },
+    worktrees: { total: worktrees.length, dirty: count(worktrees, w => Number(w.dirty) > 0) },
+  };
+}
+
 function nextAction(tasks, missions, worktrees, agents, os = {}) {
   const activeTasks = tasks.filter(t => t.status === 'claimed' || t.status === 'open');
   const activeTask = activeTasks.find(t => !ownerActionRequired(t));
@@ -529,14 +560,16 @@ function collectRadar(options = {}) {
   const agents = collectAgents(deps).map(agent => {
     const taskWorkspaceRoot = findTaskWorkspaceRoot(agent.cwd, deps);
     const agentTasks = taskWorkspaceRoot ? loadTasksCached(taskWorkspaceRoot, deps, taskCache) : [];
-    const task = taskForCwd(agentTasks, agent.cwd, taskWorkspaceRoot);
+    const task = taskForCwd(agentTasks, agent.cwd, taskWorkspaceRoot, agent);
     const taskReason = task ? taskSessionReason(task) : untaskedReason(agent, taskWorkspaceRoot, agentTasks);
+    const taskBinding = taskBindingForProjection(task);
     return {
       ...agent,
       task: taskRef(task),
       task_status: task?.status || null,
       owner: ownerForTask(task),
       task_workspace: taskWorkspaceRoot ? repoLabel(taskWorkspaceRoot) : null,
+      ...taskBinding,
       task_reason: taskReason,
       task_action: task ? taskSessionAction(agent, task, taskWorkspaceRoot) : untaskedAction(agent, taskWorkspaceRoot, agentTasks),
     };
@@ -646,19 +679,73 @@ function sortedAgents(agents = []) {
   });
 }
 
+function executableAgentLanes(agents = []) {
+  return sortedAgents(agents).filter(agent => {
+    if (agent.status !== 'active') return false;
+    if (!agent.task || agent.task === '-') return false;
+    if (!['claimed', 'open'].includes(agent.task_status)) return false;
+    return !agent.task_reason;
+  });
+}
+
+function formatExecutableLane(agent) {
+  const repo = agent.repo || agent.cwd || 'unknown repo';
+  const actor = agent.agent || 'agent';
+  return `continue ${agent.task} in ${repo} as ${actor}`;
+}
+
+function certifiedReviewLanes(agents = []) {
+  return sortedAgents(agents).filter(agent => {
+    if (agent.status !== 'active') return false;
+    if (!agent.task || agent.task === '-') return false;
+    if (agent.task_status !== 'review') return false;
+    return agent.task_reason === 'certified review';
+  });
+}
+
+function formatReviewCheckpoint(agent) {
+  const repo = agent.repo || agent.cwd || 'unknown repo';
+  return `accept/revise ${agent.task} in ${repo}`;
+}
+
 function agentProcessNextAction(agents = [], fallback = 'no obvious process action') {
   const stopped = agents.filter(agent => agent.status !== 'active').length;
   if (stopped > 0) return `inspect ${stopped} stopped agent session${stopped === 1 ? '' : 's'}`;
   const ownerGated = agents.filter(agent => agent.task_reason === 'owner action required');
   if (ownerGated.length > 0) {
     const tasks = [...new Set(ownerGated.map(agent => agent.task).filter(Boolean))].slice(0, 3).join(', ');
-    return `owner gate blocks ${ownerGated.length} session${ownerGated.length === 1 ? '' : 's'}${tasks ? ` on ${tasks}` : ''}; wait for owner action or close idle sessions`;
+    const projectionBound = ownerGated.some(agent => agent.task_source === 'repo_task_projection');
+    const executable = executableAgentLanes(agents)[0];
+    const reviewCheckpoint = executable ? null : certifiedReviewLanes(agents)[0];
+    const ownerGateAction = executable
+      ? `wait for owner action; executable lane: ${formatExecutableLane(executable)}; avoid duplicate work, close only with operator approval`
+      : reviewCheckpoint
+        ? `wait for owner action; review checkpoint: ${formatReviewCheckpoint(reviewCheckpoint)}; avoid duplicate work, close only with operator approval`
+      : 'wait for owner action, avoid duplicate work, close only with operator approval';
+    if (projectionBound) {
+      return `owner-gated repo projection covers ${ownerGated.length} session${ownerGated.length === 1 ? '' : 's'}${tasks ? ` on ${tasks}` : ''}; verify ownership, ${ownerGateAction}`;
+    }
+    return `owner gate blocks ${ownerGated.length} session${ownerGated.length === 1 ? '' : 's'}${tasks ? ` on ${tasks}` : ''}; ${ownerGateAction}`;
   }
   const taskLoad = summarizeTaskLoad(agents);
+  const activePileup = taskLoad.find(row => row.sessions > 1 && !row.status.split(/,\s*/).includes('review'));
+  if (activePileup) {
+    const source = taskSourceLabel(activePileup.task_sources);
+    const sourceHint = source ? `; ${source}` : '';
+    return `inspect ${activePileup.sessions} sessions on ${activePileup.task} (${activePileup.cpu.toFixed(1)}% CPU${sourceHint})`;
+  }
   const reviewBound = taskLoad.find(row => row.status.split(/,\s*/).includes('review'));
-  if (reviewBound) return `close or hand off ${reviewBound.sessions} session${reviewBound.sessions === 1 ? '' : 's'} still bound to review task ${reviewBound.task}`;
+  if (reviewBound) {
+    const source = taskSourceLabel(reviewBound.task_sources);
+    const sourceHint = source ? `; ${source}` : '';
+    return `close or hand off ${reviewBound.sessions} session${reviewBound.sessions === 1 ? '' : 's'} still bound to review task ${reviewBound.task}${sourceHint}`;
+  }
   const pileup = taskLoad.find(row => row.sessions > 1);
-  if (pileup) return `inspect ${pileup.sessions} sessions on ${pileup.task} (${pileup.cpu.toFixed(1)}% CPU)`;
+  if (pileup) {
+    const source = taskSourceLabel(pileup.task_sources);
+    const sourceHint = source ? `; ${source}` : '';
+    return `inspect ${pileup.sessions} sessions on ${pileup.task} (${pileup.cpu.toFixed(1)}% CPU${sourceHint})`;
+  }
   const untasked = agents.filter(agent => !agent.task || agent.task === '-').length;
   if (untasked > 0) {
     const reasons = summarizeUntaskedReasons(agents);
@@ -696,6 +783,8 @@ function summarizeTaskLoad(agents = []) {
         statuses: new Set(),
         owners: new Set(),
         repos: new Set(),
+        task_sources: new Set(),
+        task_scopes: new Set(),
         pids: [],
       });
     }
@@ -707,6 +796,8 @@ function summarizeTaskLoad(agents = []) {
     if (agent.task_status) row.statuses.add(agent.task_status);
     if (agent.owner && agent.owner !== '-') row.owners.add(agent.owner);
     if (agent.repo) row.repos.add(agent.repo);
+    if (agent.task_source) row.task_sources.add(agent.task_source);
+    if (agent.task_scope) row.task_scopes.add(agent.task_scope);
     if (agent.pid) row.pids.push(agent.pid);
   }
   return [...byTask.values()]
@@ -721,6 +812,8 @@ function summarizeTaskLoad(agents = []) {
         status: statuses.join(', ') || '-',
         owners: [...row.owners].sort(),
         repos: [...row.repos].sort(),
+        task_sources: [...row.task_sources].sort(),
+        task_scopes: [...row.task_scopes].sort(),
         pids: row.pids.sort((a, b) => number(a) - number(b)),
         attention: row.sessions > 1 || statuses.includes('review'),
       };
@@ -753,6 +846,26 @@ function agentTopPayload(data) {
   };
 }
 
+function representativeAgentsByTask(agents = [], limit = 8) {
+  const selected = [];
+  const selectedRows = new Set();
+  const seenTasks = new Set();
+  for (const agent of agents) {
+    const task = agent.task || '-';
+    if (seenTasks.has(task)) continue;
+    seenTasks.add(task);
+    selected.push(agent);
+    selectedRows.add(agent);
+    if (selected.length >= limit) return selected;
+  }
+  for (const agent of agents) {
+    if (selected.length >= limit) break;
+    if (selectedRows.has(agent)) continue;
+    selected.push(agent);
+  }
+  return selected;
+}
+
 function renderAgentTop(data) {
   const payload = agentTopPayload(data);
   const lines = [];
@@ -760,6 +873,9 @@ function renderAgentTop(data) {
   lines.push('');
   lines.push(`Agents: ${payload.summary.active}/${payload.summary.total} active; ${payload.summary.untasked} untasked; CPU ${payload.summary.cpu.toFixed(1)}%; MEM ${payload.summary.mem.toFixed(1)}%`);
   lines.push(`Next: ${payload.next_action}`);
+  if (payload.agents.some(agent => agent.task_source === 'repo_task_projection')) {
+    lines.push('Task binding: repo projection; verify ownership before assuming every session owns the displayed task.');
+  }
   lines.push('');
   lines.push(`${truncate('PID', 7)} ${truncate('AGENT', 8)} ${truncate('CPU', 6)} ${truncate('MEM', 6)} ${truncate('REPO', 24)} ${truncate('BRANCH', 16)} ${truncate('TASK', 10)} ${truncate('STATE', 8)}`);
   for (const agent of payload.agents.slice(0, 32)) {
@@ -774,19 +890,26 @@ function renderAgentTop(data) {
       lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'}: ${agent.task_reason || 'unmapped'} -> ${agent.task_action || 'inspect session'}`);
     }
   }
-  const ownerGatedAgents = payload.agents.filter(row => row.task_reason === 'owner action required').slice(0, 8);
+  const ownerGatedAll = payload.agents.filter(row => row.task_reason === 'owner action required');
+  const ownerGatedAgents = representativeAgentsByTask(ownerGatedAll, 8);
   if (ownerGatedAgents.length) {
     lines.push('');
-    lines.push(`Owner-gated: ${ownerGatedAgents.length} session${ownerGatedAgents.length === 1 ? '' : 's'} waiting on owner-only tasks.`);
+    const shown = ownerGatedAll.length > ownerGatedAgents.length ? `; showing ${ownerGatedAgents.length}` : '';
+    const projectionBound = ownerGatedAll.some(agent => agent.task_source === 'repo_task_projection');
+    const label = projectionBound ? 'Owner-gated projection' : 'Owner-gated';
+    const actionText = projectionBound ? 'verify ownership and wait on human/owner action' : 'waiting on human/owner action';
+    lines.push(`${label}: ${ownerGatedAll.length} session${ownerGatedAll.length === 1 ? '' : 's'} ${actionText}${shown}; do not start duplicate work.`);
     for (const agent of ownerGatedAgents) {
       lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'} ${agent.task}: ${agent.task_action || 'wait for owner action'}`);
     }
   }
-  const reviewBoundAgents = payload.agents.filter(row => row.task_status === 'review').slice(0, 8);
-  if (reviewBoundAgents.length) {
+  const reviewAll = payload.agents.filter(row => row.task_reason === 'certified review' || row.task_reason === 'review task');
+  const reviewAgents = reviewAll.slice(0, 8);
+  if (reviewAgents.length) {
     lines.push('');
-    lines.push(`Review-bound: ${reviewBoundAgents.length} session${reviewBoundAgents.length === 1 ? '' : 's'} still tied to Review tasks.`);
-    for (const agent of reviewBoundAgents) {
+    const shown = reviewAll.length > reviewAgents.length ? `; showing ${reviewAgents.length}` : '';
+    lines.push(`Review-bound: ${reviewAll.length} session${reviewAll.length === 1 ? '' : 's'} should hand off or claim fresh work${shown}.`);
+    for (const agent of reviewAgents) {
       lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'} ${agent.task}: ${agent.task_reason || 'review'} -> ${agent.task_action || 'close or hand off session'}`);
     }
   }
@@ -796,7 +919,9 @@ function renderAgentTop(data) {
     lines.push(`Task load: ${payload.summary.task_pileups} pileup${payload.summary.task_pileups === 1 ? '' : 's'}, ${payload.summary.review_bound_tasks} review-bound task${payload.summary.review_bound_tasks === 1 ? '' : 's'}.`);
     for (const row of taskLoadRows) {
       const repoText = row.repos.slice(0, 3).join(', ') || '-';
-      lines.push(`- ${row.task}: ${row.sessions} sessions, ${row.cpu.toFixed(1)}% CPU, ${row.status}, ${repoText}`);
+      const source = taskSourceLabel(row.task_sources);
+      const sourceText = source ? `, ${source}` : '';
+      lines.push(`- ${row.task}: ${row.sessions} sessions, ${row.cpu.toFixed(1)}% CPU, ${row.status}, ${repoText}${sourceText}`);
     }
   }
   return lines.join('\n');

package/commands/skill.js

@@ -88,6 +88,39 @@ function findAllSkills(skillsDir) {
   return skills;
 }
 
+function localSkillsDir() {
+  return path.join(process.cwd(), 'atris', 'skills');
+}
+
+function bundledSkillsDir() {
+  return path.join(__dirname, '..', 'atris', 'skills');
+}
+
+function readableSkillRoots() {
+  const roots = [localSkillsDir(), bundledSkillsDir()];
+  const seen = new Set();
+  return roots.filter((root) => {
+    if (!root || !fs.existsSync(root)) return false;
+    const real = fs.realpathSync(root);
+    if (seen.has(real)) return false;
+    seen.add(real);
+    return true;
+  });
+}
+
+function findReadableSkills() {
+  const seen = new Set();
+  const skills = [];
+  for (const root of readableSkillRoots()) {
+    for (const skill of findAllSkills(root)) {
+      if (seen.has(skill.folder)) continue;
+      seen.add(skill.folder);
+      skills.push(skill);
+    }
+  }
+  return skills;
+}
+
 // --- Audit Checks ---
 
 function runAuditChecks(skill) {
@@ -355,11 +388,10 @@ function generateTags(folderName, description) {
 // --- Subcommand Handlers ---
 
 function skillList() {
-  const skillsDir = path.join(process.cwd(), 'atris', 'skills');
-  const skills = findAllSkills(skillsDir);
+  const skills = findReadableSkills();
 
   if (skills.length === 0) {
-    console.log('No skills found in atris/skills/. Run "atris init" first.');
+    console.log('No skills found in local or bundled Atris skill roots.');
     return;
   }
 
@@ -396,15 +428,14 @@ function skillList() {
 }
 
 function skillAudit(name) {
-  const skillsDir = path.join(process.cwd(), 'atris', 'skills');
-  const allSkills = findAllSkills(skillsDir);
+  const allSkills = findReadableSkills();
 
   const targets = name === '--all'
     ? allSkills
     : allSkills.filter(s => s.folder === name || s.leafFolder === name);
 
   if (targets.length === 0) {
-    console.error(`Skill "${name}" not found. Run "atris skill list" to see available skills.`);
+    console.error(`Skill "${name}" not found. Run "atris skill list" to see available local and bundled skills.`);
     process.exit(1);
   }
 

package/commands/soul.js

@@ -26,10 +26,6 @@ function readFile(filePath) {
   try { return fs.readFileSync(filePath, 'utf8'); } catch { return null; }
 }
 
-function readJson(filePath) {
-  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return null; }
-}
-
 function countFiles(dir) {
   try { return fs.readdirSync(dir, { recursive: true }).filter(f => !f.startsWith('.')).length; } catch { return 0; }
 }