atris 3.15.13 → 3.15.22

package/lib/task-db.js

@@ -30,6 +30,13 @@ const { DatabaseSync } = require('node:sqlite');
 
 const DEFAULT_DB_PATH = path.join(os.homedir(), '.atris', 'tasks.db');
 const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
+const TODO_RENDER_DONE_LIMIT = 8;
+const PROJECTION_DONE_LIMIT = 8;
+const PROJECTION_EVENT_LIMIT = 8;
+const PROJECTION_MESSAGE_LIMIT = 6;
+const PROJECTION_PAYLOAD_TEXT_LIMIT = 1000;
+const AGENT_CERTIFICATION_REVIEW_PASSES = 2;
+const TASK_REF_GENERIC_TOKENS = new Set(['app', 'atris', 'atrisos', 'project', 'repo', 'workspace']);
 
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS tasks (
@@ -160,12 +167,91 @@ function sourceKey(sourceFile, title) {
   return h.digest('hex');
 }
 
+function normalizeTaskRef(value) {
+  return String(value || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+}
+
+function workspaceRefPrefix(ws) {
+  const base = path.basename(String(ws || 'task')).toLowerCase();
+  const parts = base.split(/[^a-z0-9]+/).filter(Boolean);
+  const useful = parts.filter(p => !TASK_REF_GENERIC_TOKENS.has(p));
+  if (useful.length > 1) {
+    const leading = useful.slice(0, -1).map(p => p[0]).join('').toUpperCase();
+    const last = useful[useful.length - 1].toUpperCase().replace(/[^A-Z0-9]/g, '');
+    const lastKey = last[0] + last.slice(1).replace(/[AEIOU]/g, '');
+    const combined = `${leading}${lastKey}`.replace(/[^A-Z0-9]/g, '');
+    if (combined) return combined.slice(0, 3).padEnd(3, 'X');
+  }
+  const picked = useful.pop()
+    || parts[parts.length - 1]
+    || 'task';
+  const token = picked.toUpperCase().replace(/[^A-Z0-9]/g, '');
+  if (!token) return 'TSK';
+  if (token.length <= 3) return token.padEnd(3, 'X');
+  const consonantKey = token[0] + token.slice(1).replace(/[AEIOU]/g, '');
+  return (consonantKey.length >= 3 ? consonantKey : token).slice(0, 3);
+}
+
+function taskDisplayRef(row, index) {
+  return `${workspaceRefPrefix(row && row.workspace_root)}-${Number(index) + 1}`;
+}
+
+function shortestUniqueTaskRef(id, ids, minLength = 8) {
+  const normalized = normalizeTaskRef(id);
+  if (!normalized) return '';
+  const all = (Array.isArray(ids) ? ids : []).map(normalizeTaskRef).filter(Boolean);
+  for (let length = Math.min(minLength, normalized.length); length <= normalized.length; length += 1) {
+    const prefix = normalized.slice(0, length);
+    const matches = all.filter(candidate => candidate.startsWith(prefix));
+    if (matches.length <= 1) return prefix;
+  }
+  return normalized;
+}
+
+function withTaskDisplayRefs(rows, refRows = rows) {
+  const list = Array.isArray(rows) ? rows : [];
+  const referenceInput = Array.isArray(refRows) ? refRows : list;
+  const referenceIds = new Set(referenceInput.map(row => row && row.id).filter(Boolean));
+  const referenceList = [
+    ...referenceInput,
+    ...list.filter(row => row && row.id && !referenceIds.has(row.id) && !(row.metadata && row.metadata.markdown_source)),
+  ];
+  const byWorkspace = new Map();
+  for (const row of referenceList) {
+    const key = row && row.workspace_root || '';
+    if (!byWorkspace.has(key)) byWorkspace.set(key, []);
+    byWorkspace.get(key).push(row);
+  }
+  const refs = new Map();
+  for (const group of byWorkspace.values()) {
+    const sorted = [...group]
+      .sort((a, b) => (Number(a.created_at || 0) - Number(b.created_at || 0)) || String(a.id || '').localeCompare(String(b.id || '')))
+    const ids = sorted.map(row => row && row.id);
+    sorted.forEach((row, index) => {
+      refs.set(row.id, {
+        display_id: taskDisplayRef(row, index),
+        legacy_ref: shortestUniqueTaskRef(row.id, ids, 8),
+      });
+    });
+  }
+  return list.map(row => ({ ...row, ...(refs.get(row.id) || {}) }));
+}
+
+function taskDisplayRefMap(rows) {
+  const map = new Map();
+  for (const row of withTaskDisplayRefs(rows)) {
+    map.set(row.id, row.display_id);
+  }
+  return map;
+}
+
 function addTask(db, { title, tag, workspaceRoot: ws, sourceKey: sk, metadata, status, claimedBy }) {
   if (!title || !String(title).trim()) throw new Error('title required');
   const now = Date.now();
   const id = newId();
-  const taskStatus = ['open', 'claimed', 'done', 'failed'].includes(status) ? status : 'open';
-  const claimedAt = taskStatus === 'claimed' ? now : null;
+  const taskStatus = ['open', 'claimed', 'review', 'done', 'failed'].includes(status) ? status : 'open';
+  const initialClaimedBy = (taskStatus === 'claimed' || taskStatus === 'review') ? (claimedBy || null) : null;
+  const claimedAt = initialClaimedBy ? now : null;
   // Idempotent on (workspace_root, source_key) when source_key supplied.
   if (sk) {
     const existing = db.prepare(
@@ -184,7 +270,7 @@ function addTask(db, { title, tag, workspaceRoot: ws, sourceKey: sk, metadata, s
     tag || null,
     ws,
     sk || null,
-    taskStatus === 'claimed' ? (claimedBy || null) : null,
+    initialClaimedBy,
     claimedAt,
     now,
     now,
@@ -217,7 +303,7 @@ function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
     FROM tasks
     ${where.length ? 'WHERE ' + where.join(' AND ') : ''}
     ORDER BY
-      CASE status WHEN 'open' THEN 0 WHEN 'claimed' THEN 1 WHEN 'failed' THEN 2 WHEN 'done' THEN 3 ELSE 4 END,
+      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,
       created_at DESC
     ${limit ? 'LIMIT ' + Number(limit) : ''}
   `;
@@ -272,23 +358,24 @@ function claimTask(db, { id, claimedBy }) {
   return { claimed: false, reason: 'already_' + row.status, claimed_by: row.claimed_by };
 }
 
-function doneTask(db, { id, status }) {
+function doneTask(db, { id, status, actor, allowReview = false }) {
   if (!id) throw new Error('id required');
   const final = status || 'done';
   if (!['done', 'failed'].includes(final)) throw new Error('status must be done|failed');
   const now = Date.now();
+  const allowedStatuses = allowReview ? "'open', 'claimed', 'review'" : "'open', 'claimed'";
   const result = withBusyRetry(() => db.prepare(`
     UPDATE tasks
        SET status = ?, done_at = ?, updated_at = ?
      WHERE id = ?
-       AND status IN ('open', 'claimed')
+       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);
     appendTaskEvent(db, {
       taskId: id,
       workspaceRoot: row.workspace_root,
-      actor: process.env.ATRIS_AGENT_ID || process.env.USER || null,
+      actor: actor || process.env.ATRIS_AGENT_ID || process.env.USER || null,
       eventType: final === 'done' ? 'completed' : 'blocked',
       payload: { status: final },
     });
@@ -296,6 +383,117 @@ function doneTask(db, { id, status }) {
   return { updated: result.changes === 1 };
 }
 
+function readyTask(db, { id, actor, proof, lesson, nextTask }) {
+  if (!id) throw new Error('id required');
+  const text = String(proof || '').trim();
+  if (!text) throw new Error('proof required');
+  const row = getTask(db, id);
+  if (!row) return { ready: false, reason: 'not_found' };
+  if (!['open', 'claimed', 'review'].includes(row.status)) {
+    return { ready: false, reason: `already_${row.status}` };
+  }
+  const now = Date.now();
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  const reviewPassCount = Number(metadata.agent_review_pass_count || 0) + 1;
+  metadata.approval_status = 'pending';
+  metadata.agent_review_pass_count = reviewPassCount;
+  metadata.agent_reviewed_at = new Date(now).toISOString();
+  metadata.agent_reviewed_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
+  metadata.latest_agent_proof = text;
+  metadata.latest_agent_lesson = String(lesson || '').trim() || null;
+  metadata.latest_agent_next_task = String(nextTask || '').trim() || null;
+  if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES) {
+    metadata.agent_certified = true;
+    metadata.agent_certified_at = new Date(now).toISOString();
+    metadata.agent_certified_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
+    metadata.agent_certification_policy = `${AGENT_CERTIFICATION_REVIEW_PASSES}_agent_review_passes`;
+  }
+  const result = withBusyRetry(() => db.prepare(`
+    UPDATE tasks
+       SET status = 'review',
+           done_at = NULL,
+           updated_at = ?,
+           metadata = ?
+     WHERE id = ?
+       AND status IN ('open', 'claimed', 'review')
+  `).run(now, JSON.stringify(metadata), id));
+  if (result.changes !== 1) return { ready: false, reason: 'not_open_claimed_or_review' };
+  const updated = getTask(db, id);
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: updated.workspace_root,
+    actor: actor || null,
+    eventType: 'proof_ready',
+    payload: {
+      proof: text,
+      lesson: metadata.latest_agent_lesson,
+      next_task: metadata.latest_agent_next_task,
+      approval_status: 'pending',
+      review_pass_count: reviewPassCount,
+      agent_certified: metadata.agent_certified === true,
+      agent_certification_policy: metadata.agent_certification_policy || null,
+    },
+  });
+  return { ready: true, event, row: updated };
+}
+
+function reviseTask(db, { id, actor, note }) {
+  if (!id) throw new Error('id required');
+  const text = String(note || '').trim();
+  if (!text) throw new Error('note required');
+  const row = getTask(db, id);
+  if (!row) return { revised: false, reason: 'not_found' };
+  if (row.status !== 'review') {
+    return { revised: false, reason: `not_reviewable_${row.status}` };
+  }
+  const now = Date.now();
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  const revisionCount = Number(metadata.human_revision_count || 0) + 1;
+  for (const key of [
+    'agent_review_pass_count',
+    'agent_reviewed_at',
+    'agent_reviewed_by',
+    'latest_agent_proof',
+    'latest_agent_lesson',
+    'latest_agent_next_task',
+    'agent_certified',
+    'agent_certified_at',
+    'agent_certified_by',
+    'agent_certification_policy',
+  ]) {
+    delete metadata[key];
+  }
+  metadata.approval_status = 'revise';
+  metadata.human_revision_count = revisionCount;
+  metadata.human_revision_at = new Date(now).toISOString();
+  metadata.human_revision_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
+  metadata.human_revision_note = text;
+  const revisedStatus = row.claimed_by ? 'claimed' : 'open';
+  const result = withBusyRetry(() => db.prepare(`
+    UPDATE tasks
+       SET status = ?,
+           done_at = NULL,
+           updated_at = ?,
+           metadata = ?
+     WHERE id = ?
+       AND status = 'review'
+  `).run(revisedStatus, now, JSON.stringify(metadata), id));
+  if (result.changes !== 1) return { revised: false, reason: 'not_updated' };
+  const updated = getTask(db, id);
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: updated.workspace_root,
+    actor: actor || null,
+    eventType: 'revision_requested',
+    payload: {
+      note: text,
+      approval_status: 'revise',
+      revision_count: revisionCount,
+    },
+  });
+  return { revised: true, event, row: updated };
+}
+
 function appendTaskEvent(db, { taskId, workspaceRoot: ws, actor, eventType, payload }) {
   if (!taskId) throw new Error('taskId required');
   if (!ws) throw new Error('workspaceRoot required');
@@ -329,16 +527,17 @@ function appendTaskEvent(db, { taskId, workspaceRoot: ws, actor, eventType, payl
   };
 }
 
-function listTaskEvents(db, { taskId, workspaceRoot: ws, limit }) {
+function listTaskEvents(db, { taskId, workspaceRoot: ws, limit, order = 'asc' }) {
   const where = [];
   const args = [];
   if (taskId) { where.push('task_id = ?'); args.push(taskId); }
   if (ws) { where.push('workspace_root = ?'); args.push(ws); }
+  const sort = String(order || '').toLowerCase() === 'desc' ? 'DESC' : 'ASC';
   const sql = `
     SELECT event_id, task_id, version, workspace_root, actor, event_type, payload, created_at
     FROM task_events
     ${where.length ? 'WHERE ' + where.join(' AND ') : ''}
-    ORDER BY created_at ASC, version ASC
+    ORDER BY created_at ${sort}, version ${sort}
     ${limit ? 'LIMIT ' + Number(limit) : ''}
   `;
   return db.prepare(sql).all(...args).map(r => ({
@@ -363,17 +562,34 @@ function noteTask(db, { id, actor, content }) {
   return { noted: true, event };
 }
 
-function reviewTask(db, { id, actor, reward, lesson, nextTask, proof }) {
+function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, careerXpEligible = false, clearedFields = [] }) {
   if (!id) throw new Error('id required');
   const row = getTask(db, id);
   if (!row) return { reviewed: false, reason: 'not_found' };
   const numericReward = Number.isFinite(Number(reward)) ? Number(reward) : 0;
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  if (numericReward > 0 && row.status === 'done') {
+    metadata.approval_status = 'accepted';
+    metadata.accepted_at = new Date().toISOString();
+    metadata.accepted_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
+    withBusyRetry(() => db.prepare(`
+      UPDATE tasks
+         SET metadata = ?,
+             updated_at = ?
+       WHERE id = ?
+    `).run(JSON.stringify(metadata), Date.now(), id));
+  }
   const payload = {
     reward: numericReward,
     lesson: String(lesson || '').trim(),
     next_task: String(nextTask || '').trim() || null,
     proof: String(proof || '').trim() || null,
+    career_xp_eligible: Boolean(careerXpEligible),
   };
+  const clearedReviewFields = Array.isArray(clearedFields)
+    ? Array.from(new Set(clearedFields.filter(field => field === 'lesson' || field === 'next_task')))
+    : [];
+  if (clearedReviewFields.length) payload.cleared_review_fields = clearedReviewFields;
   const event = appendTaskEvent(db, {
     taskId: id,
     workspaceRoot: row.workspace_root,
@@ -381,12 +597,44 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof }) {
     eventType: 'reviewed',
     payload,
   });
-  const episode = taskEpisodeFromReview(row, event, payload);
+  const episode = taskEpisodeFromReview({ ...row, metadata }, event, payload);
   appendTaskEpisode(row.workspace_root, episode);
   return { reviewed: true, event, episode };
 }
 
+function compactEpisodeText(value, max = 240) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return null;
+  return text.length > max ? `${text.slice(0, Math.max(0, max - 3)).trim()}...` : text;
+}
+
+function goalSignalFromTaskMetadata(metadata) {
+  const goalId = compactEpisodeText(metadata.goal_id || metadata.goalId || metadata.goal?.id || '', 120);
+  const objective = compactEpisodeText(
+    metadata.goal_objective || metadata.goalObjective || metadata.goal?.objective || metadata.goal || '',
+    240,
+  );
+  if (!goalId && !objective) return null;
+  return {
+    goal_id: goalId,
+    objective,
+  };
+}
+
+function reviewOutcomeLabel(reward) {
+  const value = Number(reward);
+  if (!Number.isFinite(value)) return 'reviewed';
+  if (value > 0) return 'accepted';
+  if (value < 0) return 'rejected';
+  return 'revised';
+}
+
 function taskEpisodeFromReview(row, event, payload) {
+  const metadata = row.metadata || {};
+  const rewardValue = Number(payload.reward);
+  const hasProof = Boolean(String(payload.proof || '').trim());
+  const label = reviewOutcomeLabel(payload.reward);
+  const doneForXp = row.status === 'done';
   return {
     schema: 'atris.task_episode.v1',
     episode_id: event.event_id,
@@ -398,7 +646,7 @@ function taskEpisodeFromReview(row, event, payload) {
       status: row.status,
       tag: row.tag,
       claimed_by: row.claimed_by,
-      metadata: row.metadata || {},
+      metadata,
     },
     action: {
       event_type: 'reviewed',
@@ -412,6 +660,21 @@ function taskEpisodeFromReview(row, event, payload) {
     lesson: payload.lesson,
     proof: payload.proof,
     next_task_suggestion: payload.next_task,
+    goal: goalSignalFromTaskMetadata(metadata),
+    career_xp: {
+      eligible: payload.career_xp_eligible === true && label === 'accepted' && hasProof && doneForXp,
+      source: 'task_review',
+      reward: Number.isFinite(rewardValue) ? rewardValue : 0,
+      proof_required: true,
+    },
+    rl: {
+      label,
+      source: 'task_review',
+      reward: Number.isFinite(rewardValue) ? rewardValue : 0,
+      has_proof: hasProof,
+      has_lesson: Boolean(String(payload.lesson || '').trim()),
+      has_next_task: Boolean(String(payload.next_task || '').trim()),
+    },
   };
 }
 
@@ -422,10 +685,81 @@ function appendTaskEpisode(workspaceRoot, episode) {
   return filePath;
 }
 
-function taskProjection(db, { workspaceRoot: ws, taskId, limit = 500 } = {}) {
+function clipProjectionText(value, max = PROJECTION_PAYLOAD_TEXT_LIMIT) {
+  const text = String(value || '');
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function compactProjectionPayload(value) {
+  if (typeof value === 'string') return clipProjectionText(value);
+  if (!value || typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.slice(0, 20).map(compactProjectionPayload);
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item === 'string') out[key] = clipProjectionText(item);
+    else if (item && typeof item === 'object') out[key] = compactProjectionPayload(item);
+    else out[key] = item;
+  }
+  return out;
+}
+
+function compactProjectionEvent(event) {
+  return {
+    ...event,
+    payload: compactProjectionPayload(event.payload),
+  };
+}
+
+function selectProjectionRows(rows, { taskId, includeHistory, doneLimit }) {
+  if (taskId || includeHistory) {
+    return {
+      visibleRows: rows,
+      hiddenDoneCount: 0,
+    };
+  }
+  const visibleRows = [];
+  let shownDone = 0;
+  let hiddenDoneCount = 0;
+  for (const row of rows) {
+    if (row.status === 'done') {
+      if (shownDone < doneLimit) {
+        visibleRows.push(row);
+        shownDone += 1;
+      } else {
+        hiddenDoneCount += 1;
+      }
+      continue;
+    }
+    visibleRows.push(row);
+  }
+  return { visibleRows, hiddenDoneCount };
+}
+
+function taskProjection(db, {
+  workspaceRoot: ws,
+  taskId,
+  limit = 500,
+  includeHistory = Boolean(taskId),
+  doneLimit = PROJECTION_DONE_LIMIT,
+  eventLimit = PROJECTION_EVENT_LIMIT,
+  messageLimit = PROJECTION_MESSAGE_LIMIT,
+} = {}) {
   const rows = taskId
     ? [getTask(db, taskId)].filter(Boolean)
     : listTasks(db, { workspaceRoot: ws || null, limit });
+  const refRows = taskId && rows[0]
+    ? listTasks(db, { workspaceRoot: rows[0].workspace_root })
+    : listTasks(db, { workspaceRoot: ws || null });
+  const refById = new Map(withTaskDisplayRefs(refRows).map(row => [row.id, {
+    display_id: row.display_id,
+    legacy_ref: row.legacy_ref,
+  }]));
+  const { visibleRows, hiddenDoneCount } = selectProjectionRows(rows, {
+    taskId,
+    includeHistory,
+    doneLimit: Math.max(0, Number(doneLimit) || 0),
+  });
   const events = listTaskEvents(db, {
     taskId: taskId || null,
     workspaceRoot: taskId ? null : (ws || null),
@@ -440,19 +774,32 @@ function taskProjection(db, { workspaceRoot: ws, taskId, limit = 500 } = {}) {
     schema: 'atris.task_projection.v1',
     generated_at: new Date().toISOString(),
     workspace_root: ws || (rows[0] && rows[0].workspace_root) || null,
-    tasks: rows.map(row => {
+    surface: {
+      compact: !includeHistory,
+      full_task_count: rows.length,
+      visible_task_count: visibleRows.length,
+      hidden_done_count: hiddenDoneCount,
+      done_limit: includeHistory ? null : Math.max(0, Number(doneLimit) || 0),
+      event_limit: includeHistory ? null : Math.max(0, Number(eventLimit) || 0),
+      message_limit: includeHistory ? null : Math.max(0, Number(messageLimit) || 0),
+      full_ledger_command: taskId ? `atris task events ${taskId}` : 'atris task events --all',
+    },
+    tasks: visibleRows.map(row => {
       const taskEvents = byTask.get(row.id) || [];
       const latest = taskEvents.length ? taskEvents[taskEvents.length - 1] : null;
-      const messages = taskEvents
+      const allMessages = taskEvents
         .filter(e => e.event_type === 'message')
         .map(e => ({
           version: e.version,
           actor: e.actor,
-          content: e.payload && e.payload.content || '',
+          content: clipProjectionText(e.payload && e.payload.content || ''),
           created_at: e.created_at,
         }));
+      const visibleMessages = includeHistory ? allMessages : allMessages.slice(-Math.max(0, Number(messageLimit) || 0));
+      const visibleEvents = includeHistory ? taskEvents : taskEvents.slice(-Math.max(0, Number(eventLimit) || 0)).map(compactProjectionEvent);
       return {
         id: row.id,
+        ...(refById.get(row.id) || {}),
         title: row.title,
         status: row.status,
         tag: row.tag,
@@ -464,25 +811,47 @@ function taskProjection(db, { workspaceRoot: ws, taskId, limit = 500 } = {}) {
         metadata: row.metadata || {},
         current_version: latest ? latest.version : 0,
         latest_event_type: latest ? latest.event_type : null,
-        messages,
-        events: taskEvents,
+        messages: visibleMessages,
+        events: visibleEvents,
+        history: {
+          event_count: taskEvents.length,
+          message_count: allMessages.length,
+          events_visible: visibleEvents.length,
+          messages_visible: visibleMessages.length,
+          events_truncated: !includeHistory && taskEvents.length > visibleEvents.length,
+          messages_truncated: !includeHistory && allMessages.length > visibleMessages.length,
+        },
       };
     }),
   };
 }
 
-function renderTodoMarkdown(rows, { title = 'TODO.md' } = {}) {
+function renderTodoMarkdown(rows, { title = 'TODO.md', doneLimit = TODO_RENDER_DONE_LIMIT, refRows = rows, preservedSections = [] } = {}) {
+  const displayRows = withTaskDisplayRefs(rows, refRows);
   const buckets = {
-    open: rows.filter(r => r.status === 'open'),
-    claimed: rows.filter(r => r.status === 'claimed'),
-    failed: rows.filter(r => r.status === 'failed'),
-    done: rows.filter(r => r.status === 'done'),
+    open: displayRows.filter(r => r.status === 'open'),
+    claimed: displayRows.filter(r => r.status === 'claimed'),
+    review: displayRows.filter(r => r.status === 'review'),
+    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.', ''];
+  for (const section of preservedSections) {
+    const text = String(section || '').trim();
+    if (!text) continue;
+    lines.push(text, '');
+  }
   appendSection(lines, 'Backlog', buckets.open);
   appendSection(lines, 'In Progress', buckets.claimed);
+  appendSection(lines, 'Review', buckets.review);
   appendSection(lines, 'Blocked', buckets.failed);
-  appendSection(lines, 'Completed', buckets.done);
+  const renderedDone = buckets.done.slice(0, Math.max(0, Number(doneLimit) || 0));
+  appendSection(lines, 'Completed', renderedDone);
+  const archivedDone = Math.max(0, buckets.done.length - renderedDone.length);
+  if (archivedDone > 0) {
+    lines.push(`(${archivedDone} older completed task${archivedDone === 1 ? '' : 's'} archived in \`atris task list --status done\` and \`atris task events\`.)`, '');
+  }
+  while (lines[lines.length - 1] === '') lines.pop();
   return lines.join('\n') + '\n';
 }
 
@@ -493,10 +862,16 @@ function appendSection(lines, name, rows) {
     return;
   }
   for (const row of rows) {
-    const tag = row.tag ? ` [${row.tag}]` : '';
-    lines.push(`- **[${row.id}]** ${row.title}${tag}`);
-    if (row.claimed_by && row.status === 'claimed') lines.push(`  **Claimed by:** ${row.claimed_by}`);
     const meta = row.metadata || {};
+    const tags = Array.isArray(meta.todo_tags) && meta.todo_tags.length
+      ? meta.todo_tags
+      : (row.tag ? [row.tag] : []);
+    const tag = [...new Set(tags.filter(Boolean).map(value => String(value).trim()).filter(Boolean))]
+      .map(value => ` [${value}]`)
+      .join('');
+    const displayRef = meta.todo_id || row.display_id || row.id;
+    lines.push(`- **[${displayRef}]** ${row.title}${tag}`);
+    if (row.claimed_by && row.status === 'claimed') lines.push(`  **Claimed by:** ${row.claimed_by}`);
     if (meta.verify) lines.push(`  **Verify:** ${meta.verify}`);
   }
   lines.push('');
@@ -543,12 +918,18 @@ module.exports = {
   listTasks,
   claimTask,
   doneTask,
+  readyTask,
+  reviseTask,
   noteTask,
   reviewTask,
   appendTaskEvent,
   listTaskEvents,
   taskProjection,
   renderTodoMarkdown,
+  normalizeTaskRef,
+  shortestUniqueTaskRef,
+  taskDisplayRefMap,
+  withTaskDisplayRefs,
   newId,
   // Test surface
   _SCHEMA: SCHEMA,

package/lib/todo-fallback.js

@@ -10,11 +10,12 @@ const fs = require('fs');
 const path = require('path');
 
 function parseTodoFile(todoPath) {
-  if (!fs.existsSync(todoPath)) return { backlog: [], inProgress: [], completed: [] };
+  if (!fs.existsSync(todoPath)) return { backlog: [], inProgress: [], review: [], completed: [] };
   const content = fs.readFileSync(todoPath, 'utf8');
   return {
     backlog: parseSection(content, 'Backlog'),
     inProgress: parseSection(content, 'In Progress'),
+    review: parseSection(content, 'Review'),
     completed: parseSection(content, 'Completed'),
   };
 }
@@ -37,7 +38,7 @@ function cleanTaskTitle(text) {
 
 function parseSection(content, sectionName) {
   const escaped = sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const match = content.match(new RegExp(`(?:^|\\n)##\\s+${escaped}\\s*\\n([\\s\\S]*?)(?=\\n##(?!#)\\s+|$)`, 'i'));
+  const match = content.match(new RegExp(`(?:^|\\n)##\\s+${escaped}[^\\n]*\\n([\\s\\S]*?)(?=\\n##(?!#)\\s+|$)`, 'i'));
   if (!match) return [];
 
   const body = (match[1] || '').trim();
@@ -50,6 +51,15 @@ function parseSection(content, sectionName) {
   for (const rawLine of lines) {
     const line = rawLine.trimEnd();
 
+    // Strikethrough = done. `- ~~**id:** ...~~ DONE ...` lines are kept in
+    // Backlog for rollback context but must not be picked as live work.
+    // Otherwise the autopilot picker re-selects them every tick and halts on
+    // "no Verify: field" (lessons.md: no-verify-field, 8 occurrences 2026-05-08..10).
+    if (/^- ~~/.test(line)) {
+      if (current) { tasks.push(current); current = null; }
+      continue;
+    }
+
     const taskMatch = line.match(/^- \*\*([^*:\n]+):\*\*\s*(.+)$/);
     if (taskMatch) {
       if (current) tasks.push(current);
@@ -66,6 +76,22 @@ function parseSection(content, sectionName) {
       continue;
     }
 
+    const bracketTaskMatch = line.match(/^- \*\*\[([^\]\n]+)\]\*\*\s+(.+)$/);
+    if (bracketTaskMatch) {
+      if (current) tasks.push(current);
+      const { allTags, tag } = tagsFromText(bracketTaskMatch[2]);
+      current = {
+        id: bracketTaskMatch[1],
+        title: cleanTaskTitle(bracketTaskMatch[2]),
+        tag,
+        tags: allTags,
+        claimed: null,
+        stage: null,
+        verify: null,
+      };
+      continue;
+    }
+
     const checkMatch = line.match(/^- \[[ x]\]\s+(.+)$/);
     if (checkMatch) {
       if (current) {