atris 3.16.1 → 3.17.0

package/lib/slides-deck.js

@@ -0,0 +1,236 @@
+// Atris deck engine — turn a plain content spec into a premium, anti-slop
+// Google Slides deck. Pure: spec -> batch-update requests (no network here).
+//
+// The product idea: PMs open Slides and get Arial-on-white slop by default.
+// This engine gives them a described deck rendered in a committed design system
+// (own backgrounds, distinctive fonts, one accent, real data panels). It is
+// built so it CANNOT emit the usual AI tells: em dashes are sanitized, labels
+// stay sentence case, no gradient text, no glassmorphism, one accent hue.
+//
+// Spec shape (see commands/deck.js for the CLI):
+//   { theme: 'terminal'|'paper',
+//     brand: { name: 'Sentinel', accent: '.' },
+//     slides: [ { type, ...fields } ] }
+// Emphasis: wrap a phrase in **double asterisks** to render it in the accent.
+
+// ---------- themes (OKLCH design system, flattened to sRGB hex) ----------
+const THEMES = {
+  terminal: { // warm dark "premium terminal"
+    fonts: { display: 'Fraunces', body: 'Outfit', mono: 'Roboto Mono' },
+    color: { bg: '#1E1A16', panel: '#2A231C', panelAlt: '#2F271F', line: '#3A332B',
+      ink: '#ECE6DD', soft: '#BCB2A4', faint: '#968C7E',
+      accent: '#D98E5C', accent2: '#E3A06B', onAccent: '#1E1A16',
+      sev: ['#D98E5C', '#DBBE84', '#7F97A4'] },
+  },
+  paper: { // light "editorial paper instrument"
+    fonts: { display: 'Fraunces', body: 'Outfit', mono: 'Roboto Mono' },
+    color: { bg: '#FBF8F2', panel: '#FFFFFF', panelAlt: '#F4EEE4', line: '#E5DDCF',
+      ink: '#2B241B', soft: '#6B5F4F', faint: '#877B69',
+      accent: '#B5572E', accent2: '#9A4723', onAccent: '#FFFFFF',
+      sev: ['#B5572E', '#C0883A', '#5F7787'] },
+  },
+};
+const COLOR_ROLES = ['bg', 'panel', 'line', 'ink', 'soft', 'faint', 'accent', 'accent2', 'onAccent'];
+
+const W = 720, H = 405, M = 48; // slide is 720 x 405 PT
+
+// ---------- low-level builder ----------
+function rgb(hex) { const n = parseInt(String(hex).slice(1), 16);
+  return { red: ((n >> 16) & 255) / 255, green: ((n >> 8) & 255) / 255, blue: (n & 255) / 255 }; }
+
+// strip the AI tells the engine refuses to ship. Returns sanitized text.
+function sanitize(t) {
+  return String(t == null ? '' : t)
+    .replace(/\s*[—]\s*/g, ', ')   // em dash -> comma (top AI-writing tell)
+    .replace(/\s-\s/g, ', ')         // spaced hyphen used as a dash
+    .replace(/\bAI-powered\b/gi, 'built for')
+    .replace(/\s{2,}/g, ' ');
+}
+
+// parse **emphasis** -> { plain, ranges:[{start,end}] } (indices into plain)
+function parseEmph(text) {
+  const ranges = []; let plain = ''; let i = 0;
+  while (i < text.length) {
+    if (text[i] === '*' && text[i + 1] === '*') {
+      const close = text.indexOf('**', i + 2);
+      if (close !== -1) { const inner = text.slice(i + 2, close);
+        ranges.push({ start: plain.length, end: plain.length + inner.length });
+        plain += inner; i = close + 2; continue; }
+    }
+    plain += text[i]; i++;
+  }
+  return { plain, ranges };
+}
+
+function makeCtx(theme) {
+  const C = theme.color, F = theme.fonts, requests = [];
+  let uid = 0; const nid = (p) => `${p}_${String(++uid).padStart(4, '0')}`;
+
+  const createSlide = (id) => requests.push({ createSlide: { objectId: id, slideLayoutReference: { predefinedLayout: 'BLANK' } } });
+  const bg = (slide, hex) => requests.push({ updatePageProperties: { objectId: slide,
+    pageProperties: { pageBackgroundFill: { solidFill: { color: { rgbColor: rgb(hex) } } } },
+    fields: 'pageBackgroundFill.solidFill.color' } });
+  const shape = (type, slide, x, y, w, h) => { const id = nid(type.slice(0, 2).toLowerCase());
+    requests.push({ createShape: { objectId: id, shapeType: type, elementProperties: {
+      pageObjectId: slide, size: { width: { magnitude: w, unit: 'PT' }, height: { magnitude: h, unit: 'PT' } },
+      transform: { scaleX: 1, scaleY: 1, translateX: x, translateY: y, unit: 'PT' } } } }); return id; };
+  const fill = (id, hex, outlineHex, weight) => {
+    const props = { shapeBackgroundFill: { solidFill: { color: { rgbColor: rgb(hex) } } } };
+    let fields = 'shapeBackgroundFill.solidFill.color';
+    if (outlineHex) { props.outline = { outlineFill: { solidFill: { color: { rgbColor: rgb(outlineHex) } } }, weight: { magnitude: weight || 1, unit: 'PT' } }; fields += ',outline.outlineFill.solidFill.color,outline.weight'; }
+    else { props.outline = { propertyState: 'NOT_RENDERED' }; fields += ',outline.propertyState'; }
+    requests.push({ updateShapeProperties: { objectId: id, shapeProperties: props, fields } }); return id; };
+  function styleRange(id, s, e, o) { if (e <= s || !o) return;
+    const style = {}, f = [];
+    if (o.family) { style.fontFamily = o.family; f.push('fontFamily'); }
+    if (o.size) { style.fontSize = { magnitude: o.size, unit: 'PT' }; f.push('fontSize'); }
+    if (o.color) { style.foregroundColor = { opaqueColor: { rgbColor: rgb(o.color) } }; f.push('foregroundColor'); }
+    if (o.bold) { style.bold = true; f.push('bold'); }
+    if (o.italic) { style.italic = true; f.push('italic'); }
+    if (!f.length) return;
+    requests.push({ updateTextStyle: { objectId: id, textRange: { type: 'FIXED_RANGE', startIndex: s, endIndex: e }, style, fields: f.join(',') } }); }
+  function box(slide, x, y, w, h, markup, opts = {}) {
+    const { plain, ranges } = parseEmph(sanitize(markup));
+    if (!plain.length) return null;
+    const id = shape('TEXT_BOX', slide, x, y, w, h);
+    requests.push({ insertText: { objectId: id, text: plain } });
+    styleRange(id, 0, plain.length, opts);
+    const accentColor = opts.accent || C.accent2;
+    ranges.forEach((r) => styleRange(id, r.start, r.end, { family: opts.family, size: opts.size, color: accentColor, italic: opts.emphItalic }));
+    if (opts.align || opts.line != null) requests.push({ updateParagraphStyle: { objectId: id, textRange: { type: 'ALL' },
+      style: { ...(opts.align ? { alignment: opts.align } : {}), ...(opts.line != null ? { lineSpacing: opts.line } : {}) },
+      fields: [opts.align && 'alignment', opts.line != null && 'lineSpacing'].filter(Boolean).join(',') } });
+    if (opts.vmid) requests.push({ updateShapeProperties: { objectId: id, shapeProperties: { contentAlignment: 'MIDDLE' }, fields: 'contentAlignment' } });
+    return id; }
+  const rule = (slide, x, y, w, hex) => fill(shape('RECTANGLE', slide, x, y, w, 2), hex || C.accent);
+
+  function wordmark(slide, x, y, size, brand, center) {
+    const name = (brand && brand.name) || 'Atris';
+    const ac = (brand && brand.accent) || '';
+    const id = box(slide, x, y, center ? W - x * 2 : size * 9, size * 1.6, name + ac,
+      { family: F.display, size, color: C.ink, align: center ? 'CENTER' : 'START' });
+    if (ac) styleRange(id, name.length, name.length + ac.length, { family: F.display, size, color: C.accent });
+    return id; }
+
+  // generalized data panel: header + rows + footer
+  function panel(slide, x, y, w, data) {
+    const rows = (data.rows || []).slice(0, 4);
+    const rowH = 38, headH = data.header ? 30 : 0, footH = data.footer ? 26 : 0;
+    const h = headH + rowH * rows.length + footH;
+    fill(shape('ROUND_RECTANGLE', slide, x, y, w, h), C.panel, C.line, 1);
+    if (data.header) {
+      box(slide, x + 14, y + 9, w * 0.6, 16, data.header.title || '', { family: F.body, size: 10.5, color: C.ink });
+      if (data.header.meta) box(slide, x + w - 120, y + 9, 106, 14, data.header.meta, { family: F.body, size: 8.5, color: C.faint, align: 'END' });
+      fill(shape('RECTANGLE', slide, x, y + headH, w, 0.75), C.line);
+    }
+    rows.forEach((r, i) => {
+      const ry = y + headH + i * rowH;
+      if (r.active) fill(shape('RECTANGLE', slide, x, ry, 2, rowH), C.accent);
+      const sev = C.sev[(r.sev != null ? r.sev : 0) % C.sev.length];
+      fill(shape('ELLIPSE', slide, x + 16, ry + rowH / 2 - 3.5, 7, 7), sev);
+      const nameTxt = sanitize(r.title || '') + (r.sub ? '\n' + sanitize(r.sub) : '');
+      const nb = box(slide, x + 30, ry + 6, w - 110, 28, nameTxt, { family: F.body, size: 11, color: C.ink, line: 108 });
+      if (r.sub && nb) styleRange(nb, sanitize(r.title || '').length + 1, nameTxt.length, { family: F.body, size: 9, color: C.faint });
+      if (r.value != null) {
+        const valTxt = String(r.value) + (r.valueSub ? '\n' + r.valueSub : '');
+        const bb = box(slide, x + w - 84, ry + 6, 70, 28, valTxt, { family: F.body, size: 11, color: C.ink, align: 'END' });
+        if (bb) { styleRange(bb, 0, String(r.value).length, { family: F.body, size: 13, color: C.ink, bold: true });
+          if (r.valueSub) styleRange(bb, String(r.value).length + 1, valTxt.length, { family: F.body, size: 8, color: C.faint }); }
+      }
+      if (i < rows.length - 1) fill(shape('RECTANGLE', slide, x, ry + rowH, w, 0.75), C.panelAlt);
+    });
+    if (data.footer) { const fy = y + headH + rowH * rows.length;
+      box(slide, x + 14, fy + 6, w * 0.62, 14, data.footer.left || '', { family: F.body, size: 9, color: C.faint });
+      if (data.footer.right) box(slide, x + w - 84, fy + 6, 70, 14, data.footer.right, { family: F.body, size: 9, color: C.accent2, align: 'END' }); }
+    return h; }
+
+  function chips(slide, x, y, list) { let cx = x;
+    (list || []).forEach((label) => { const t = sanitize(label); const w = 16 + t.length * 6.3;
+      fill(shape('ROUND_RECTANGLE', slide, cx, y, w, 24), C.panel, C.line, 1);
+      box(slide, cx, y, w, 24, t, { family: F.mono, size: 9.5, color: C.faint, align: 'CENTER', vmid: true });
+      cx += w + 10; }); }
+
+  function buttons(slide, y, list) {
+    const items = (list || []).slice(0, 3); const bw = 150, bh = 34, gap = 12;
+    const total = items.length * bw + (items.length - 1) * gap; let bx = (W - total) / 2;
+    items.forEach((b) => { const primary = b.primary;
+      fill(shape('ROUND_RECTANGLE', slide, bx, y, bw, bh), primary ? C.ink : C.bg, primary ? null : C.line, 1);
+      box(slide, bx, y, bw, bh, b.label || 'Button', { family: F.body, size: 12.5, color: primary ? C.bg : C.ink, align: 'CENTER', vmid: true });
+      bx += bw + gap; }); }
+
+  return { requests, C, F, nid, createSlide, bg, shape, fill, box, styleRange, rule, wordmark, panel, chips, buttons };
+}
+
+// ---------- slide archetypes ----------
+const ARCHE = {
+  title(ctx, slide, s, spec) {
+    ctx.wordmark(slide, M, 34, 15, spec.brand);
+    ctx.rule(slide, M, 96, 40);
+    const hasPanel = !!s.panel;
+    ctx.box(slide, M, 110, hasPanel ? 360 : 600, 180, s.headline || s.title || '',
+      { family: ctx.F.display, size: 40, color: ctx.C.ink, line: 100, emphItalic: true });
+    if (s.sub) ctx.box(slide, M, hasPanel ? 300 : 300, hasPanel ? 350 : 540, 70, s.sub, { family: ctx.F.body, size: 12.5, color: ctx.C.soft, line: 120 });
+    if (hasPanel) ctx.panel(slide, 432, 96, 240, s.panel);
+  },
+  statement(ctx, slide, s, spec) {
+    ctx.wordmark(slide, M, 34, 13, spec.brand);
+    ctx.rule(slide, M, 150, 40);
+    ctx.box(slide, M, 164, 600, 120, s.text || s.headline || '', { family: ctx.F.display, size: 46, color: ctx.C.ink, line: 100, emphItalic: true });
+    if (s.sub) ctx.box(slide, M, 286, 480, 70, s.sub, { family: ctx.F.body, size: 14, color: ctx.C.soft, line: 130 });
+  },
+  columns(ctx, slide, s, spec) {
+    ctx.wordmark(slide, M, 34, 13, spec.brand);
+    if (s.heading) ctx.box(slide, M, 110, 560, 34, s.heading, { family: ctx.F.display, size: 26, color: ctx.C.ink });
+    const cols = (s.columns || []).slice(0, 4); const n = cols.length || 1;
+    const span = W - M * 2, gap = 16, colW = (span - (n - 1) * gap) / n, cy = s.heading ? 188 : 150;
+    cols.forEach((c, i) => { const cx = M + i * (colW + gap);
+      if (i > 0) ctx.fill(ctx.shape('RECTANGLE', slide, cx - gap / 2, cy, 0.75, 120), ctx.C.line);
+      ctx.box(slide, cx, cy, colW - 8, 30, c.h || c.title || '', { family: ctx.F.display, size: 17, color: ctx.C.ink });
+      ctx.box(slide, cx, cy + 34, colW - 8, 120, c.b || c.body || '', { family: ctx.F.body, size: 11.5, color: ctx.C.soft, line: 134 }); });
+  },
+  panel(ctx, slide, s, spec) {
+    ctx.wordmark(slide, M, 34, 13, spec.brand);
+    if (s.heading) ctx.box(slide, M, 120, 260, 50, s.heading, { family: ctx.F.display, size: 30, color: ctx.C.ink });
+    if (s.sub) ctx.box(slide, M, 178, 260, 160, s.sub, { family: ctx.F.body, size: 12.5, color: ctx.C.soft, line: 132 });
+    ctx.panel(slide, 360, 110, 312, s.panel || { rows: [] });
+  },
+  chips(ctx, slide, s, spec) {
+    ctx.wordmark(slide, M, 34, 13, spec.brand);
+    if (s.heading) ctx.box(slide, M, 110, 580, 34, s.heading, { family: ctx.F.display, size: 28, color: ctx.C.ink });
+    if (s.sub) ctx.box(slide, M, 162, 480, 64, s.sub, { family: ctx.F.body, size: 12.5, color: ctx.C.soft, line: 132 });
+    ctx.chips(slide, M, 250, s.chips || []);
+    if (s.mono) ctx.box(slide, M, 300, 520, 24, s.mono, { family: ctx.F.mono, size: 12, color: ctx.C.accent2 });
+  },
+  bignumber(ctx, slide, s, spec) {
+    ctx.wordmark(slide, M, 34, 13, spec.brand);
+    ctx.box(slide, M, 138, W - M * 2, 120, s.number || s.value || '', { family: ctx.F.display, size: 92, color: ctx.C.accent2, line: 100 });
+    if (s.label) ctx.box(slide, M, 268, 520, 30, s.label, { family: ctx.F.body, size: 16, color: ctx.C.ink });
+    if (s.sub) ctx.box(slide, M, 300, 480, 50, s.sub, { family: ctx.F.body, size: 12.5, color: ctx.C.soft, line: 130 });
+  },
+  close(ctx, slide, s, spec) {
+    ctx.rule(slide, (W - 48) / 2, 150, 48);
+    const name = (spec.brand && spec.brand.name) || 'Atris';
+    const ac = (spec.brand && spec.brand.accent) || '';
+    const id = ctx.box(slide, 0, 168, W, 64, name + ac, { family: ctx.F.display, size: 52, color: ctx.C.ink, align: 'CENTER' });
+    if (ac && id) ctx.styleRange(id, name.length, name.length + ac.length, { family: ctx.F.display, size: 52, color: ctx.C.accent });
+    if (s.tagline) ctx.box(slide, 0, 244, W, 24, s.tagline, { family: ctx.F.body, size: 14, color: ctx.C.soft, align: 'CENTER' });
+    if (s.buttons) ctx.buttons(slide, 296, s.buttons);
+    if (s.footer) ctx.box(slide, 0, 360, W, 20, s.footer, { family: ctx.F.body, size: 10, color: ctx.C.faint, align: 'CENTER' });
+  },
+};
+
+// ---------- public: spec -> requests ----------
+function buildDeck(spec) {
+  const theme = THEMES[spec.theme] || THEMES.terminal;
+  const ctx = makeCtx(theme);
+  const slideIds = [];
+  (spec.slides || []).forEach((s, i) => {
+    const sid = `deck_slide_${i + 1}`; slideIds.push(sid);
+    ctx.createSlide(sid);
+    ctx.bg(sid, theme.color.bg);
+    (ARCHE[s.type] || ARCHE.statement)(ctx, sid, s, spec);
+  });
+  return { requests: ctx.requests, slideIds };
+}
+
+module.exports = { buildDeck, THEMES, ARCHE, sanitize, parseEmph, rgb, COLOR_ROLES };

package/lib/state-detection.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const escapeRegExp = require('./escape-regexp');
 
 const TASK_STATUS_BUCKETS = {
   backlog: new Set(['open']),
@@ -184,10 +185,6 @@ function getTaskCounts(atrisDir) {
   };
 }
 
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
 function getTodayInboxItems(workspaceDir) {
   const atrisDir = path.join(workspaceDir, 'atris');
   const logsDir = path.join(atrisDir, 'logs');

package/lib/task-db.js

@@ -59,6 +59,95 @@ const TASK_PLAN_TAGS = new Set([
   'ux',
 ]);
 
+function todayLogName() {
+  const now = new Date();
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}.md`;
+}
+
+function compactLogText(value, max = 240) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.length > max ? `${text.slice(0, Math.max(0, max - 3)).trim()}...` : text;
+}
+
+function logFieldRows(fields) {
+  return Object.entries(fields)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `- ${key}: ${compactLogText(value, 500)}`);
+}
+
+function taskMemberCandidates(row, actor) {
+  const metadata = row && row.metadata && typeof row.metadata === 'object' ? row.metadata : {};
+  return [
+    metadata.assigned_to,
+    metadata.stage_owner,
+    metadata.planned_by,
+    metadata.agent_certified_by,
+    row && row.claimed_by,
+    actor,
+  ].map(value => String(value || '').trim())
+    .filter(Boolean)
+    .filter((value, index, list) => list.indexOf(value) === index);
+}
+
+function existingMemberSlug(workspaceRoot, row, actor) {
+  for (const candidate of taskMemberCandidates(row, actor)) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(candidate)) continue;
+    const memberFile = path.join(workspaceRoot, 'atris', 'team', candidate, 'MEMBER.md');
+    if (fs.existsSync(memberFile)) return candidate;
+  }
+  return null;
+}
+
+function appendTaskCompletionLogs(db, row, { status, actor, action, proof } = {}) {
+  if (!row || !row.workspace_root || !fs.existsSync(path.join(row.workspace_root, 'atris'))) return {};
+  const logName = todayLogName();
+  const stamp = new Date().toTimeString().slice(0, 5);
+  const allRows = listTasks(db, { workspaceRoot: row.workspace_root });
+  const ref = taskDisplayRefMap(allRows).get(row.id) || shortestUniqueTaskRef(row.id, allRows.map(task => task.id), 8) || row.id;
+  const metadata = row.metadata && typeof row.metadata === 'object' ? row.metadata : {};
+  const proofText = compactLogText(proof || metadata.latest_agent_proof || metadata.verify || '', 500);
+  const member = existingMemberSlug(row.workspace_root, row, actor);
+  const title = status === 'failed' ? 'Task failed' : action === 'accepted' ? 'Task accepted' : 'Task completed';
+  const fields = {
+    task: ref,
+    title: row.title,
+    status,
+    action,
+    tag: row.tag,
+    member,
+    actor,
+    proof: proofText,
+  };
+
+  const projectDir = path.join(row.workspace_root, 'atris', 'logs', logName.slice(0, 4));
+  fs.mkdirSync(projectDir, { recursive: true });
+  const projectLogPath = path.join(projectDir, logName);
+  fs.appendFileSync(projectLogPath, [
+    `## ${stamp} · ${title}`,
+    ...logFieldRows(fields),
+    '',
+  ].join('\n'), 'utf8');
+
+  let memberLogPath = null;
+  if (member) {
+    const memberLogsDir = path.join(row.workspace_root, 'atris', 'team', member, 'logs');
+    fs.mkdirSync(memberLogsDir, { recursive: true });
+    memberLogPath = path.join(memberLogsDir, logName);
+    fs.appendFileSync(memberLogPath, [
+      `## ${stamp} · ${title}`,
+      ...logFieldRows({ ...fields, member }),
+      '',
+    ].join('\n'), 'utf8');
+  }
+
+  return {
+    project_log_path: projectLogPath,
+    member_log_path: memberLogPath,
+    member,
+  };
+}
+
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS tasks (
   id              TEXT PRIMARY KEY,
@@ -325,6 +414,7 @@ function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
     ${where.length ? 'WHERE ' + where.join(' AND ') : ''}
     ORDER BY
       CASE status WHEN 'open' THEN 0 WHEN 'claimed' THEN 1 WHEN 'review' THEN 2 WHEN 'failed' THEN 3 WHEN 'done' THEN 4 ELSE 5 END,
+      CASE WHEN tag='endgame' THEN 0 ELSE 1 END,
       created_at DESC
     ${limit ? 'LIMIT ' + Number(limit) : ''}
   `;
@@ -379,7 +469,7 @@ function claimTask(db, { id, claimedBy }) {
   return { claimed: false, reason: 'already_' + row.status, claimed_by: row.claimed_by };
 }
 
-function doneTask(db, { id, status, actor, allowReview = false }) {
+function doneTask(db, { id, status, actor, allowReview = false, action, proof } = {}) {
   if (!id) throw new Error('id required');
   const final = status || 'done';
   if (!['done', 'failed'].includes(final)) throw new Error('status must be done|failed');
@@ -392,16 +482,23 @@ function doneTask(db, { id, status, actor, allowReview = false }) {
        AND status IN (${allowedStatuses})
   `).run(final, now, now, id));
   if (result.changes === 1) {
-    const row = db.prepare('SELECT id, workspace_root FROM tasks WHERE id = ?').get(id);
+    const row = getTask(db, id);
     appendTaskEvent(db, {
       taskId: id,
       workspaceRoot: row.workspace_root,
       actor: actor || process.env.ATRIS_AGENT_ID || process.env.USER || null,
       eventType: final === 'done' ? 'completed' : 'blocked',
-      payload: { status: final },
+      payload: { status: final, action: action || final },
+    });
+    const logs = appendTaskCompletionLogs(db, row, {
+      status: final,
+      actor: actor || process.env.ATRIS_AGENT_ID || process.env.USER || null,
+      action: action || final,
+      proof,
     });
+    return { updated: true, logs };
   }
-  return { updated: result.changes === 1 };
+  return { updated: false };
 }
 
 function readyTask(db, { id, actor, proof, lesson, nextTask }) {

package/lib/task-proof.js

@@ -2,7 +2,7 @@
 
 const GENERIC_COMPLETION_PROOF_RE = /^(?:done|done now|complete|completed|finished|fixed|handled|ship|shipped|ok|okay|yes|yep|looks good|looks good to me|all set|should be good|works now|approved|approve|lgtm|failed)$/i;
 
-const COMMAND_PROOF_RE = /\b(?:npm\s+run|npm\s+test|node\s+--test|node\s+scripts\/|pnpm\b|yarn\b|npx\b|pytest\b|python\s+-m|tsc\b|vite\s+build|git\s+diff\s+--check|curl\b|atris\s+task|\.\/ax\b|ax\s+--|test\s+-s)\b/i;
+const COMMAND_PROOF_RE = /\b(?:npm\s+run|npm\s+test|node\s+--test|node\s+scripts\/|pnpm\b|yarn\b|npx\b|pytest\b|python\s+-m|tsc\b|vite\s+build|git\s+diff\s+--(?:check|exit-code|quiet)|grep\s+-[A-Za-z]*q[A-Za-z]*|rg\s+(?:-\S+\s+)*(?:"[^"]+"|'[^']+'|\S+)\s+(?:\.{0,2}\/|~\/|\/|[\w.-]+\/|[\w.-]+\.[A-Za-z0-9]|\b(?:atris|bin|commands|lib|scripts|src|test)\b)|diff\s+(?:-u|--brief)|cmp\s+-s|curl\b|atris\s+task|\.\/ax\b|ax\s+--|test\s+-s)\b/i;
 const FILE_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|src\/|scripts\/|atris\/|backend\/|public\/|resources\/|package[.]json|main[.]js|preload[.]js|AGENTXP_PROOF[.]md)[^\s'"`,;)]*/i;
 const PATH_ONLY_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|\/private\/|\/var\/|atris\/runs\/|\.atris\/state\/)[^\s'"`,;)]+(?:[.](?:json|jsonl|md|log|txt|png|jpg|jpeg|pdf))?/i;
 const RECEIPT_OR_ARTIFACT_RE = /\b(?:receipt|artifact|screenshot|log|trace|path=|file=|bytes=|model=|opened=|https?:\/\/)\b/i;

package/lib/todo-fallback.js

@@ -8,6 +8,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const escapeRegExp = require('./escape-regexp');
 
 function parseTodoFile(todoPath) {
   if (!fs.existsSync(todoPath)) return { backlog: [], inProgress: [], review: [], completed: [] };
@@ -37,7 +38,7 @@ function cleanTaskTitle(text) {
 }
 
 function parseSection(content, sectionName) {
-  const escaped = sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const escaped = escapeRegExp(sectionName);
   const match = content.match(new RegExp(`(?:^|\\n)##\\s+${escaped}[^\\n]*\\n([\\s\\S]*?)(?=\\n##(?!#)\\s+|$)`, 'i'));
   if (!match) return [];
 

package/lib/todo-sections.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// Canonical TODO/journal section classification. The same emoji-brittle logic
+// existed (and was bug-fixed) independently in commands/now.js (CLI-287) and
+// commands/brain.js (CLI-288); centralizing it here so a third copy can't drift.
+//
+// Headings may carry trailing decoration ("## In Progress 🔄", "## Completed ✅"),
+// so detection uses \b (not \s*$) and section names match by prefix — "In Progress 🔄"
+// counts as "In Progress", while "Backlogged Notes" does NOT count as "Backlog".
+
+const RENDERED_SECTION_RE = /^##\s+(Backlog|In Progress|Blocked|Completed)\b/m;
+
+// True when the document uses rendered task sections (vs a flat/legacy bullet list).
+function hasRenderedSections(text) {
+  return RENDERED_SECTION_RE.test(String(text || ''));
+}
+
+// A parsed heading name matches a canonical section if it equals it or is that
+// name followed by decoration (a space then emoji/text).
+function sectionMatches(name, target) {
+  const n = String(name || '');
+  return n === target || n.startsWith(`${target} `);
+}
+
+function isOpenSection(name) {
+  return sectionMatches(name, 'Backlog') || sectionMatches(name, 'In Progress');
+}
+
+function isDoneSection(name) {
+  return sectionMatches(name, 'Completed');
+}
+
+module.exports = { hasRenderedSections, sectionMatches, isOpenSection, isDoneSection, RENDERED_SECTION_RE };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.16.1",
+  "version": "3.17.0",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",
@@ -19,7 +19,6 @@
     "atris.md",
     "GETTING_STARTED.md",
     "PERSONA.md",
-    "atris/atrisDev.md",
     "atris/CLAUDE.md",
     "atris/GEMINI.md",
     "atris/GETTING_STARTED.md",

package/utils/api.js

@@ -216,6 +216,7 @@ function streamProChat(url, token, body, showTools = false) {
       }
 
       let buffer = '';
+      let emittedText = false;
 
       res.on('data', (chunk) => {
         buffer += chunk.toString();
@@ -232,10 +233,16 @@ function streamProChat(url, token, body, showTools = false) {
 
               if (msg.type === 'system_init' && showTools) {
                 console.log(`[System] Tools available: ${msg.tools?.join(', ') || 'none'}`);
+              } else if (msg.type === 'text_delta') {
+                if (msg.content) {
+                  emittedText = true;
+                  process.stdout.write(msg.content);
+                }
               } else if (msg.type === 'assistant') {
                 if (msg.content && Array.isArray(msg.content)) {
                   for (const block of msg.content) {
                     if (block.type === 'text') {
+                      emittedText = true;
                       process.stdout.write(block.text);
                     }
                   }
@@ -245,11 +252,14 @@ function streamProChat(url, token, body, showTools = false) {
               } else if (msg.type === 'tool_result' && showTools) {
                 const preview = msg.content?.substring(0, 100) || '';
                 console.log(`[✓ Result]: ${preview}${msg.content?.length > 100 ? '...' : ''}`);
-              } else if (msg.type === 'result') {
+              } else if (msg.type === 'result' && !emittedText) {
                 if (msg.result) {
                   process.stdout.write(msg.result);
                 }
+              } else if (msg.type === 'error') {
+                reject(new Error(msg.error || 'Atris stream error'));
               } else if (msg.chunk) {
+                emittedText = true;
                 process.stdout.write(msg.chunk);
               }
             } catch (e) {
@@ -270,7 +280,9 @@ function streamProChat(url, token, body, showTools = false) {
                 const msg = JSON.parse(data);
                 if (msg.chunk) {
                   process.stdout.write(msg.chunk);
-                } else if (msg.type === 'result' && msg.result) {
+                } else if (msg.type === 'text_delta' && msg.content) {
+                  process.stdout.write(msg.content);
+                } else if (msg.type === 'result' && msg.result && !emittedText) {
                   process.stdout.write(msg.result);
                 }
               } catch (e) {