atris 3.15.57 → 3.16.1

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/recap.js

@@ -0,0 +1,203 @@
+const fs = require('fs');
+const path = require('path');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_DAYS = 7;
+
+function loadTaskDb() {
+  try {
+    return require('../lib/task-db');
+  } catch (e) {
+    return null;
+  }
+}
+
+function readProjection(root) {
+  const projectionPath = path.join(root, '.atris', 'state', 'tasks.projection.json');
+  if (!fs.existsSync(projectionPath)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(projectionPath, 'utf8'));
+    return Array.isArray(parsed.tasks) ? parsed.tasks : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function loadTasks(root) {
+  const taskDb = loadTaskDb();
+  if (taskDb) {
+    try {
+      const db = taskDb.open();
+      const ws = taskDb.workspaceRoot(root);
+      const rows = taskDb.listTasks(db, { workspaceRoot: ws });
+      const refs = taskDb.taskDisplayRefMap(rows);
+      return rows.map(row => ({ ...row, display_id: refs.get(row.id) || row.id.slice(-6) }));
+    } catch (e) {
+      // fall through to projection
+    }
+  }
+  return readProjection(root);
+}
+
+function taskProof(task) {
+  const meta = task.metadata || {};
+  const proof = String(meta.latest_agent_proof || '').trim();
+  if (proof) return proof;
+  if (meta.agent_certified === true) return 'verified by repeated agent review';
+  return null;
+}
+
+function shortProof(proof, width = 70) {
+  if (!proof) return null;
+  const flat = proof.replace(/\s+/g, ' ').trim();
+  return flat.length <= width ? flat : `${flat.slice(0, width - 1)}…`;
+}
+
+function shortTitle(title, width = 64) {
+  const flat = String(title || '').replace(/\s+/g, ' ').trim();
+  return flat.length <= width ? flat : `${flat.slice(0, width - 1)}…`;
+}
+
+function buildRecapData(root = process.cwd(), { days = DEFAULT_DAYS } = {}) {
+  const windowDays = Number.isFinite(Number(days)) && Number(days) > 0 ? Number(days) : DEFAULT_DAYS;
+  const tasks = loadTasks(root);
+  if (!tasks || tasks.length === 0) return { empty: true, days: windowDays, workspace: path.basename(root) };
+
+  const cutoff = Date.now() - windowDays * DAY_MS;
+  const pick = t => ({
+    id: t.display_id || t.id,
+    title: String(t.title || '').trim(),
+    proof: taskProof(t),
+    owner: t.claimed_by || (t.metadata && t.metadata.assigned_to) || null,
+    done_at: t.done_at || null,
+  });
+
+  const shipped = tasks
+    .filter(t => t.status === 'done' && Number(t.done_at || 0) >= cutoff)
+    .sort((a, b) => Number(b.done_at || 0) - Number(a.done_at || 0))
+    .map(pick);
+  const waiting = tasks
+    .filter(t => t.status === 'review')
+    .sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0))
+    .map(pick);
+  const inProgress = tasks
+    .filter(t => t.status === 'open' || t.status === 'claimed')
+    .map(pick);
+
+  const withProof = [...shipped, ...waiting].filter(t => t.proof).length;
+  return {
+    empty: false,
+    days: windowDays,
+    workspace: path.basename(root),
+    shipped,
+    waiting,
+    inProgress,
+    proof_attached: withProof,
+    proof_total: shipped.length + waiting.length,
+  };
+}
+
+function renderRecap(data) {
+  if (data.empty) {
+    return [
+      `RECAP — ${data.workspace}`,
+      '',
+      'No task history yet.',
+      'Run "atris init", then let an agent work — every finished task lands here with proof.',
+    ].join('\n');
+  }
+  const lines = [];
+  lines.push(`RECAP — ${data.workspace} — last ${data.days} day${data.days === 1 ? '' : 's'}`);
+  lines.push('');
+  const headline = [];
+  if (data.shipped.length) headline.push(`${data.shipped.length} change${data.shipped.length === 1 ? '' : 's'} shipped`);
+  if (data.waiting.length) headline.push(`${data.waiting.length} finished and waiting for your sign-off`);
+  if (data.inProgress.length) headline.push(`${data.inProgress.length} in progress`);
+  lines.push(headline.length ? `Your AI team: ${headline.join(' · ')}.` : 'Quiet window — no movement in this period.');
+  lines.push('Every finished line below carries proof: the commands run and their results.');
+
+  if (data.shipped.length) {
+    lines.push('');
+    lines.push(`SHIPPED (accepted by a human) — ${data.shipped.length}`);
+    for (const t of data.shipped.slice(0, 12)) {
+      lines.push(`  ${t.id}  ${shortTitle(t.title)}`);
+      if (t.proof) lines.push(`          proof: ${shortProof(t.proof)}`);
+    }
+    if (data.shipped.length > 12) lines.push(`  … and ${data.shipped.length - 12} more, all with proof on file`);
+  }
+
+  if (data.waiting.length) {
+    lines.push('');
+    lines.push(`FINISHED, WAITING FOR YOUR SIGN-OFF — ${data.waiting.length}`);
+    for (const t of data.waiting.slice(0, 10)) {
+      lines.push(`  ${t.id}  ${shortTitle(t.title)}`);
+    }
+    if (data.waiting.length > 10) lines.push(`  … and ${data.waiting.length - 10} more`);
+    lines.push('  approve or send back: atris task reviews');
+  }
+
+  if (data.inProgress.length) {
+    lines.push('');
+    lines.push(`IN PROGRESS — ${data.inProgress.length}`);
+    for (const t of data.inProgress) {
+      lines.push(`  ${t.id}  ${shortTitle(t.title)}${t.owner ? `  @${t.owner}` : ''}`);
+    }
+  }
+
+  lines.push('');
+  lines.push(`Proof attached: ${data.proof_attached}/${data.proof_total} finished items.`);
+  lines.push('Paste-ready summary for Slack or email: atris recap --share');
+  return lines.join('\n');
+}
+
+function renderShare(data) {
+  if (data.empty) return `Nothing to share yet on ${data.workspace} — no finished tasks on record.`;
+  const lines = [];
+  lines.push(`What the AI team did on ${data.workspace} in the last ${data.days} day${data.days === 1 ? '' : 's'}:`);
+  lines.push('');
+  if (data.shipped.length) lines.push(`- ${data.shipped.length} change${data.shipped.length === 1 ? '' : 's'} shipped, each verified before a human accepted it`);
+  if (data.waiting.length) lines.push(`- ${data.waiting.length} more finished with proof attached, waiting for human sign-off`);
+  if (data.inProgress.length) lines.push(`- ${data.inProgress.length} task${data.inProgress.length === 1 ? '' : 's'} in progress`);
+  const highlights = [...data.shipped, ...data.waiting].filter(t => t.proof).slice(0, 5);
+  if (highlights.length) {
+    lines.push('');
+    lines.push('Highlights:');
+    for (const t of highlights) {
+      lines.push(`- ${shortTitle(t.title, 80)} (proof: ${shortProof(t.proof, 60)})`);
+    }
+  }
+  lines.push('');
+  lines.push('Every item above is backed by a receipt — the exact commands run and their results — not a status update someone typed.');
+  return lines.join('\n');
+}
+
+function printRecapHelp() {
+  console.log(`
+atris recap - what your AI team actually did, in plain English
+
+  atris recap              Last 7 days: shipped, waiting on you, in progress
+  atris recap --days 30    Widen the window
+  atris recap --share      Paste-ready summary for Slack, email, or a customer
+  atris recap --json       Structured output for agents and dashboards
+
+Reads the workspace task records and their proof. No jargon, no guesses:
+if it is listed as finished, the receipt is on file.
+`);
+}
+
+function recapAtris(args = []) {
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    printRecapHelp();
+    return;
+  }
+  const daysIdx = args.indexOf('--days');
+  const days = daysIdx !== -1 ? Number(args[daysIdx + 1]) : DEFAULT_DAYS;
+  const data = buildRecapData(process.cwd(), { days });
+  if (args.includes('--json')) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(args.includes('--share') ? renderShare(data) : renderRecap(data));
+}
+
+module.exports = { recapAtris, buildRecapData, renderRecap, renderShare };

package/commands/skill.js

@@ -183,8 +183,12 @@ function runAuditChecks(skill) {
   });
 
   // 7. no XML tags in content (skip placeholders like <name>, <keyword>, code blocks)
-  const xmlMatches = skill.content.match(/<[a-zA-Z][^>]*>/g) || [];
-  const placeholders = /^<(name|keyword|placeholder|value|type|path|file|dir|id|url|tag|description|your-|user-|project-|skill-)/i;
+  const proseContent = skill.content
+    .replace(/```[\s\S]*?```/g, '')   // fenced code blocks
+    .replace(/`[^`\n]*`/g, '');        // inline code spans
+  const xmlMatches = proseContent.match(/<[a-zA-Z][^>]*>/g) || [];
+  // Single-letter tags like <X>/<N> are prose placeholders, not real XML.
+  const placeholders = /^<(name|keyword|placeholder|value|type|path|file|dir|id|url|tag|description|your-|user-|project-|skill-|[a-zA-Z]>)/i;
   const realXml = xmlMatches.filter(t =>
     !t.startsWith('<!--') && !t.startsWith('<!') && !placeholders.test(t)
   );

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; }
 }