atris 3.16.0 → 3.16.1

package/commands/probe.js

@@ -0,0 +1,366 @@
+// atris probe — chat-lane probe (TRR-22): one REAL /atris2/turn over the full
+// tool relay, exactly as the surfaces run it. Port of terrace's
+// atris/bin/relay-probe and atris/bin/calendar-probe — keep the op tables in
+// lockstep across iOS (votd/GMModeAPI.swift Atris2ToolRelay), web
+// (atrisos-web orbToolRelay.ts), Obelisk (atris2LocalFileOp.cjs), and the
+// terrace probes.
+//
+// Contract: the turn body sends `local_executor: true` plus a `workspace_path`
+// LABEL (/workspace/personal or /workspace/business-{id}). The backend relays
+// `local_file_op` / `local_atris_cli_op` calls down the SSE stream; we execute
+// each against the computer via POST /ai-computer/terminal and POST the result
+// to /atris2/turn/tool-result. Label-absolute paths are rewritten
+// root-relative (the runner's /bash cwd is the workspace ROOT).
+//
+// PASS = >=1 relayed op (with --calendar: >=1 calendar cli op) AND a non-empty
+// final answer with no dead-end marker; otherwise prints the marker in the
+// receipt line and exits 1 — a FAIL naming the dead-end is the instrument
+// working. The receipt line is journal-ready.
+//
+// Usage:
+//   atris probe                                # personal lane, file question
+//   atris probe --calendar                     # calendar question (cli-op lane)
+//   atris probe --business <id> [--model atris:pro]
+//   atris probe --member-slug relay            # turn runs AS the member
+//   atris probe --message "..."                # custom question
+
+const https = require('https');
+const http = require('http');
+const { getApiBaseUrl } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+
+// G2's honest blocked message (tool_policy_bench.MAX_TURNS_EXHAUSTED_MESSAGE)
+// starts with this — an answer that is only this marker is a dead-end.
+const MAX_TURNS_MARKER = 'i ran out of tool budget for this turn';
+
+function workspaceLabel(businessId) {
+  return businessId ? `/workspace/business-${businessId}` : '/workspace/personal';
+}
+
+function shq(value) {
+  return "'" + String(value).replace(/'/g, "'\\''") + "'";
+}
+
+// --- Port of Atris2ToolRelay path normalization (lockstep) ---
+
+function normalizePath(raw, label) {
+  const l = label.replace(/\/$/, '');
+  if (!l) return raw;
+  if (raw === l || raw === l + '/') return '.';
+  if (raw.startsWith(l + '/')) return raw.slice(l.length + 1) || '.';
+  return raw;
+}
+
+function normalizeBash(cmd, label) {
+  const l = label.replace(/\/$/, '');
+  if (!l) return cmd;
+  return cmd.split(l + '/').join('').split(l).join('.');
+}
+
+// Probe is read-only: no write/edit file ops.
+function fileOpCommand(args, label) {
+  const op = String(args.type || '').toLowerCase();
+  const raw = normalizePath(String(args.path || '') || '.', label);
+  if (raw.split('/').includes('..')) return null;
+  const p = shq(raw);
+  if (op === 'bash') return `( ${normalizeBash(String(args.command || '') || 'true', label)} )`;
+  if (op === 'list') return `find ${p} -maxdepth 3 -not -path '*/node_modules/*' -not -path '*/.git/*' | head -200`;
+  if (op === 'search') {
+    const q = shq(String(args.query || args.pattern || ''));
+    return `grep -rn -m 50 ${q} ${p} 2>/dev/null | head -50`;
+  }
+  if (op === 'read') return `{ [ -d ${p} ] && ls -p ${p} | head -200 || head -c 12000 ${p}; }`;
+  return null;
+}
+
+// Port of Atris2ToolRelay.atrisCLICommand (GMModeAPI.swift) — op → `atris …`.
+const SIMPLE_CLI_OPS = {
+  status: ['atris.md'],
+  integrations_status: ['integrations'],
+  calendar_today: ['calendar', 'today'],
+  calendar_yesterday: ['calendar', 'yesterday'],
+  calendar_week: ['calendar', 'week'],
+  gmail_inbox: ['gmail', 'inbox'],
+  slack_channels: ['slack', 'channels'],
+  slack_dms: ['slack', 'dms'],
+  task_status: ['task', 'status', '--json'],
+  task_list: ['task', 'list', '--json'],
+  skill_list: ['skill', 'list'],
+  member_list: ['member', 'list'],
+  mission_status: ['mission', 'status', '--json'],
+};
+
+function atrisCliCommand(args) {
+  const op = String(args.type || '').toLowerCase();
+  let argv = SIMPLE_CLI_OPS[op] || null;
+  if (!argv) {
+    if (op === 'task_show') {
+      const taskId = String(args.task_id || '');
+      if (taskId) argv = ['task', 'show', taskId, '--json'];
+    } else if (op === 'member_status') {
+      const member = String(args.member || '');
+      if (member) argv = ['member', 'status', member, '--json'];
+    } else if (op === 'calendar_date') {
+      const date = String(args.date || '');
+      if (/^\d{4}-\d{2}-\d{2}$/.test(date)) argv = ['calendar', 'date', date];
+    } else if (op === 'slack_messages') {
+      const channel = String(args.channel || '');
+      if (channel) argv = ['slack', 'messages', channel, '--limit', '20'];
+    } else if (op === 'slack_search') {
+      const query = String(args.query || '');
+      if (query) argv = ['slack', 'search', query, '--limit', '20'];
+    }
+  }
+  if (!argv) return null;
+  return 'atris ' + argv.map(shq).join(' ');
+}
+
+function atrisCliResult(command, term) {
+  const code = term.exit_code || 0;
+  const out = {
+    schema: 'atris.local_cli_result.v1',
+    status: code === 0 ? 'ok' : 'error',
+    command,
+    stdout: String(term.stdout || '').slice(0, 12000),
+    exit_code: code,
+  };
+  if (code !== 0) out.error = String(term.stderr || term.stdout || 'command failed').slice(0, 2000);
+  return out;
+}
+
+// --- HTTP helpers (Bearer auth against the prod API, like the terrace probes) ---
+
+function postJson(urlString, token, payload, timeoutMs) {
+  const url = new URL(urlString);
+  const transport = url.protocol === 'https:' ? https : http;
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify(payload);
+    const req = transport.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        Authorization: `Bearer ${token}`,
+      },
+      timeout: timeoutMs,
+    }, (res) => {
+      let data = '';
+      res.on('data', (c) => data += c);
+      res.on('end', () => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
+          return;
+        }
+        try { resolve(data ? JSON.parse(data) : {}); } catch (e) { resolve({}); }
+      });
+    });
+    req.on('timeout', () => { req.destroy(new Error('request timeout')); });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function runTerminal(base, token, command, businessId) {
+  const body = { command, timeout: 60 };
+  if (businessId) body.business_id = businessId;
+  return postJson(`${base}/ai-computer/terminal`, token, body, 80000);
+}
+
+function parseArgs(argv) {
+  const a = { business: null, model: 'atris:fast', memberId: null, memberSlug: null, calendar: false, message: null };
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i];
+    if (flag === '--business') a.business = argv[++i] || null;
+    else if (flag === '--model') a.model = argv[++i] || a.model;
+    else if (flag === '--member-id') a.memberId = argv[++i] || null;
+    else if (flag === '--member-slug') a.memberSlug = argv[++i] || null;
+    else if (flag === '--calendar') a.calendar = true;
+    else if (flag === '--message') a.message = argv[++i] || null;
+    else if (flag === '--help' || flag === '-h') {
+      console.log('Usage: atris probe [--calendar] [--business <id>] [--model atris:fast] [--member-slug <slug>] [--member-id <id>] [--message "..."]');
+      process.exit(0);
+    }
+  }
+  return a;
+}
+
+async function probeCommand(argv) {
+  const a = parseArgs(argv || []);
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('✗ Not logged in. Run: atris login');
+    return 1;
+  }
+  const token = creds.token;
+  const base = getApiBaseUrl();
+  const label = workspaceLabel(a.business);
+  const where = a.business ? `business ${String(a.business).slice(0, 8)}` : 'personal';
+  const member = a.memberSlug || a.memberId;
+  const prompt = a.message || (a.calendar
+    ? "What's on my calendar today? Use your tools."
+    : 'Read the first 5 lines of any markdown file in this workspace and quote one real line from it. Use your file tools.');
+
+  const body = {
+    message: prompt, model: a.model, max_turns: 8,
+    verify_command: 'true', local_executor: true, workspace_path: label,
+  };
+  if (a.memberId) body.member_id = a.memberId;
+  if (a.memberSlug) body.member_slug = a.memberSlug;
+
+  const t0 = Date.now();
+  let toolsRun = 0;
+  let cliCalendarOps = 0;
+  let resultText = '';
+  let err = null;
+  let engine = null;
+  const unsupported = [];
+
+  try {
+    await new Promise((resolve, reject) => {
+      const url = new URL(`${base}/atris2/turn`);
+      const transport = url.protocol === 'https:' ? https : http;
+      const postData = JSON.stringify(body);
+      const req = transport.request({
+        hostname: url.hostname,
+        port: url.port || (url.protocol === 'https:' ? 443 : 80),
+        path: url.pathname,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(postData),
+          Accept: 'text/event-stream',
+          Authorization: `Bearer ${token}`,
+        },
+      }, (res) => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          let data = '';
+          res.on('data', (c) => data += c);
+          res.on('end', () => reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`)));
+          return;
+        }
+        let buffer = '';
+        let idleTimer = null;
+        const IDLE_MS = 180000;
+        const resetIdle = () => {
+          if (idleTimer) clearTimeout(idleTimer);
+          idleTimer = setTimeout(() => { req.destroy(); reject(new Error(`stream stalled: no events for ${IDLE_MS / 1000}s`)); }, IDLE_MS);
+        };
+        resetIdle();
+
+        // Relayed tool calls run sequentially: the backend awaits each result
+        // before continuing the loop, so a promise chain preserves order.
+        let toolChain = Promise.resolve();
+
+        const handleEvent = (ev) => {
+          if (!ev || typeof ev !== 'object') return;
+          const et = ev.type;
+          if (et === 'system_init') {
+            engine = String(ev.model || '') || null;
+          } else if (et === 'tool_call_request') {
+            const name = String(ev.name || '');
+            const args = ev.args || ev.arguments || {};
+            const op = String(args.type || '').toLowerCase();
+            toolsRun += 1;
+            toolChain = toolChain.then(async () => {
+              let out;
+              if (name === 'local_file_op') {
+                const cmd = fileOpCommand(args, label);
+                if (cmd === null) {
+                  out = { status: 'error', error: 'unsupported op or unsafe path' };
+                  unsupported.push(`file_op:${op}`);
+                } else {
+                  const term = await runTerminal(base, token, cmd, a.business);
+                  const ok = (term.exit_code || 0) === 0;
+                  out = ok
+                    ? { status: 'ok', stdout: String(term.stdout || '').slice(0, 12000) }
+                    : { status: 'error', error: String(term.stderr || 'command failed').slice(0, 2000) };
+                }
+              } else if (name === 'local_atris_cli_op') {
+                const cmd = atrisCliCommand(args);
+                if (cmd === null) {
+                  out = { status: 'error', error: `unsupported atris cli op: ${op || '?'}` };
+                  unsupported.push(`cli_op:${op || '?'}`);
+                } else {
+                  const term = await runTerminal(base, token, cmd, a.business);
+                  out = atrisCliResult(cmd, term);
+                  if (op.startsWith('calendar')) cliCalendarOps += 1;
+                }
+              } else {
+                out = { status: 'error', error: `unsupported relayed tool: ${name || '?'}` };
+                unsupported.push(`tool:${name || '?'}`);
+              }
+              await postJson(`${base}/atris2/turn/tool-result`, token,
+                { call_id: ev.call_id || ev.id, result: out }, 30000);
+              resetIdle();
+            }).catch((e) => reject(e));
+          } else if (et === 'result') {
+            resultText = String(ev.result || '');
+          } else if (et === 'error') {
+            err = String(ev.error || 'turn error');
+          }
+        };
+
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+          resetIdle();
+          buffer += chunk;
+          let nl;
+          while ((nl = buffer.indexOf('\n')) !== -1) {
+            const line = buffer.slice(0, nl).replace(/\r$/, '');
+            buffer = buffer.slice(nl + 1);
+            if (!line.startsWith('data: ')) continue;
+            try { handleEvent(JSON.parse(line.slice(6))); } catch (e) { /* malformed frame */ }
+          }
+        });
+        res.on('end', () => {
+          toolChain.then(() => { if (idleTimer) clearTimeout(idleTimer); resolve(); });
+        });
+        res.on('error', (e) => { if (idleTimer) clearTimeout(idleTimer); reject(e); });
+      });
+      req.on('error', reject);
+      req.write(postData);
+      req.end();
+    });
+  } catch (e) {
+    if (!err) err = `${e.name || 'Error'}: ${e.message || e}`;
+  }
+
+  // Name the dead-end (first match wins); null = converged.
+  let deadEnd = null;
+  if (err) {
+    deadEnd = `error: ${String(err).slice(0, 120)}`;
+  } else if (a.calendar && cliCalendarOps === 0) {
+    deadEnd = 'no local_atris_cli_op calendar op relayed'
+      + (unsupported.length ? ` (unsupported: ${unsupported.slice(0, 3).join(',')})` : '')
+      + (toolsRun ? ` (tools=${toolsRun})` : ' (zero tool calls)');
+  } else if (!a.calendar && toolsRun === 0) {
+    deadEnd = 'zero relayed tool calls';
+  } else if (unsupported.length) {
+    deadEnd = `unsupported relayed call(s): ${unsupported.slice(0, 3).join(',')}`;
+  } else if (resultText.trim().length <= 20) {
+    deadEnd = 'empty/short final answer';
+  } else if (resultText.toLowerCase().includes(MAX_TURNS_MARKER)) {
+    deadEnd = 'max turns exhausted (honest G2 blocked message)';
+  }
+
+  const secs = Math.round((Date.now() - t0) / 100) / 10;
+  const ok = deadEnd === null;
+  const stamp = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+  const detail = ok
+    ? `answer: ${resultText.slice(0, 80).replace(/\n/g, ' ')}`
+    : `dead-end: ${deadEnd}`;
+  const line = `- **atris-probe** \`${stamp}\` — ${where} · ${a.model}`
+    + (member ? ` · member=${member}` : '')
+    + (engine ? ` · engine=${engine}` : '')
+    + ` · ${ok ? 'PASS' : 'FAIL'} · ${secs}s · tools=${toolsRun}`
+    + (a.calendar ? ` cal_cli=${cliCalendarOps}` : '')
+    + ` · ${detail}`;
+  console.log(line);
+  return ok ? 0 : 1;
+}
+
+module.exports = { probeCommand };

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

@@ -4425,15 +4425,26 @@ function cmdDelegate(args) {
   if (handoff.swarlo) console.log(`swarlo: ${handoff.swarlo.channel}/${handoff.swarlo.action}`);
 }
 
-function taskDayGroups(tasks) {
+// Failed tasks older than this stop earning a daily owner-group row;
+// they collapse into one stale summary line instead (target state = clean day view).
+const DAY_STALE_FAILED_MS = 7 * 24 * 60 * 60 * 1000;
+
+function taskDayGroups(tasks, { now = Date.now() } = {}) {
   const active = tasks.filter(task => task.status !== 'done');
-  const groups = new Map();
+  const staleFailed = [];
+  const visible = [];
   for (const task of active) {
+    const isStaleFailed = task.status === 'failed' && (now - (task.updated_at || 0)) > DAY_STALE_FAILED_MS;
+    if (isStaleFailed) staleFailed.push(task);
+    else visible.push(task);
+  }
+  const groups = new Map();
+  for (const task of visible) {
     const owner = taskAssignee(task) || 'unassigned';
     if (!groups.has(owner)) groups.set(owner, []);
     groups.get(owner).push(task);
   }
-  return Array.from(groups.entries())
+  const grouped = Array.from(groups.entries())
     .sort((a, b) => {
       if (a[0] === 'unassigned') return 1;
       if (b[0] === 'unassigned') return -1;
@@ -4446,6 +4457,7 @@ function taskDayGroups(tasks) {
         return (statusOrder[a.status] - statusOrder[b.status]) || (b.updated_at - a.updated_at);
       }),
     }));
+  return { groups: grouped, staleFailed };
 }
 
 function cmdDay(args) {
@@ -4453,13 +4465,15 @@ function cmdDay(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const { projection, outPath } = writeDefaultProjection(taskDb, db, { all });
-  const groups = taskDayGroups(projection.tasks || []);
+  const { groups, staleFailed } = taskDayGroups(projection.tasks || []);
   const counts = {
     active: groups.reduce((sum, group) => sum + group.tasks.length, 0),
     owners: groups.length,
     open: (projection.tasks || []).filter(task => task.status === 'open').length,
     claimed: (projection.tasks || []).filter(task => task.status === 'claimed').length,
-    review: (projection.tasks || []).filter(task => task.status === 'review' || task.status === 'failed' || (task.status === 'done' && task.review && task.review.reward === null)).length,
+    review: (projection.tasks || []).filter(task => task.status === 'review').length,
+    failed: (projection.tasks || []).filter(task => task.status === 'failed').length,
+    stale_failed: staleFailed.length,
   };
   const date = new Date().toISOString().slice(0, 10);
   if (wantsJson(args)) {
@@ -4470,11 +4484,16 @@ function cmdDay(args) {
       projection_path: outPath,
       counts,
       groups,
+      stale_failed: {
+        count: staleFailed.length,
+        refs: staleFailed.map(task => taskRef(task)),
+      },
     });
     return;
   }
   console.log('TASK DAY');
-  console.log(`${date}  active ${counts.active} / owners ${counts.owners} / review ${counts.review}`);
+  const failedText = counts.failed > 0 ? ` / failed ${counts.failed}` : '';
+  console.log(`${date}  active ${counts.active} / owners ${counts.owners} / review ${counts.review}${failedText}`);
   console.log('');
   if (!groups.length) {
     console.log('clear   no active tasks');
@@ -4487,6 +4506,10 @@ function cmdDay(args) {
       console.log(`  ${task.status.padEnd(7)} ${taskRef(task)}${claim}${tag} ${task.title}`);
     }
   }
+  if (staleFailed.length) {
+    console.log('');
+    console.log(`stale   ${staleFailed.length} failed >7d hidden — atris task list --status failed`);
+  }
   console.log('');
   console.log('add: atris task delegate "..." --to codex --tag tasks');
 }
@@ -7920,4 +7943,4 @@ async function run(args) {
   }
 }
 
-module.exports = { run };
+module.exports = { run, taskDayGroups };