atris 3.58.5 → 3.58.7

package/lib/rsi-record.js

@@ -0,0 +1,335 @@
+'use strict';
+
+// Record one bounded improvement attempt into the Dream-RSI ledger.
+//
+// When the workspace root contains backend/scripts/rsi/record.py (the
+// backend checkout with the recorder), a command that runs one bounded
+// attempt at improving the workspace (improve tick, pulse tick, drive)
+// wraps the work in start-tree -> choose -> open -> finish. Every step is
+// best-effort: a missing recorder, a failed choose, or a dead python logs
+// one line and the command's behavior and exit code stay untouched.
+//
+// State lands in $ATRIS_RSI_STATE (default <root>/.atris/state/rsi), the
+// same paths backend/scripts/rsi/schema.py uses.
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// Lane name for bounded self-improvement attempts recorded from this CLI.
+const IMPROVE_LANE = 'improve_tick';
+// While an attempt node is open, nested atris subprocesses (local mission
+// fallback, autopilot, mission ticks spawned by drive) must not open their
+// own nodes: one command run is one attempt.
+const GUARD_ENV = 'ATRIS_RSI_ATTEMPT_NODE';
+const SPAWN_TIMEOUT_MS = 20000;
+const NODE_SCHEMA = 'atris.rsi.node.v1';
+
+function scriptsDir(root) {
+  return path.join(root, 'backend', 'scripts', 'rsi');
+}
+
+function recorderPath(root) {
+  const p = path.join(scriptsDir(root), 'record.py');
+  return fs.existsSync(p) ? p : null;
+}
+
+// The repo's own venv first (same as scripts/rsi_record_wrap.sh), else
+// whatever python3 is on PATH.
+function pythonBin(root) {
+  const venv = path.join(root, 'venv', 'bin', 'python');
+  try {
+    fs.accessSync(venv, fs.constants.X_OK);
+    return venv;
+  } catch {
+    return 'python3';
+  }
+}
+
+function stateDir(root) {
+  return process.env.ATRIS_RSI_STATE || path.join(root, '.atris', 'state', 'rsi');
+}
+
+function attemptsPath(root) {
+  return path.join(stateDir(root), 'attempts.jsonl');
+}
+
+function dreamsPath(root) {
+  return path.join(stateDir(root), 'dreams.jsonl');
+}
+
+function currentPolicyId(root, fallback = 'p-0001') {
+  try {
+    const raw = fs.readFileSync(path.join(root, 'atris', 'rsi', 'policy.current'), 'utf8').trim();
+    return raw || fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function localDate(d = new Date()) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${day}`;
+}
+
+// "<prefix>-YYYY-MM-DD[-N]" -> "YYYY-MM-DD" (record.py start-tree shape).
+function treeDate(treeId) {
+  const parts = String(treeId || '').split('-');
+  if (parts.length < 4) return null;
+  const date = parts.slice(1, 4).join('-');
+  return /^\d{4}-\d{2}-\d{2}$/.test(date) ? date : null;
+}
+
+// Read attempts.jsonl tolerantly: blank lines, non-JSON, and foreign rows
+// are skipped. Latest row per node id wins (finish appends a new row).
+function readAttemptRows(root) {
+  let lines;
+  try {
+    lines = fs.readFileSync(attemptsPath(root), 'utf8').split(/\r?\n/);
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row && row.schema === NODE_SCHEMA) rows.push(row);
+    } catch {
+      // skip non-JSON rows
+    }
+  }
+  return rows;
+}
+
+function latestNodes(root) {
+  const latest = new Map();
+  for (const row of readAttemptRows(root)) {
+    if (row && row.id) latest.set(String(row.id), row);
+  }
+  return [...latest.values()];
+}
+
+// Reuse today's tree for the lane when one exists (the newest one wins when
+// a day has several), so every tick on a day shares one tree.
+function todayTreeId(root, lane, today = localDate()) {
+  const matches = new Set();
+  for (const row of readAttemptRows(root)) {
+    if (row && row.lane === lane && treeDate(row.tree_id) === today) matches.add(String(row.tree_id));
+  }
+  const sorted = [...matches].sort();
+  return sorted.length ? sorted[sorted.length - 1] : null;
+}
+
+function runPy(root, script, args, timeoutMs = SPAWN_TIMEOUT_MS) {
+  const scriptPath = path.join(scriptsDir(root), script);
+  const r = spawnSync(pythonBin(root), [scriptPath, ...args], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    env: process.env,
+  });
+  return {
+    ok: r.status === 0,
+    stdout: String(r.stdout || '').trim(),
+    stderr: String(r.stderr || '').trim(),
+    error: r.error || null,
+  };
+}
+
+function startTree(root, lane) {
+  const today = localDate();
+  const existing = todayTreeId(root, lane, today);
+  if (existing) return existing;
+  const r = runPy(root, 'record.py', ['start-tree', '--lane', lane, '--date', today]);
+  const id = r.ok ? (r.stdout.split('\n').pop() || '').trim() : '';
+  return id || null;
+}
+
+// Ask the live policy for one action (--w 1). Returns the first action or
+// null; an empty list means the policy chose to stop, a failure returns null.
+function chooseAction(root, treeId, { queueItems = 0, w = 1 } = {}) {
+  const choose = path.join(scriptsDir(root), 'choose.py');
+  if (!fs.existsSync(choose)) return null;
+  const r = runPy(root, 'choose.py', [
+    '--tree', treeId,
+    '--date', localDate(),
+    '--queue-items', String(queueItems),
+    '--w', String(w),
+  ]);
+  if (!r.ok) return null;
+  try {
+    const actions = JSON.parse(r.stdout);
+    return Array.isArray(actions) && actions.length ? actions[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+function gitHead(root, short = false) {
+  try {
+    const args = short ? ['rev-parse', '--short', 'HEAD'] : ['rev-parse', 'HEAD'];
+    const r = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8', timeout: 15000 });
+    return r.status === 0 ? String(r.stdout || '').trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function gitDirtyFiles(root) {
+  try {
+    const r = spawnSync('git', ['-C', root, 'status', '--porcelain'], { encoding: 'utf8', timeout: 15000 });
+    if (r.status !== 0) return [];
+    return String(r.stdout || '')
+      .split('\n')
+      .map((l) => l.slice(3).trim())
+      .filter(Boolean)
+      .map((f) => {
+        const arrow = f.indexOf(' -> ');
+        return arrow >= 0 ? f.slice(arrow + 4) : f;
+      });
+  } catch {
+    return [];
+  }
+}
+
+// A cheap working-tree snapshot: HEAD + the set of dirty paths. Comparing
+// two snapshots gives a tick's ACTUAL contribution; pre-existing dirt is
+// excluded so a tick is not credited for mess it did not make.
+function gitSnapshot(root) {
+  return { head: gitHead(root), dirty: new Set(gitDirtyFiles(root)) };
+}
+
+// Commits and files between a captured snapshot (or bare HEAD string) and
+// now: the committed diff plus paths the tick newly dirtied.
+function gitDelta(root, before) {
+  const out = { commits: 0, files: [] };
+  if (!root) return out;
+  const beforeHead = typeof before === 'string' ? before : (before && before.head);
+  const beforeDirty = before && before.dirty instanceof Set ? before.dirty : new Set();
+  const files = new Set();
+  try {
+    const after = gitHead(root);
+    if (beforeHead && after && beforeHead !== after) {
+      const count = spawnSync('git', ['-C', root, 'rev-list', '--count', `${beforeHead}..${after}`], { encoding: 'utf8', timeout: 15000 });
+      if (count.status === 0) out.commits = Number(String(count.stdout).trim()) || 0;
+      const diff = spawnSync('git', ['-C', root, 'diff', '--name-only', beforeHead, after], { encoding: 'utf8', timeout: 15000 });
+      if (diff.status === 0) String(diff.stdout).split('\n').map((f) => f.trim()).filter(Boolean).forEach((f) => files.add(f));
+    }
+    for (const f of gitDirtyFiles(root)) {
+      if (!beforeDirty.has(f)) files.add(f);
+    }
+  } catch {
+    // git missing or not a repo: commits 0, no files
+  }
+  out.files = [...files].slice(0, 200);
+  return out;
+}
+
+// Map a model name to a recorded engine. The schema's ENGINES are
+// codex/devin/cursor/agy/claude; unknown models return null so callers fall
+// back to 'claude' (the CLI's own runner default).
+function engineFromModel(model) {
+  const m = String(model || '').toLowerCase();
+  if (!m) return null;
+  if (m.includes('codex')) return 'codex';
+  if (m.includes('devin')) return 'devin';
+  if (m.includes('cursor') || m.includes('composer')) return 'cursor';
+  if (m.includes('agy') || m.includes('antigravity')) return 'agy';
+  if (m.includes('claude') || m.includes('sonnet') || m.includes('opus') || m.includes('haiku')) return 'claude';
+  return null;
+}
+
+/**
+ * Open one recorded attempt. Returns null when the workspace has no
+ * recorder, when a parent attempt is already open (nested call), or when
+ * any recorder step fails. Never throws.
+ *
+ * opts.engine: the engine the tick will actually use (default 'claude').
+ * opts.ground: the ground the tick targets; '' is allowed when the tick has
+ *   no notion of target.
+ * The returned attempt carries .hint = the policy-chosen action (or null),
+ * so a tick with a notion of target can steer by hint.ground.
+ */
+function beginAttempt(root, { lane = IMPROVE_LANE, engine = 'claude', ground = '', queueItems = 0, log = () => {} } = {}) {
+  try {
+    if (!root || process.env[GUARD_ENV]) return null;
+    if (!recorderPath(root)) return null;
+    const tree = startTree(root, lane);
+    if (!tree) {
+      log('rsi: recorder present but start-tree failed; attempt not recorded');
+      return null;
+    }
+    const chosen = chooseAction(root, tree, { queueItems, w: 1 });
+    const action = {
+      policy_id: (chosen && chosen.policy_id) || currentPolicyId(root),
+      kind: 'open',
+      // The ground the tick actually targeted. Callers without a notion of
+      // target pass '' (allowed); the policy's pick is exposed as .hint
+      // instead of being claimed as the ground the tick took.
+      ground: String(ground || ''),
+      engine: engine || 'claude',
+      model: chosen && chosen.model != null ? chosen.model : null,
+      cap_s: Number(chosen && chosen.cap_s) || 1800,
+      prompt_variant: (chosen && chosen.prompt_variant) || 'v1',
+    };
+    const context = {
+      base_commit: gitHead(root, true) || '',
+      ground: action.ground,
+      queue_items: queueItems,
+    };
+    const r = runPy(root, 'record.py', [
+      'open', '--tree', tree, '--lane', lane,
+      '--action-json', JSON.stringify(action),
+      '--context-json', JSON.stringify(context),
+    ]);
+    const node = r.ok ? (r.stdout.split('\n').pop() || '').trim() : '';
+    if (!node) {
+      log('rsi: node open failed; attempt not recorded');
+      return null;
+    }
+    process.env[GUARD_ENV] = node;
+    return { tree, node, lane, action, hint: chosen || null };
+  } catch (e) {
+    log(`rsi: attempt record skipped (${e && e.message ? e.message : e})`);
+    return null;
+  }
+}
+
+// Close an attempt opened by beginAttempt. Never throws; returns true when
+// the finish row was written.
+function finishAttempt(root, attempt, outcome = {}, { log = () => {} } = {}) {
+  if (!attempt || !attempt.node) return false;
+  if (process.env[GUARD_ENV] === attempt.node) delete process.env[GUARD_ENV];
+  try {
+    const r = runPy(root, 'record.py', [
+      'finish', '--node', attempt.node,
+      '--outcome-json', JSON.stringify(outcome),
+    ]);
+    if (!r.ok) {
+      log(`rsi: node finish failed${r.stderr ? ` (${r.stderr.split('\n').pop()})` : ''}`);
+      return false;
+    }
+    return true;
+  } catch (e) {
+    log(`rsi: node finish skipped (${e && e.message ? e.message : e})`);
+    return false;
+  }
+}
+
+module.exports = {
+  IMPROVE_LANE,
+  GUARD_ENV,
+  attemptsPath,
+  dreamsPath,
+  currentPolicyId,
+  latestNodes,
+  gitSnapshot,
+  gitDelta,
+  engineFromModel,
+  beginAttempt,
+  finishAttempt,
+};

package/lib/state-detection.js

@@ -121,11 +121,7 @@ function getTasksFromTodoSection(content, sectionName) {
 
   if (tasks.length > 0) return tasks;
 
-  return body
-    .split('\n')
-    .map((line) => line.trim())
-    .filter((line) => /^-\s+/.test(line) && !/\(empty/i.test(line))
-    .map((line) => line.replace(/^-+\s*/, '').trim());
+  return require('./todo-fallback').parseSection(content, sectionName).map(task => task.title);
 }
 
 function getTasksFromDbBucket(atrisDir, bucketName) {
@@ -149,7 +145,7 @@ function getTasksFromDbBucket(atrisDir, bucketName) {
 
 // Single-read task lane counts for boot/status surfaces.
 // Prefers the task DB (source of truth); falls back to TODO.md parsing.
-// Review counts only exist on the DB path, markdown views don't carry the lane.
+// Generated markdown carries the Review lane, but cannot certify its proof.
 function getTaskCounts(atrisDir) {
   try {
     const taskDb = require('./task-db');
@@ -179,7 +175,7 @@ function getTaskCounts(atrisDir) {
   return {
     backlog: getBacklogTasks(atrisDir).length,
     active: getInProgressTasks(atrisDir).length,
-    review: 0,
+    review: getTasksFromTodoSection(readTodoText(atrisDir), 'Review').length,
     reviewCertified: 0,
     source: 'todo'
   };
@@ -230,7 +226,7 @@ function getTaskGlance(atrisDir, sampleSize = 3) {
   return {
     backlog: backlogTitles.length,
     active: activeTitles.length,
-    review: 0,
+    review: getTasksFromTodoSection(readTodoText(atrisDir), 'Review').length,
     reviewCertified: 0,
     activeTitles: activeTitles.slice(0, sampleSize),
     backlogTitles: backlogTitles.slice(0, sampleSize),
@@ -239,6 +235,10 @@ function getTaskGlance(atrisDir, sampleSize = 3) {
   };
 }
 
+function readTodoText(atrisDir) {
+  try { return fs.readFileSync(path.join(atrisDir, 'TODO.md'), 'utf8'); } catch { return ''; }
+}
+
 function getTodayInboxItems(workspaceDir) {
   const atrisDir = path.join(workspaceDir, 'atris');
   const logsDir = path.join(atrisDir, 'logs');

package/lib/task-db.js

@@ -28,6 +28,7 @@ const os = require('os');
 const crypto = require('crypto');
 const { DatabaseSync } = require('node:sqlite');
 const reviewIntegrity = require('./review-integrity');
+const dailyLog = require('./daily-log');
 const { isGenericScratchRoot } = require('./scratch-root');
 const { isDecisionTask } = require('./task-decision');
 const { parseVerifyCommand } = require('./auto-accept-certified');
@@ -67,23 +68,6 @@ 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 [
@@ -100,21 +84,22 @@ function taskMemberCandidates(row, actor) {
 
 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;
+    const slug = dailyLog.memberSlug(workspaceRoot, candidate);
+    if (slug) return slug;
   }
   return null;
 }
 
+function taskLogRef(db, row) {
+  const allRows = listTasks(db, { workspaceRoot: row.workspace_root });
+  return taskDisplayRefMap(allRows).get(row.id) || shortestUniqueTaskRef(row.id, allRows.map(task => task.id), 8) || row.id;
+}
+
 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 ref = taskLogRef(db, row);
   const metadata = row.metadata && typeof row.metadata === 'object' ? row.metadata : {};
-  const proofText = compactLogText(proof || metadata.latest_agent_proof || metadata.verify || '', 500);
+  const proofText = dailyLog.compactLogText(proof || metadata.latest_agent_proof || metadata.verify || '', 500);
   const member = existingMemberSlug(row.workspace_root, row, actor);
   const title = status === 'archived' ? 'Task archived'
     : status === 'failed' ? 'Task failed'
@@ -131,26 +116,10 @@ function appendTaskCompletionLogs(db, row, { status, actor, action, proof } = {}
     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');
-  }
+  const projectLogPath = dailyLog.appendMasterDailyEntry(row.workspace_root, title, fields);
+  const memberLogPath = member
+    ? dailyLog.appendMemberDailyEntry(row.workspace_root, member, title, fields)
+    : null;
 
   return {
     project_log_path: projectLogPath,
@@ -159,6 +128,25 @@ function appendTaskCompletionLogs(db, row, { status, actor, action, proof } = {}
   };
 }
 
+function appendTaskWorkLog(db, row, { actor, title, note } = {}) {
+  if (!row || !row.workspace_root || !fs.existsSync(path.join(row.workspace_root, 'atris'))) return {};
+  const member = existingMemberSlug(row.workspace_root, row, actor);
+  const fields = {
+    task: taskLogRef(db, row),
+    title: row.title,
+    tag: row.tag,
+    actor,
+    note: dailyLog.compactLogText(note, 500),
+  };
+  const memberLogPath = member
+    ? dailyLog.appendMemberDailyEntry(row.workspace_root, member, title, fields)
+    : null;
+  const projectLogPath = dailyLog.MASTER_NOTE.test(String(note || ''))
+    ? dailyLog.appendMasterDailyEntry(row.workspace_root, dailyLog.noteTitle(note), { ...fields, member })
+    : null;
+  return { project_log_path: projectLogPath, member_log_path: memberLogPath, member };
+}
+
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS tasks (
   id              TEXT PRIMARY KEY,
@@ -186,6 +174,9 @@ CREATE TABLE IF NOT EXISTS task_events (
 );
 CREATE INDEX IF NOT EXISTS idx_tasks_status      ON tasks(status);
 CREATE INDEX IF NOT EXISTS idx_tasks_workspace   ON tasks(workspace_root);
+CREATE INDEX IF NOT EXISTS idx_tasks_workspace_status_updated ON tasks(workspace_root, status, updated_at);
+CREATE INDEX IF NOT EXISTS idx_tasks_workspace_blocker ON tasks(workspace_root, tag)
+  WHERE tag = 'mission-blocker';
 CREATE INDEX IF NOT EXISTS idx_tasks_claimed_by  ON tasks(claimed_by);
 CREATE INDEX IF NOT EXISTS idx_task_events_task  ON task_events(task_id, version);
 CREATE INDEX IF NOT EXISTS idx_task_events_ws    ON task_events(workspace_root, created_at);
@@ -515,7 +506,9 @@ function claimTask(db, { id, claimedBy }) {
       eventType: 'claimed',
       payload: { claimed_by: claimedBy },
     });
-    return { claimed: true, row: { ...row, metadata: row.metadata ? safeJSON(row.metadata) : null } };
+    const enriched = { ...row, metadata: row.metadata ? safeJSON(row.metadata) : null };
+    appendTaskWorkLog(db, enriched, { actor: claimedBy, title: 'Task claimed' });
+    return { claimed: true, row: enriched };
   }
   // Either id doesn't exist or status != 'open'. Tell the caller which.
   const row = db.prepare('SELECT id, status, claimed_by FROM tasks WHERE id = ?').get(id);
@@ -665,11 +658,12 @@ function doneTask(db, { id, status, actor, allowReview = false, action, proof, a
   return { updated: false };
 }
 
-function reapMissionBlockerTasks(db, { workspaceRoot: ws, missions = [], actor } = {}) {
+function reapMissionBlockerTasks(db, { workspaceRoot: ws, missions = [], actor, rows = null, skipLogs = false } = {}) {
   const missionById = new Map((Array.isArray(missions) ? missions : [])
     .filter(mission => mission && mission.id)
     .map(mission => [String(mission.id), mission]));
-  const candidates = listTasks(db, { workspaceRoot: ws || null, limit: null })
+  const source = Array.isArray(rows) ? rows : listTasks(db, { workspaceRoot: ws || null, limit: null });
+  const candidates = source
     .filter(row => OPEN_TASK_STATUSES.has(row.status))
     .filter(row => row.tag === 'mission-blocker')
     .filter(row => row.metadata && row.metadata.mission_id && row.metadata.mission_blocker_class)
@@ -683,6 +677,7 @@ function reapMissionBlockerTasks(db, { workspaceRoot: ws, missions = [], actor }
       id: row.id,
       actor,
       reason,
+      skipLogs,
     });
     if (!result.archived) continue;
     closed.push({
@@ -710,7 +705,7 @@ function reapMissionBlockerTasks(db, { workspaceRoot: ws, missions = [], actor }
 // metadata.archived_from. Individual archive commands never archive 'done'
 // rows. The clear-done sweep opts in through fromDone after selecting only the
 // same 'done' rows counted by `atris status`.
-function archiveTask(db, { id, actor, reason, fromFailed = false, fromDone = false } = {}) {
+function archiveTask(db, { id, actor, reason, fromFailed = false, fromDone = false, skipLogs = false } = {}) {
   if (!id) throw new Error('id required');
   const reasonText = String(reason || '').trim();
   if (!reasonText) throw new Error('reason required');
@@ -752,7 +747,7 @@ function archiveTask(db, { id, actor, reason, fromFailed = false, fromDone = fal
       ...(['failed', 'done'].includes(row.status) ? { previous_status: row.status } : {}),
     },
   });
-  const logs = appendTaskCompletionLogs(db, updated, {
+  const logs = skipLogs ? null : appendTaskCompletionLogs(db, updated, {
     status: 'archived',
     actor: metadata.archived_by,
     action: 'archived',
@@ -1519,6 +1514,11 @@ function noteTask(db, { id, actor, content }) {
     eventType: 'message',
     payload: { content: text },
   });
+  // Structured trace notes already land on the member log through
+  // task result/ready; logging them here would double the receipt.
+  if (!/^TASK_[A-Z_]+_TRACE\s/.test(text)) {
+    appendTaskWorkLog(db, row, { actor, title: 'Task note', note: text });
+  }
   return { noted: true, event };
 }
 
@@ -2126,7 +2126,8 @@ function renderTodoMarkdown(rows, { title = 'TODO.md', doneLimit = TODO_RENDER_D
     failed: displayRows.filter(r => r.status === 'failed'),
     done: displayRows.filter(r => r.status === 'done'),
   };
-  const lines = [`# ${title}`, '', '> Regenerated from durable Atris task state. Do not treat this file as truth.', ''];
+  const lines = [`# ${title}`, '', 'Details for any task: atris task show <ID>', '', '> Regenerated from durable Atris task state. Do not treat this file as truth.', ''];
+  if (process.env.ATRIS_TODO_RENDER !== 'full') lines.push('<!-- ATRIS_TODO_COMPACT:2 -->', '');
   for (const section of preservedSections) {
     const text = String(section || '').trim();
     if (!text) continue;
@@ -2170,6 +2171,25 @@ function appendSection(lines, name, rows) {
     const decision = isDecisionTask(row) ? ' [decision]' : '';
     const displayRef = meta.todo_id || row.display_id || row.id;
     const explanation = taskExplanation(row);
+    if (process.env.ATRIS_TODO_RENDER !== 'full') {
+      const singleLine = value => String(value || '').replace(/\s+/g, ' ').trim();
+      const clip = (value, limit) => {
+        const text = singleLine(value);
+        return text.length > limit ? text.slice(0, limit - 1) + '…' : text;
+      };
+      const owner = singleLine(row.claimed_by || meta.assigned_to || meta.owner) || 'unassigned';
+      const title = clip(row.title, name === 'Completed' ? 100 : 140);
+      const labels = name === 'Backlog' || name === 'Blocked' ? tag + decision : '';
+      const assignment = name === 'Backlog' || name === 'Completed' ? '' : ` · ${owner}`;
+      const previewLimit = name === 'Blocked' ? 60 : 40;
+      const verify = (name === 'In Progress' || name === 'Blocked') && meta.verify
+        ? ` · verify: ${singleLine(meta.verify).slice(0, previewLimit)}` : '';
+      lines.push(`- **[${displayRef}]** ${title}${labels}${assignment}${verify}`);
+      if (name === 'Review') {
+        lines.push(`  **Done looks like:** ${clip(explanation.done_looks_like, 160)}`);
+      }
+      continue;
+    }
     // The plain face leads. The exact original title remains immediately below
     // it so old TODO-only projects and deep inspection keep full fidelity.
     lines.push(`- **[${displayRef}]** ${explanation.what_changes}${tag}${decision}`);