atris 3.58.6 → 3.58.8

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');
@@ -271,6 +271,32 @@ function getTodayInboxItems(workspaceDir) {
 /**
  * Detect workspace state: fresh install, has inbox items, in-progress work, or blocked
  */
+// Blocked means a task whose status is failed: the DB has no separate
+// blocked status, doneTask logs a failed task as a "blocked" event, and the
+// board renders failed tasks under "## Blocked". Once this workspace has rows
+// in the task DB, the DB is the only source. The DB file is shared by every
+// workspace on the machine, so a workspace with no rows there falls back to
+// the Blocked section of its own TODO.md, never a word elsewhere in a title.
+function hasBlockedTasks(atrisDir, todoFile, legacyTaskContextFile) {
+  try {
+    const taskDb = require('./task-db');
+    if (fs.existsSync(taskDb.getDbPath())) {
+      const db = taskDb.open();
+      const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
+      if (taskDb.listTasks(db, { workspaceRoot, limit: 1 }).length) {
+        return taskDb.listTasks(db, { workspaceRoot, status: 'failed', limit: 1 }).length > 0;
+      }
+    }
+  } catch (e) {
+    if (process.env.ATRIS_DEBUG) console.error('[state-detection] db blocked read failed:', e.message);
+  }
+  const taskFilePath = fs.existsSync(todoFile)
+    ? todoFile
+    : (fs.existsSync(legacyTaskContextFile) ? legacyTaskContextFile : null);
+  if (!taskFilePath) return false;
+  return getTasksFromTodoSection(fs.readFileSync(taskFilePath, 'utf8'), 'Blocked').length > 0;
+}
+
 function detectWorkspaceState(workspaceDir) {
   const atrisDir = path.join(workspaceDir, 'atris');
   const featuresDir = path.join(atrisDir, 'features');
@@ -317,15 +343,8 @@ function detectWorkspaceState(workspaceDir) {
     }
   }
 
-  // Check for blocked tasks (prefer TODO.md, fallback to legacy TASK_CONTEXTS.md)
-  const taskFilePath = fs.existsSync(todoFile)
-    ? todoFile
-    : (fs.existsSync(legacyTaskContextFile) ? legacyTaskContextFile : null);
-  if (taskFilePath) {
-    const content = fs.readFileSync(taskFilePath, 'utf8');
-    if (content.includes('Risk Level: High') || /\bblocked\b/i.test(content)) {
-      return { state: 'blocked', reason: 'Tasks marked as blocked or high risk' };
-    }
+  if (hasBlockedTasks(atrisDir, todoFile, legacyTaskContextFile)) {
+    return { state: 'blocked', reason: 'Tasks marked as blocked' };
   }
 
   // Default: setup complete but no active work

package/lib/task-db.js

@@ -28,11 +28,13 @@ 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');
 const { taskExplanation } = require('./task-explanation');
 const { treeHashFor } = require('./tree-hash');
+const { sleepSync } = require('./sleep-sync');
 
 const DEFAULT_DB_PATH = path.join(os.homedir(), '.atris', 'tasks.db');
 const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
@@ -67,23 +69,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 +85,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 +117,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 +129,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 +175,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 +507,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 +659,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 +678,7 @@ function reapMissionBlockerTasks(db, { workspaceRoot: ws, missions = [], actor }
       id: row.id,
       actor,
       reason,
+      skipLogs,
     });
     if (!result.archived) continue;
     closed.push({
@@ -710,7 +706,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 +748,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 +1515,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 +2127,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 +2172,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}`);
@@ -2204,8 +2225,7 @@ function withBusyRetry(fn, attempts = 8) {
       const busy = /SQLITE_BUSY|database is locked/i.test(msg) || code === 'SQLITE_BUSY' || code === 5;
       if (!busy) throw e;
       // Sleep synchronously, node:sqlite is sync; matches the rest of the API
-      const end = Date.now() + delay + Math.floor(Math.random() * delay);
-      while (Date.now() < end) {} // tight loop is fine, delay is small
+      sleepSync(delay + Math.floor(Math.random() * delay));
       delay = Math.min(delay * 2, 500);
     }
   }
@@ -2214,6 +2234,7 @@ function withBusyRetry(fn, attempts = 8) {
 
 module.exports = {
   open,
+  withBusyRetry,
   close,
   getDbPath,
   workspaceRoot,

package/lib/task-list-keeper.js

@@ -0,0 +1,192 @@
+'use strict';
+
+// Puts finished and untouched tasks off the visible list. History stays
+// archived. A current list costs one indexed lookup and no writes.
+
+const fs = require('fs');
+const path = require('path');
+const taskDb = require('./task-db');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const OPEN_STATUSES = new Set(['open', 'claimed', 'review']);
+
+// Failed rows already leave the today screen after 7 days. They stay
+// findable until 30 days, then they leave the list too.
+const IDLE_LIMITS_MS = {
+  claimed: 3 * DAY_MS,
+  open: 14 * DAY_MS,
+  review: 14 * DAY_MS,
+  failed: 30 * DAY_MS,
+};
+
+const REASONS = {
+  done: 'finished work left the list',
+  claimed: 'claimed work sat untouched for 3 days',
+  open: 'waiting work sat untouched for 14 days',
+  review: 'review sat untouched for 14 days',
+  failed: 'failed work sat untouched for 30 days',
+};
+
+const CANDIDATE_SQL = `
+  SELECT id, title, status, tag, updated_at, created_at, done_at, metadata
+    FROM tasks
+   WHERE workspace_root = ? AND status = 'done'
+  UNION ALL
+  SELECT id, title, status, tag, updated_at, created_at, done_at, metadata
+    FROM tasks
+   WHERE workspace_root = ? AND status = 'claimed' AND updated_at < ?
+  UNION ALL
+  SELECT id, title, status, tag, updated_at, created_at, done_at, metadata
+    FROM tasks
+   WHERE workspace_root = ? AND status = 'open' AND updated_at < ?
+  UNION ALL
+  SELECT id, title, status, tag, updated_at, created_at, done_at, metadata
+    FROM tasks
+   WHERE workspace_root = ? AND status = 'review' AND updated_at < ?
+  UNION ALL
+  SELECT id, title, status, tag, updated_at, created_at, done_at, metadata
+    FROM tasks
+   WHERE workspace_root = ? AND status = 'failed' AND updated_at < ?
+  UNION ALL
+  SELECT id, title, status, tag, updated_at, created_at, done_at, metadata
+    FROM tasks
+   WHERE workspace_root = ? AND tag = 'mission-blocker' AND status IN ('open', 'claimed', 'review')
+`;
+
+function actorName(actor) {
+  return actor || process.env.ATRIS_AGENT_ID || process.env.USER || 'task-list';
+}
+
+function decisionFor(row, now) {
+  if (!row || row.status === 'archived') return null;
+  if (row.status === 'done') {
+    return { reason: REASONS.done, fromDone: true, fromFailed: false };
+  }
+  if (!Object.prototype.hasOwnProperty.call(IDLE_LIMITS_MS, row.status)) return null;
+  const at = Number(row.updated_at || row.created_at || 0);
+  if (!((now - at) > IDLE_LIMITS_MS[row.status])) return null;
+  return { reason: REASONS[row.status], fromDone: false, fromFailed: row.status === 'failed' };
+}
+
+function selectCandidates(db, workspaceRoot, now) {
+  return db.prepare(CANDIDATE_SQL).all(
+    workspaceRoot,
+    workspaceRoot, now - IDLE_LIMITS_MS.claimed,
+    workspaceRoot, now - IDLE_LIMITS_MS.open,
+    workspaceRoot, now - IDLE_LIMITS_MS.review,
+    workspaceRoot, now - IDLE_LIMITS_MS.failed,
+    workspaceRoot,
+  );
+}
+
+function blockerFrom(row) {
+  if (!row || row.tag !== 'mission-blocker' || !OPEN_STATUSES.has(row.status)) return null;
+  let metadata = row.metadata;
+  if (typeof metadata === 'string') {
+    try { metadata = JSON.parse(metadata); } catch { metadata = null; }
+  }
+  if (!metadata || !metadata.mission_id || !metadata.mission_blocker_class) return null;
+  return { ...row, metadata };
+}
+
+function loadMissions(workspaceRoot) {
+  try {
+    return require('../commands/mission').listMissions(workspaceRoot) || [];
+  } catch {
+    return [];
+  }
+}
+
+function noteKeep(workspaceRoot, actor, count) {
+  if (!count || !workspaceRoot || !fs.existsSync(path.join(workspaceRoot, 'atris'))) return;
+  try {
+    const now = new Date();
+    const year = String(now.getFullYear());
+    const dir = path.join(workspaceRoot, 'atris', 'logs', year);
+    fs.mkdirSync(dir, { recursive: true });
+    const name = `${year}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}.md`;
+    const stamp = now.toTimeString().slice(0, 5);
+    fs.appendFileSync(path.join(dir, name), `## ${stamp} · Task list kept\n- count: ${count}\n- actor: ${actor}\n\n`);
+  } catch {
+    // The rows are already off the list. A missed note should not put them back.
+  }
+}
+
+function keepTaskList(db, { workspaceRoot, actor, now = Date.now(), missions } = {}) {
+  const who = actorName(actor);
+  const seen = new Set();
+  const toArchive = [];
+  const blockers = [];
+  for (const row of selectCandidates(db, workspaceRoot, now)) {
+    if (!row || seen.has(row.id)) continue;
+    seen.add(row.id);
+    const decision = decisionFor(row, now);
+    if (decision) {
+      toArchive.push({ id: row.id, previous_status: row.status, ...decision });
+      continue;
+    }
+    const blocker = blockerFrom(row);
+    if (blocker) blockers.push(blocker);
+  }
+
+  const missionList = Array.isArray(missions)
+    ? missions
+    : (blockers.length ? loadMissions(workspaceRoot) : []);
+  if (!toArchive.length && !(blockers.length && missionList.length)) {
+    return { put_away: [], reaped: [] };
+  }
+
+  const putAway = [];
+  let reaped = [];
+  db.exec('BEGIN IMMEDIATE');
+  try {
+    for (const item of toArchive) {
+      const result = taskDb.archiveTask(db, {
+        id: item.id,
+        actor: who,
+        reason: item.reason,
+        fromDone: item.fromDone,
+        fromFailed: item.fromFailed,
+        skipLogs: true,
+      });
+      if (result.archived) {
+        putAway.push({ id: item.id, previous_status: item.previous_status, reason: item.reason });
+      }
+    }
+    if (blockers.length && missionList.length) {
+      reaped = taskDb.reapMissionBlockerTasks(db, {
+        workspaceRoot,
+        missions: missionList,
+        actor: who,
+        rows: blockers,
+        skipLogs: true,
+      }).closed || [];
+    }
+    db.exec('COMMIT');
+  } catch (error) {
+    try { db.exec('ROLLBACK'); } catch { /* the original error is the one to surface */ }
+    throw error;
+  }
+  noteKeep(workspaceRoot, who, putAway.length + reaped.length);
+  return { put_away: putAway, reaped };
+}
+
+function keepWorkspaceTaskList(cwd = process.cwd(), { actor } = {}) {
+  const dbPath = taskDb.getDbPath();
+  if (!dbPath || !fs.existsSync(dbPath)) {
+    return { put_away: [], reaped: [], skipped: 'no_db' };
+  }
+  const db = taskDb.open();
+  return keepTaskList(db, {
+    workspaceRoot: taskDb.workspaceRoot(cwd),
+    actor,
+    now: Date.now(),
+  });
+}
+
+module.exports = {
+  DAY_MS,
+  IDLE_LIMITS_MS,
+  keepTaskList,
+  keepWorkspaceTaskList,
+};

package/lib/todo-fallback.js

@@ -34,7 +34,7 @@ function cleanTaskTitle(text) {
   const withoutTags = raw.replace(/\s*\[[\w-]+\]/g, '').trim();
   const bold = withoutTags.match(/^\*\*(.+?)\*\*\s*(?:[\u2014-]\s*)?(.*)$/);
   if (!bold) return withoutTags;
-  return [bold[1], bold[2]].filter(Boolean).join(' \u2014 ').trim();
+  return [bold[1], bold[2]].filter(Boolean).join(' - ').replace(/\s*\u2014\s*/g, ' - ').trim();
 }
 
 function parseSection(content, sectionName) {
@@ -80,15 +80,21 @@ function parseSection(content, sectionName) {
     const bracketTaskMatch = line.match(/^- \*\*\[([^\]\n]+)\]\*\*\s+(.+)$/);
     if (bracketTaskMatch) {
       if (current) tasks.push(current);
-      const { allTags, tag } = tagsFromText(bracketTaskMatch[2]);
+      // Compact rows carry display-only verification previews. Never execute
+      // a clipped command; the full command lives in task show or the DB.
+      const titleOnly = content.includes('<!-- ATRIS_TODO_COMPACT:2 -->') && /^(Backlog|Completed)$/i.test(sectionName);
+      const compact = !titleOnly && bracketTaskMatch[2].match(/^(.*?) · ([^·]+?)(?: · verify: (.*))?$/);
+      const title = compact ? compact[1] : bracketTaskMatch[2];
+      const { allTags, tag } = tagsFromText(title);
       current = {
         id: bracketTaskMatch[1],
-        title: cleanTaskTitle(bracketTaskMatch[2]),
+        title: cleanTaskTitle(title),
         tag,
         tags: allTags,
-        claimed: null,
+        claimed: compact && compact[2] !== 'unassigned' ? compact[2].trim() : null,
         stage: null,
         verify: null,
+        ...(compact || titleOnly ? { verify_preview: compact ? compact[3] || null : null } : {}),
       };
       continue;
     }

package/lib/todo.js

@@ -1,6 +1,7 @@
 // SHIM. Same export surface as the legacy markdown parser, but reads from the
 // SQLite task store first when ATRIS_TASK_DB=1 is set, falling back to the
-// pure markdown parser at lib/todo-fallback.js.
+// pure markdown parser at lib/todo-fallback.js. Compact generated boards also
+// consult an existing store so verification previews never replace commands.
 //
 // All 3 callers (commands/autopilot.js, commands/status.js, commands/run.js)
 // inherit the strangler without changing their import path.
@@ -22,12 +23,14 @@ function dbToShimRow(row) {
     ? metadata.verify.trim()
     : null;
   const claimed = row.claimed_by || metadata.claimed || null;
+  const tags = [...new Set([row.tag, ...(Array.isArray(metadata.todo_tags) ? metadata.todo_tags : []),
+    ...(Array.isArray(metadata.tags) ? metadata.tags : [])].filter(Boolean))];
   // Map DB row → the shape the existing consumers expect from parseTodo().
   return {
     id: row.id,
     title: row.title,
-    tag: row.tag || null,
-    tags: row.tag ? [row.tag] : [],
+    tag: tags.includes('endgame') ? 'endgame' : (row.tag || tags[0] || null),
+    tags,
     claimed,
     stage: row.status === 'claimed' ? 'in_progress' : (metadata.stage || null),
     verify,
@@ -38,25 +41,29 @@ function dbToShimRow(row) {
 function dbBuckets(workspaceRoot) {
   const taskDb = require('./task-db');
   const db = taskDb.open();
-  const rows = taskDb.listTasks(db, { workspaceRoot, limit: 500 });
+  const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot, limit: 500 }));
   // Need raw source_key for merge dedup, plus the shim shape for callers.
   const backlog = [];
   const inProgress = [];
   const review = [];
   const completed = [];
   const sourceKeys = new Set();
+  const sourceRefs = new Set();
   // Query directly so the shim can dedup against markdown by the strong key
   // even if future list filters hide rows.
   const stmt = db.prepare('SELECT id, source_key FROM tasks WHERE workspace_root = ? AND source_key IS NOT NULL');
   for (const r of stmt.all(workspaceRoot)) sourceKeys.add(r.source_key);
   for (const r of rows) {
+    for (const ref of [r.id, r.display_id, r.legacy_ref, r.metadata?.todo_id]) {
+      if (ref) sourceRefs.add(String(ref).toLowerCase());
+    }
     const shaped = dbToShimRow(r);
     if (r.status === 'open') backlog.push(shaped);
     else if (r.status === 'claimed') inProgress.push(shaped);
     else if (r.status === 'review') review.push(shaped);
     else if (r.status === 'done' || r.status === 'failed') completed.push(shaped);
   }
-  return { backlog, inProgress, review, completed, sourceKeys };
+  return { backlog, inProgress, review, completed, sourceKeys, sourceRefs };
 }
 
 function mergeBuckets(dbBuck, mdBuck, todoPath) {
@@ -71,6 +78,7 @@ function mergeBuckets(dbBuck, mdBuck, todoPath) {
   for (const k of ['backlog', 'inProgress', 'review', 'completed']) {
     for (const r of dbBuck[k]) { out[k].push(r); seenTitles.add(norm(r.title)); }
     for (const r of mdBuck[k]) {
+      if (r.id && dbBuck.sourceRefs?.has(String(r.id).toLowerCase())) continue;
       const sk = todoPath ? taskDb.sourceKey(todoPath, r.title) : null;
       if (sk && dbBuck.sourceKeys && dbBuck.sourceKeys.has(sk)) continue;
       if (seenTitles.has(norm(r.title))) continue;
@@ -81,14 +89,19 @@ function mergeBuckets(dbBuck, mdBuck, todoPath) {
 }
 
 function parseTodo(todoPath) {
-  // Legacy pure-markdown path.
-  if (!TASK_DB_ENABLED) return fallback.parseTodoFile(todoPath);
+  const mdBuck = fallback.parseTodoFile(todoPath);
+  const compact = Object.values(mdBuck).some(rows => rows.some(row => Object.hasOwn(row, 'verify_preview')));
+  // Compact generated boards omit full commands. Resolve them from existing
+  // durable state even without the legacy opt-in, without minting a database.
+  if (!TASK_DB_ENABLED && !compact) return mdBuck;
 
   // DB-first merged view. Workspace scope = directory containing todoPath
   // (or its parent), so the DB stays per-repo.
   const path = require('path');
   const fs = require('fs');
-  const taskDb = require('./task-db');
+  let taskDb;
+  try { taskDb = require('./task-db'); } catch { return mdBuck; }
+  if (!TASK_DB_ENABLED && !fs.existsSync(taskDb.getDbPath())) return mdBuck;
   let workspaceRoot;
   try {
     const todoAbs = path.resolve(todoPath);
@@ -106,9 +119,8 @@ function parseTodo(todoPath) {
   } catch (e) {
     // If sqlite blew up (missing in node, perms), don't break the legacy path.
     if (process.env.ATRIS_DEBUG) console.error('[todo shim] db read failed:', e.message);
-    return fallback.parseTodoFile(todoPath);
+    return mdBuck;
   }
-  const mdBuck = fallback.parseTodoFile(todoPath);
   return mergeBuckets(dbBuck, mdBuck, todoPath);
 }