atris 3.15.57 → 3.16.0

package/lib/task-db.js

@@ -31,12 +31,33 @@ 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 TODO_RENDER_FAILED_LIMIT = 12;
 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 TASK_PLAN_TAGS = new Set([
+  'agent',
+  'autopilot',
+  'cron',
+  'endgame',
+  'execute',
+  'explore',
+  'feature',
+  'goal',
+  'goal-step',
+  'loop',
+  'plan',
+  'planned',
+  'schedule',
+  'scheduled',
+  'shape',
+  'shaping',
+  'ui',
+  'ux',
+]);
 
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS tasks (
@@ -494,6 +515,431 @@ function reviseTask(db, { id, actor, note }) {
   return { revised: true, event, row: updated };
 }
 
+function cleanStageText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function normalizedTaskPart(value) {
+  return cleanStageText(value).toLowerCase().replace(/\s+/g, '-');
+}
+
+function backlogTag(value) {
+  const requested = cleanStageText(value) || 'capture';
+  return TASK_PLAN_TAGS.has(normalizedTaskPart(requested)) ? 'capture' : requested;
+}
+
+function taskHasPlanSignal(row) {
+  const metadata = row && row.metadata && typeof row.metadata === 'object' ? row.metadata : {};
+  const tag = normalizedTaskPart(row && row.tag);
+  const stage = normalizedTaskPart(metadata.stage);
+  return TASK_PLAN_TAGS.has(tag)
+    || TASK_PLAN_TAGS.has(stage)
+    || Boolean(
+      metadata.planned_at
+      || metadata.stage_plan_recorded_at
+      || metadata.verify
+      || metadata.proof_needed
+      || metadata.exit_condition
+      || metadata.stage_goal
+      || metadata.stage_owner
+      || metadata.goal
+      || metadata.loop
+      || metadata.cron
+      || metadata.next_run_at
+    );
+}
+
+function clearPlanMetadata(metadata, { actor, reason, previousTag } = {}) {
+  const next = metadata && typeof metadata === 'object' ? { ...metadata } : {};
+  const clearedKeys = [];
+  const taskGoal = cleanStageText(next.task_goal || next.goal_objective || next.objective || next.stage_goal);
+  if (taskGoal && !next.task_goal) next.task_goal = taskGoal;
+  for (const key of [
+    'stage',
+    'stage_goal',
+    'stage_summary',
+    'exit_condition',
+    'verify',
+    'proof_needed',
+    'first_move',
+    'next_button',
+    'stage_updated_at',
+    'stage_updated_by',
+    'stage_owner',
+    'stage_confidence',
+    'goal_objective',
+    'objective',
+    'goal',
+    'loop',
+    'cron',
+    'next_run_at',
+    'planned_at',
+    'planned_by',
+    'stage_plan_recorded_at',
+  ]) {
+    if (next[key] !== undefined) {
+      delete next[key];
+      clearedKeys.push(key);
+    }
+  }
+  const delegatedAssignment = Boolean(metadata.delegate_via || metadata.swarlo_channel || metadata.created_for_day);
+  if (
+    next.assigned_to
+    && !delegatedAssignment
+    && (next.assigned_to === metadata.stage_owner || next.assigned_to === metadata.planned_by)
+  ) {
+    delete next.assigned_to;
+    clearedKeys.push('assigned_to');
+  }
+  next.backlogged_at = new Date().toISOString();
+  next.backlogged_by = cleanStageText(actor) || null;
+  next.backlog_reason = cleanStageText(reason) || 'clear_plan';
+  if (previousTag) next.backlog_previous_tag = previousTag;
+  return { metadata: next, clearedKeys };
+}
+
+function backlogTask(db, { id, actor, reason, tag = 'capture' }) {
+  if (!id) throw new Error('id required');
+  const row = getTask(db, id);
+  if (!row) return { backlogged: false, reason: 'not_found' };
+  if (row.status !== 'open') {
+    return { backlogged: false, reason: `already_${row.status}`, claimed_by: row.claimed_by || null };
+  }
+  if (!taskHasPlanSignal(row)) return { backlogged: false, reason: 'not_planned' };
+
+  const actorText = cleanStageText(actor) || null;
+  const previousTag = row.tag || null;
+  const nextTag = backlogTag(tag);
+  const { metadata, clearedKeys } = clearPlanMetadata(row.metadata || {}, {
+    actor: actorText,
+    reason,
+    previousTag: previousTag && normalizedTaskPart(previousTag) !== normalizedTaskPart(nextTag) ? previousTag : null,
+  });
+  const now = Math.max(Date.now(), Number(row.updated_at || 0) + 1);
+  const result = withBusyRetry(() => db.prepare(`
+    UPDATE tasks
+       SET tag = ?,
+           metadata = ?,
+           updated_at = ?
+     WHERE id = ?
+       AND status = 'open'
+       AND updated_at = ?
+  `).run(nextTag, JSON.stringify(metadata), now, id, row.updated_at));
+  if (result.changes !== 1) return { backlogged: false, reason: 'stale_task_state' };
+  const updated = getTask(db, id);
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: updated.workspace_root,
+    actor: actorText,
+    eventType: 'task_backlogged',
+    payload: {
+      reason: cleanStageText(reason) || 'clear_plan',
+      previous_tag: previousTag,
+      tag: nextTag,
+      cleared_keys: clearedKeys,
+    },
+  });
+  return { backlogged: true, event, row: updated, cleared_keys: clearedKeys };
+}
+
+function clearPlanTasks(db, { workspaceRoot: ws, actor, reason, tag = 'capture', limit } = {}) {
+  const rows = listTasks(db, { workspaceRoot: ws || null, status: 'open', limit }).filter(taskHasPlanSignal);
+  const cleared = [];
+  const skipped = [];
+  for (const row of rows) {
+    const result = backlogTask(db, {
+      id: row.id,
+      actor,
+      reason: reason || 'clear_plan_bulk',
+      tag,
+    });
+    if (result.backlogged) cleared.push(result.row);
+    else skipped.push({ id: row.id, reason: result.reason });
+  }
+  return { cleared, skipped };
+}
+
+function stagePacketFromPayload(payload) {
+  const data = payload && typeof payload === 'object' ? payload : {};
+  const lines = [
+    'TASK_STAGE_UPDATE',
+    `stage: ${cleanStageText(data.stage)}`,
+  ];
+  if (data.confidence !== undefined && data.confidence !== null) lines.push(`confidence: ${data.confidence}`);
+  if (data.summary) lines.push(`summary: ${data.summary}`);
+  if (data.owner) lines.push(`owner: ${data.owner}`);
+  if (data.goal) lines.push(`goal: ${data.goal}`);
+  if (data.exit) lines.push(`exit: ${data.exit}`);
+  if (data.proof_needed) lines.push(`proof_needed: ${data.proof_needed}`);
+  if (data.first_move) lines.push(`first_move: ${data.first_move}`);
+  if (data.next_button) lines.push(`next_button: ${data.next_button}`);
+  return lines.filter(Boolean).join('\n');
+}
+
+function backlogPacketFromPayload(payload) {
+  const data = payload && typeof payload === 'object' ? payload : {};
+  const lines = [
+    'TASK_BACKLOG_UPDATE',
+    `reason: ${cleanStageText(data.reason || 'clear_plan')}`,
+  ];
+  if (data.previous_tag) lines.push(`previous_tag: ${cleanStageText(data.previous_tag)}`);
+  if (data.tag) lines.push(`tag: ${cleanStageText(data.tag)}`);
+  if (Array.isArray(data.cleared_keys) && data.cleared_keys.length) lines.push(`cleared_keys: ${data.cleared_keys.join(', ')}`);
+  return lines.filter(Boolean).join('\n');
+}
+
+function stageTask(db, {
+  id,
+  actor,
+  stage,
+  goal,
+  summary,
+  owner,
+  exit,
+  proofNeeded,
+  firstMove,
+  nextButton,
+  confidence,
+}) {
+  if (!id) throw new Error('id required');
+  const targetStage = cleanStageText(stage).toLowerCase();
+  if (!['plan', 'do'].includes(targetStage)) throw new Error('stage must be plan|do');
+  const row = getTask(db, id);
+  if (!row) return { staged: false, reason: 'not_found' };
+  if (['done', 'failed'].includes(row.status)) return { staged: false, reason: `already_${row.status}` };
+  if (row.status === 'review') return { staged: false, reason: 'not_reviewable_use_revise' };
+
+  const requestedOwner = cleanStageText(owner);
+  const requestedGoal = cleanStageText(goal);
+  const requestedProof = cleanStageText(proofNeeded);
+  const requestedExit = cleanStageText(exit);
+  const actorText = cleanStageText(actor);
+  let metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  let stageOwner = requestedOwner || actorText || cleanStageText(row.claimed_by) || null;
+  let goalText = requestedGoal || cleanStageText(metadata.task_goal || metadata.goal_objective || metadata.objective || metadata.stage_goal);
+  let proofText = requestedProof || cleanStageText(metadata.verify || metadata.proof_needed);
+  let exitText = requestedExit || cleanStageText(metadata.exit_condition);
+
+  function recordedDoPlan(currentRow, { claimedOwnerWins = false } = {}) {
+    const currentMetadata = currentRow && currentRow.metadata && typeof currentRow.metadata === 'object'
+      ? { ...currentRow.metadata }
+      : {};
+    const claimedOwner = cleanStageText(currentRow && currentRow.claimed_by);
+    const planOwner = cleanStageText(currentMetadata.stage_owner || currentMetadata.assigned_to);
+    const recordedOwner = claimedOwnerWins && claimedOwner ? claimedOwner : (claimedOwner || planOwner);
+    const caller = actorText || requestedOwner || null;
+    const recordedGoal = cleanStageText(currentMetadata.goal_objective || currentMetadata.objective || currentMetadata.stage_goal || currentMetadata.task_goal);
+    const recordedProof = cleanStageText(currentMetadata.verify || currentMetadata.proof_needed);
+    const recordedExit = cleanStageText(currentMetadata.exit_condition);
+    const planRecorded = cleanStageText(currentMetadata.planned_at)
+      || cleanStageText(currentMetadata.stage) === 'plan'
+      || cleanStageText(currentMetadata.stage_plan_recorded_at);
+    if (!planRecorded) {
+      return { ok: false, reason: requestedGoal || requestedProof || requestedExit ? 'plan_required' : 'goal_required' };
+    }
+    if (!recordedGoal) return { ok: false, reason: 'goal_required' };
+    if (!recordedExit) return { ok: false, reason: 'exit_required' };
+    if (!recordedProof) return { ok: false, reason: 'proof_needed_required' };
+    if (requestedGoal && requestedGoal !== recordedGoal) return { ok: false, reason: 'plan_goal_mismatch' };
+    if (requestedProof && requestedProof !== recordedProof) return { ok: false, reason: 'plan_proof_mismatch' };
+    if (requestedExit && requestedExit !== recordedExit) return { ok: false, reason: 'plan_exit_mismatch' };
+    if (claimedOwner && planOwner && claimedOwner !== planOwner && !claimedOwnerWins) {
+      return { ok: false, reason: 'claimed_by_other', claimed_by: planOwner };
+    }
+    if (recordedOwner && caller && recordedOwner !== caller) {
+      return { ok: false, reason: 'claimed_by_other', claimed_by: recordedOwner };
+    }
+    return {
+      ok: true,
+      metadata: currentMetadata,
+      stageOwner: recordedOwner || requestedOwner || actorText || null,
+      goalText: recordedGoal,
+      proofText: recordedProof,
+      exitText: recordedExit,
+    };
+  }
+
+  if (targetStage === 'plan') {
+    if (!goalText) return { staged: false, reason: 'goal_required' };
+    if (!exitText || !proofText) {
+      return { staged: false, reason: !exitText ? 'exit_required' : 'proof_needed_required' };
+    }
+    const claimedBy = cleanStageText(row.claimed_by);
+    if (row.status === 'claimed' && claimedBy) {
+      if ((actorText && actorText !== claimedBy) || (requestedOwner && requestedOwner !== claimedBy)) {
+        return { staged: false, reason: 'claimed_by_other', claimed_by: claimedBy };
+      }
+      stageOwner = claimedBy;
+    }
+  } else {
+    const plan = recordedDoPlan(row, { claimedOwnerWins: row.status === 'claimed' });
+    if (!plan.ok) return { staged: false, reason: plan.reason, claimed_by: plan.claimed_by || null };
+    metadata = plan.metadata;
+    stageOwner = plan.stageOwner;
+    goalText = plan.goalText;
+    proofText = plan.proofText;
+    exitText = plan.exitText;
+  }
+
+  const hasConfidence = confidence !== undefined && confidence !== null && confidence !== '';
+  const confidenceValue = hasConfidence ? Number(confidence) : NaN;
+
+  let workingRow = row;
+  let claimedFromOpen = false;
+  let claimedFromUnowned = false;
+  let claimedWorker = null;
+  function rollbackOpenDoClaim(reasonRow) {
+    if (!claimedFromOpen || !claimedWorker || !reasonRow) return;
+    const rollbackTime = Math.max(Date.now(), Number(reasonRow.updated_at || 0) + 1);
+    withBusyRetry(() => db.prepare(`
+      UPDATE tasks
+         SET status = 'open',
+             claimed_by = NULL,
+             claimed_at = NULL,
+             updated_at = ?
+       WHERE id = ?
+         AND status = 'claimed'
+         AND claimed_by IS ?
+         AND updated_at = ?
+    `).run(rollbackTime, id, claimedWorker, reasonRow.updated_at));
+  }
+  if (targetStage === 'do' && workingRow.status === 'open') {
+    claimedWorker = stageOwner || cleanStageText(actor) || process.env.ATRIS_AGENT_ID || process.env.USER || 'unknown';
+    const claimTime = Math.max(Date.now(), Number(workingRow.updated_at || 0) + 1);
+    const claimed = withBusyRetry(() => db.prepare(`
+      UPDATE tasks
+         SET status = 'claimed',
+             claimed_by = ?,
+             claimed_at = ?,
+             updated_at = ?
+       WHERE id = ?
+         AND status = 'open'
+         AND updated_at = ?
+    `).run(claimedWorker, claimTime, claimTime, id, workingRow.updated_at));
+    if (claimed.changes !== 1) return { staged: false, reason: 'stale_task_state' };
+    claimedFromOpen = true;
+    workingRow = getTask(db, id);
+    if (!workingRow) return { staged: false, reason: 'not_found' };
+    const plan = recordedDoPlan(workingRow);
+    if (!plan.ok) {
+      rollbackOpenDoClaim(workingRow);
+      return { staged: false, reason: plan.reason, claimed_by: plan.claimed_by || null };
+    }
+    metadata = plan.metadata;
+    stageOwner = plan.stageOwner;
+    goalText = plan.goalText;
+    proofText = plan.proofText;
+    exitText = plan.exitText;
+  }
+
+  const updateTime = Math.max(Date.now(), Number(workingRow && workingRow.updated_at || row.updated_at || 0) + 1);
+  const updateIso = new Date(updateTime).toISOString();
+  metadata.stage = targetStage;
+  metadata.task_goal = goalText;
+  metadata.goal_objective = goalText;
+  metadata.stage_goal = goalText;
+  if (targetStage === 'plan') {
+    metadata.planned_at = updateIso;
+    metadata.planned_by = cleanStageText(actor) || null;
+    metadata.stage_plan_recorded_at = metadata.planned_at;
+  }
+  metadata.stage_summary = cleanStageText(summary) || metadata.stage_summary || null;
+  metadata.exit_condition = exitText || metadata.exit_condition || null;
+  metadata.verify = proofText || metadata.verify || null;
+  metadata.proof_needed = proofText || metadata.proof_needed || null;
+  metadata.first_move = cleanStageText(firstMove) || metadata.first_move || null;
+  metadata.next_button = cleanStageText(nextButton) || (targetStage === 'plan' ? 'Start do' : 'Move to review');
+  metadata.stage_updated_at = updateIso;
+  metadata.stage_updated_by = cleanStageText(actor) || null;
+  if (stageOwner) {
+    metadata.stage_owner = stageOwner;
+    metadata.assigned_to = targetStage === 'do' ? stageOwner : (metadata.assigned_to || stageOwner);
+  }
+  if (hasConfidence && Number.isFinite(confidenceValue)) metadata.stage_confidence = Math.max(0, Math.min(1, confidenceValue));
+
+  let result;
+  if (targetStage === 'plan') {
+    const whereClaim = row.status === 'claimed'
+      ? 'AND status = ? AND claimed_by IS ? AND updated_at = ?'
+      : 'AND status = ? AND updated_at = ?';
+    const params = row.status === 'claimed'
+      ? [updateTime, JSON.stringify(metadata), id, row.status, row.claimed_by || null, row.updated_at]
+      : [updateTime, JSON.stringify(metadata), id, row.status, row.updated_at];
+    result = withBusyRetry(() => db.prepare(`
+      UPDATE tasks
+         SET done_at = NULL,
+             updated_at = ?,
+             metadata = ?
+       WHERE id = ?
+         ${whereClaim}
+    `).run(...params));
+  } else {
+    const worker = workingRow && workingRow.claimed_by || stageOwner || cleanStageText(actor) || null;
+    if (workingRow && workingRow.status === 'claimed' && !workingRow.claimed_by && worker) {
+      result = withBusyRetry(() => db.prepare(`
+        UPDATE tasks
+           SET done_at = NULL,
+               claimed_by = ?,
+               claimed_at = ?,
+               updated_at = ?,
+               metadata = ?
+         WHERE id = ?
+           AND status = 'claimed'
+           AND claimed_by IS NULL
+           AND updated_at = ?
+      `).run(worker, updateTime, updateTime, JSON.stringify(metadata), id, workingRow.updated_at));
+      claimedFromUnowned = result.changes === 1;
+      claimedWorker = worker;
+    } else {
+      result = withBusyRetry(() => db.prepare(`
+        UPDATE tasks
+           SET done_at = NULL,
+               updated_at = ?,
+               metadata = ?
+         WHERE id = ?
+           AND status = 'claimed'
+           AND claimed_by IS ?
+           AND updated_at = ?
+      `).run(updateTime, JSON.stringify(metadata), id, worker, workingRow.updated_at));
+    }
+  }
+  if (result.changes !== 1) {
+    rollbackOpenDoClaim(workingRow);
+    return { staged: false, reason: 'stale_task_state' };
+  }
+
+  const payload = {
+    stage: targetStage,
+    goal: goalText,
+    summary: cleanStageText(summary) || null,
+    owner: stageOwner,
+    exit: exitText || null,
+    proof_needed: proofText || null,
+    first_move: cleanStageText(firstMove) || null,
+    next_button: metadata.next_button || null,
+    confidence: Number.isFinite(confidenceValue) ? metadata.stage_confidence : null,
+  };
+  payload.stage_packet = stagePacketFromPayload(payload);
+  const updated = getTask(db, id);
+  if ((claimedFromOpen || claimedFromUnowned) && targetStage === 'do') {
+    appendTaskEvent(db, {
+      taskId: id,
+      workspaceRoot: updated.workspace_root,
+      actor: claimedWorker,
+      eventType: 'claimed',
+      payload: { claimed_by: claimedWorker },
+    });
+  }
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: updated.workspace_root,
+    actor: cleanStageText(actor) || null,
+    eventType: targetStage === 'plan' ? 'task_planned' : 'work_started',
+    payload,
+  });
+  return { staged: true, event, row: updated, stage_packet: payload.stage_packet };
+}
+
 function appendTaskEvent(db, { taskId, workspaceRoot: ws, actor, eventType, payload }) {
   if (!taskId) throw new Error('taskId required');
   if (!ws) throw new Error('workspaceRoot required');
@@ -562,7 +1008,72 @@ function noteTask(db, { id, actor, content }) {
   return { noted: true, event };
 }
 
-function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, careerXpEligible = false, clearedFields = [] }) {
+function taskChatPacketFromPayload(payload) {
+  const data = payload && typeof payload === 'object' ? payload : {};
+  const lines = ['TASK_CHAT_UPDATE'];
+  if (data.goal) lines.push(`goal: ${data.goal}`);
+  if (data.summary) lines.push(`summary: ${data.summary}`);
+  if (data.content) lines.push(`message: ${data.content}`);
+  return lines.join('\n');
+}
+
+function chatTask(db, { id, actor, content, goal, summary }) {
+  if (!id) throw new Error('id required');
+  const text = cleanStageText(content);
+  const goalText = cleanStageText(goal);
+  const summaryText = cleanStageText(summary);
+  if (!text && !goalText && !summaryText) return { chatted: false, reason: 'content_required' };
+  const row = getTask(db, id);
+  if (!row) return { chatted: false, reason: 'not_found' };
+  if (['done', 'failed'].includes(row.status)) return { chatted: false, reason: `already_${row.status}` };
+
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  const previousGoal = cleanStageText(metadata.task_goal || metadata.goal_objective || metadata.objective || metadata.stage_goal);
+  const actorText = cleanStageText(actor) || null;
+  const now = Math.max(Date.now(), Number(row.updated_at || 0) + 1);
+  const payload = {
+    content: text || null,
+    goal: goalText || null,
+    summary: summaryText || null,
+    previous_goal: goalText && previousGoal && previousGoal !== goalText ? previousGoal : null,
+  };
+  payload.chat_packet = taskChatPacketFromPayload(payload);
+
+  if (goalText || summaryText) {
+    metadata.task_goal = goalText || metadata.task_goal || null;
+    if (goalText && !metadata.goal_objective) metadata.goal_objective = goalText;
+    if (goalText && !metadata.objective) metadata.objective = goalText;
+    if (summaryText) metadata.task_summary = summaryText;
+    metadata.task_refined_at = new Date(now).toISOString();
+    metadata.task_refined_by = actorText;
+    const updated = withBusyRetry(() => db.prepare(`
+      UPDATE tasks
+         SET metadata = ?,
+             updated_at = ?
+       WHERE id = ?
+         AND updated_at = ?
+    `).run(JSON.stringify(metadata), now, id, row.updated_at));
+    if (updated.changes !== 1) return { chatted: false, reason: 'stale_task_state' };
+  }
+
+  const latest = goalText || summaryText ? getTask(db, id) : row;
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: latest.workspace_root,
+    actor: actorText,
+    eventType: 'task_chat',
+    payload,
+  });
+  return {
+    chatted: true,
+    event,
+    row: latest,
+    goal_changed: Boolean(goalText && goalText !== previousGoal),
+    chat_packet: payload.chat_packet,
+  };
+}
+
+function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, careerXpEligible = false, clearedFields = [] }) {
   if (!id) throw new Error('id required');
   const row = getTask(db, id);
   if (!row) return { reviewed: false, reason: 'not_found' };
@@ -570,15 +1081,38 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, careerXpEl
   const now = Date.now();
   const reviewer = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
   const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  const proofText = String(proof || '').trim();
+  const verifyText = cleanStageText(verify);
+  const lessonText = String(lesson || '').trim();
+  const nextTaskText = String(nextTask || '').trim();
+  const clearedReviewFields = Array.isArray(clearedFields)
+    ? Array.from(new Set(clearedFields.filter(field => field === 'lesson' || field === 'next_task')))
+    : [];
   const reviewingPendingProof = row.status === 'review'
     && metadata.approval_status === 'pending'
+    && numericReward <= 0
     && metadata.agent_certified !== true;
+  const updatingPendingReviewProof = row.status === 'review'
+    && metadata.approval_status === 'pending'
+    && numericReward <= 0
+    && Boolean(proofText || verifyText || lessonText || nextTaskText || clearedReviewFields.length);
   let reviewPassCount = Number(metadata.agent_review_pass_count || 0);
+  if (reviewingPendingProof || updatingPendingReviewProof) {
+    metadata.agent_reviewed_at = new Date(now).toISOString();
+    metadata.agent_reviewed_by = reviewer;
+    if (proofText) metadata.latest_agent_proof = proofText;
+    if (verifyText) {
+      metadata.verify = verifyText;
+      metadata.latest_agent_verify = verifyText;
+    }
+    if (clearedReviewFields.includes('lesson')) metadata.latest_agent_lesson = null;
+    else if (lessonText) metadata.latest_agent_lesson = lessonText;
+    if (clearedReviewFields.includes('next_task')) metadata.latest_agent_next_task = null;
+    else if (nextTaskText) metadata.latest_agent_next_task = nextTaskText;
+  }
   if (reviewingPendingProof) {
     reviewPassCount += 1;
     metadata.agent_review_pass_count = reviewPassCount;
-    metadata.agent_reviewed_at = new Date(now).toISOString();
-    metadata.agent_reviewed_by = reviewer;
     if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES) {
       metadata.agent_certified = true;
       metadata.agent_certified_at = new Date(now).toISOString();
@@ -591,7 +1125,7 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, careerXpEl
     metadata.accepted_at = new Date().toISOString();
     metadata.accepted_by = reviewer;
   }
-  if (reviewingPendingProof || (numericReward > 0 && row.status === 'done')) {
+  if (reviewingPendingProof || updatingPendingReviewProof || (numericReward > 0 && row.status === 'done')) {
     withBusyRetry(() => db.prepare(`
       UPDATE tasks
          SET metadata = ?,
@@ -601,9 +1135,10 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, careerXpEl
   }
   const payload = {
     reward: numericReward,
-    lesson: String(lesson || '').trim(),
-    next_task: String(nextTask || '').trim() || null,
-    proof: String(proof || '').trim() || null,
+    lesson: lessonText,
+    next_task: nextTaskText || null,
+    proof: proofText || null,
+    verify: verifyText || null,
     career_xp_eligible: Boolean(careerXpEligible),
   };
   if (reviewingPendingProof) {
@@ -611,9 +1146,6 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, careerXpEl
     payload.agent_certified = metadata.agent_certified === true;
     payload.agent_certification_policy = metadata.agent_certification_policy || null;
   }
-  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,
@@ -636,7 +1168,7 @@ function compactEpisodeText(value, max = 240) {
 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 || '',
+    metadata.task_goal || metadata.goal_objective || metadata.goalObjective || metadata.goal?.objective || metadata.goal || '',
     240,
   );
   if (!goalId && !objective) return null;
@@ -813,14 +1345,25 @@ function taskProjection(db, {
       const taskEvents = byTask.get(row.id) || [];
       const latest = taskEvents.length ? taskEvents[taskEvents.length - 1] : null;
       const allMessages = taskEvents
-        .filter(e => e.event_type === 'message')
+        .filter(e => e.event_type === 'message' || e.event_type === 'task_chat' || e.event_type === 'task_planned' || e.event_type === 'work_started' || e.event_type === 'task_backlogged')
         .map(e => ({
           version: e.version,
           actor: e.actor,
-          content: clipProjectionText(e.payload && e.payload.content || ''),
+          content: e.event_type === 'message'
+            ? (e.payload && e.payload.content || '')
+            : e.event_type === 'task_chat'
+              ? (e.payload && (e.payload.chat_packet || taskChatPacketFromPayload(e.payload)) || '')
+            : e.event_type === 'task_backlogged'
+              ? (e.payload && backlogPacketFromPayload(e.payload) || '')
+              : (e.payload && (e.payload.stage_packet || stagePacketFromPayload(e.payload)) || ''),
           created_at: e.created_at,
         }));
-      const visibleMessages = includeHistory ? allMessages : allMessages.slice(-Math.max(0, Number(messageLimit) || 0));
+      const visibleMessages = includeHistory
+        ? allMessages
+        : allMessages.slice(-Math.max(0, Number(messageLimit) || 0)).map(message => ({
+          ...message,
+          content: clipProjectionText(message.content),
+        }));
       const visibleEvents = includeHistory ? taskEvents : taskEvents.slice(-Math.max(0, Number(eventLimit) || 0)).map(compactProjectionEvent);
       return {
         id: row.id,
@@ -851,7 +1394,7 @@ function taskProjection(db, {
   };
 }
 
-function renderTodoMarkdown(rows, { title = 'TODO.md', doneLimit = TODO_RENDER_DONE_LIMIT, refRows = rows, preservedSections = [] } = {}) {
+function renderTodoMarkdown(rows, { title = 'TODO.md', doneLimit = TODO_RENDER_DONE_LIMIT, failedLimit = TODO_RENDER_FAILED_LIMIT, refRows = rows, preservedSections = [] } = {}) {
   const displayRows = withTaskDisplayRefs(rows, refRows);
   const buckets = {
     open: displayRows.filter(r => r.status === 'open'),
@@ -869,7 +1412,12 @@ function renderTodoMarkdown(rows, { title = 'TODO.md', doneLimit = TODO_RENDER_D
   appendSection(lines, 'Backlog', buckets.open);
   appendSection(lines, 'In Progress', buckets.claimed);
   appendSection(lines, 'Review', buckets.review);
-  appendSection(lines, 'Blocked', buckets.failed);
+  const renderedFailed = buckets.failed.slice(0, Math.max(0, Number(failedLimit) || 0));
+  appendSection(lines, 'Blocked', renderedFailed);
+  const archivedFailed = Math.max(0, buckets.failed.length - renderedFailed.length);
+  if (archivedFailed > 0) {
+    lines.push(`(${archivedFailed} older blocked task${archivedFailed === 1 ? '' : 's'} archived in \`atris task list --status failed\` and \`atris task events\`.)`, '');
+  }
   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);
@@ -942,10 +1490,14 @@ module.exports = {
   getTask,
   listTasks,
   claimTask,
+  backlogTask,
+  clearPlanTasks,
   doneTask,
   readyTask,
   reviseTask,
+  stageTask,
   noteTask,
+  chatTask,
   reviewTask,
   appendTaskEvent,
   listTaskEvents,