atris 3.34.0 → 3.36.0

package/commands/task.js

@@ -7,15 +7,25 @@ const fs = require('fs');
 const http = require('http');
 const path = require('path');
 const os = require('os');
-const { taskProofState, buildVerifiedProof } = require('../lib/task-proof');
-const { evaluateAutoAccept, parseVerifyCommand, runVerifyCommand, DENIED_TAGS } = require('../lib/auto-accept-certified');
-const { extractReceiptEvidence } = require('../lib/receipt-evidence');
+const { taskProofState } = require('../lib/task-proof');
+const {
+  evaluateAutoAccept,
+  isAgentCertified,
+  isAutoCertifyVerifyCommandAllowed,
+  parseVerifyCommand,
+  runVerifyCommand,
+  runVerifyCommandCached,
+  DENIED_TAGS,
+} = require('../lib/auto-accept-certified');
+const { extractReceiptEvidence, RECEIPT_PATH_PATTERN } = require('../lib/receipt-evidence');
 const escapeRegExp = require('../lib/escape-regexp');
+const reviewIntegrity = require('../lib/review-integrity');
+const { gateForHuman, isRetiredFillerReason, landingWhyClause, numberWord } = require('../lib/voice-gate');
 const {
   normalizeOwnerSlug,
   resolveFunctionalOwner: resolveFunctionalTaskOwner,
 } = require('../lib/functional-owner');
-const { operatorReady, hasAgentJargon } = require('./autoland');
+const { operatorReady, hasAgentJargon, explainResult } = require('./autoland');
 const {
   TASK_INSPECT_FIELDS,
   readFieldsFlag,
@@ -38,6 +48,13 @@ const REVIEW_LANE_RUN_MAX_RUNS = 20;
 const PENDING_REVIEW_CHAT_STOP_REASON = 'pending_review_chat_waiting_for_agent_review';
 const PROOF_BOUNDARY_BLOCKED_ACTION = 'proof_boundary_blocked';
 const PROOF_BOUNDARY_BLOCKED_REASON = 'proof_boundary_blocked_requires_revision';
+const MISSION_XP_END_TO_END_REASON = 'mission_xp_requires_end_to_end_receipt';
+const MISSION_XP_END_TO_END_DETAIL = 'mission XP proof must name a zero-papercut end-to-end fresh-laptop pass through install, init, first mission, and first self-landed task; generic mission/tick receipts are not enough';
+const READY_RESULT_TEACHING = 'ready needs --result: one plain sentence someone new to the project can understand. say what someone can do now and why it matters. no ids, no paths, no commands. example: operators can now read the whole team day on one page instead of scrolling raw logs.';
+const REVIEW_AUTO_ACCEPT_ACTOR = 'auto (certified, small)';
+const REVIEW_AUTO_ACCEPT_POLICY = 'review_autoaccept_certified_small';
+const REVIEW_AUTO_ACCEPT_FILE_LIMIT = 10;
+const REVIEW_AUTO_ACCEPT_LINE_LIMIT = 300;
 
 const STATUS_PLAN_TAGS = new Set([
   'agent',
@@ -99,11 +116,11 @@ function getTaskDb() {
   }
 }
 
-function warnIfTaskTitleNeedsOperatorWhy(title) {
+function warnIfTaskTitleNeedsOperatorWhy(title, options = {}) {
   const text = String(title || '').trim();
   if (!text || operatorReady(text)) return null;
-  const warning = 'Warning: add the why in plain words to this task title: what it buys or costs, who benefits, and no flags or identifiers.';
-  console.error(warning);
+  const warning = 'Warning: put the why in this task title in plain words: what it buys or costs, and who benefits. Drop flags and ids.';
+  if (options.print !== false) console.error(warning);
   return warning;
 }
 
@@ -111,6 +128,13 @@ function taskUsageText() {
   return `
 atris task - durable local task state (SQLite, gitignored)
 
+  golden path (zero human turns):
+    atris task delegate "fix the login bug" --to <member>
+    atris task claim <id> --as <member>
+    ... build ...
+    atris task ready <id> --verify
+    atris autoland tick   # second check runs, task lands
+
   atris task                              Show the task desk
   atris task new "<title>"                Create a task
   atris task next [--tag <tag>] [--create-next]
@@ -118,14 +142,19 @@ atris task - durable local task state (SQLite, gitignored)
   atris task continue-work <id>           Create/reuse a certified Review follow-up task
   atris task say <id> "<message>"         Add context to a task
   atris task chat <id> "<message>" [--goal "..."]  Refine a task chat + working goal
-  atris task ready <id> --proof "..."      Agent proof ready; native goal can complete
-  atris task ready <id> --verify "<cmd>"   Run <cmd>; only ready if it exits 0 (executed proof)
+  atris task ready <id> --proof "..." --result "<sentence>"
+                                           Agent proof ready; native goal can complete
+  atris task ready <id> --verify "<cmd>" --result "<sentence>"
+                                           Run <cmd>; only ready if it exits 0 (executed proof)
+                                           Writes atris/runs/ receipt (pass or fail), folds path into proof
+  atris task receipt <id> --verify "<cmd>" Run <cmd> and write an atris/runs/ receipt without going to ready
   atris task plan-preview "<purpose>" [--tag <tag>] [--owner <member>] [--task <id>]
                                            Show the plain Plan before work starts
-  atris task ready <id> --proof "..." [--changed "..." --checked "..." --saved "..." --try "..."]
+  atris task ready <id> --proof "..." --result "<sentence>" [--changed "..." --checked "..." --saved "..." --try "..."]
                                            Agent proof ready; records Result if needed
-  atris task ready <id> --proof "..." [--happened "..." --checked "..." --tested "..." --decision "..."]
+  atris task ready <id> --proof "..." --result "<sentence>" [--happened "..." --checked "..." --tested "..." --decision "..."]
                                            Agent proof ready; writes the human result receipt
+  atris task result <id> "<sentence>"       Set or replace the day-one PM result sentence
   atris task result <id> --changed "..." --checked "..." [--saved "..."] [--try "..."]
                                            Show the plain Result and store trace on the task
   atris task review-chat <id> [--as <owner>]  Start a task-owned /codex verification chat
@@ -133,20 +162,25 @@ atris task - durable local task state (SQLite, gitignored)
                                            Human accepts proof, marks done; --public also publishes AgentXP
   atris task certify-verified [--dry-run] [--limit <n>] [--as <actor>]
                                            Re-run the runnable check named in each Review proof as a second actor; passing rows certify (denied lanes and check-less rows wait for a human)
-  atris task auto-accept-certified --dry-run [--strict-verify] [--limit <n>]
+  atris task auto-accept-certified --dry-run [--strict-verify] [--all] [--limit <n>]
                                            Preview certified Review rows; live accept needs --confirm-human-accept --as <human>
+  atris task sweep --auto-accept [--json]   Auto-accept verified Review rows; protected lanes wait for human
+  atris task audit [--limit <n>] [--revise] re-run stored verifies for newest accepted tasks; report-only unless --revise
   atris task revise <id> --note "..."      Send reviewed work back to Do
 
   atris task add "<title>" [--tag <tag>] [--goal-id <id>]  Create a task
-  atris task delegate "<title>" [--to <member>] [--executed-by <engine>] [--goal-id <id>]  Create assigned work
+  atris task delegate "<title>" [--to <member>] [--executed-by <engine>] [--goal-id <id>] [--tag <tag>]  Create assigned work
   atris task plan <id> --goal "..." --exit "..." --proof-needed "..."
                                            Record a task-owned Plan stage
   atris task do <id> --as <owner> --first-move "..."
                                            Start task-owned Do work from the plan
   atris task backlog <id> [--reason "..."] Move a planned open task back to Backlog
   atris task clear-plan --yes              Move all planned open tasks back to Backlog
-  atris task day [--json]                  Show today's owner-grouped task list
-  atris task list [--all] [--status <s>]   List tasks (default: this workspace)
+  atris task day [--full] [--all] [--everywhere] [--json]  show today's owner-grouped task list
+                                           text shows eight current rows; --full shows every active row
+                                           --all stays in this workspace; --everywhere spans workspaces
+  atris task list [--all] [--everywhere] [--status <s>]
+                                           list tasks in this workspace; --everywhere spans workspaces
   atris task claim <id> [--as <owner>]     Atomic claim
   atris task release <id> [--as <owner>]   Release your own mistaken claim back to open
   atris task capabilities [--json]         Read-only task CLI/API capability contract
@@ -163,6 +197,10 @@ atris task - durable local task state (SQLite, gitignored)
                                            Advance the scoped current task one safe step
                                            review-state lanes: needs-agent, continue-work, human-accept-waiting, certified
   atris task note <id> "<message>"         Append dialogue/context to a task
+  atris task retitle <id> "<new title>"    Rename a task and preserve the old title in dialogue
+  atris task tag <id> --add <tag> [--remove <tag>]
+                                           Update tags on an existing task (e.g. --add needs-human to hold it
+                                           from sweep + fleet staffing); logs a task_tags_updated event
   atris task show <id> [--json]            Show a task card + dialogue
   atris task inspect <id> --fields review,status,title [--json]
                                            Field-selectable task state (review metadata, status, title, owner, tag)
@@ -170,6 +208,12 @@ atris task - durable local task state (SQLite, gitignored)
   atris task step <id> [--json]            Refine chat, then advance one safe Plan/Do/Review step
   atris task done <id> --proof "..."       Mark complete with proof
   atris task done <id> --failed [--proof "..."]  Mark failed, optionally reviewed
+  atris task archive <id> --reason "..." [--from-failed]
+                                           Sweep off-roadmap/duplicate work as archived (not failed);
+                                           --from-failed opts in to relabel a fail-closed row (never done)
+  atris task clear-done [--before <days>] [--dry-run] [--json]  Archive completed rows, oldest first
+  atris task relabel-archived [--dry-run|--apply]
+                                           One-time OBL-1622 migration: relabel June-10 backlog-reset rows failed -> archived
   atris task finish <id> --proof "..."     Legacy alias for done with proof
   atris task review <id> --reward <n> [--verify "<cmd>"]
                                            Write review event + RSI episode
@@ -183,10 +227,13 @@ atris task - durable local task state (SQLite, gitignored)
   atris task sync --dry-run                Plan cloud/Swarlo task sync writes
   atris task import <file>                 One-shot import from TODO.md
   atris task lineage <id> [--json]          Show endgame -> tasks -> commits chain
-  atris task events [id] [--limit <n>]     Print recent task events
-  atris task events --all                  Print the full append-only ledger
-  atris task export [--out <file>]         Write web/desktop JSON projection
-  atris task render [--out <file>]         Regenerate compact TODO.md view from state
+  atris task events [id] [--limit <n>]     print recent task events
+  atris task events --all                  print the full current-workspace ledger
+  atris task events --everywhere           print the full ledger across workspaces
+  atris task export [--all] [--everywhere] [--out <file>]
+                                           write web/desktop JSON projection
+  atris task render [--all] [--everywhere] [--out <file>]
+                                           regenerate compact TODO.md view from state
   atris task where                          Print db path + workspace scope
   atris task help                           This help
 
@@ -226,6 +273,15 @@ function hasFlag(args, name) {
   return args.indexOf(name) !== -1;
 }
 
+function taskScopeEverywhere(args = [], options = {}) {
+  if (options.everywhere !== undefined) return Boolean(options.everywhere);
+  return hasFlag(args, '--everywhere');
+}
+
+function scopedWorkspaceRoot(taskDb, args = [], options = {}) {
+  return taskScopeEverywhere(args, options) ? null : taskDb.workspaceRoot();
+}
+
 function hasEmptyFlagValue(args, name) {
   const i = args.indexOf(name);
   return i !== -1 && args[i + 1] === '';
@@ -387,6 +443,22 @@ function proofFlagValue(args) {
   return typeof proof === 'string' ? proof.trim() : '';
 }
 
+function resultSentenceIssue(value) {
+  const check = explainResult(value);
+  return check.ok ? null : check.reason;
+}
+
+function readyResultDetail(reason) {
+  return reason ? `${READY_RESULT_TEACHING}\n${reason}` : READY_RESULT_TEACHING;
+}
+
+function requireResultSentence(label, value, { ready = false } = {}) {
+  const issue = resultSentenceIssue(value);
+  if (!issue) return String(value || '').replace(/\s+/g, ' ').trim();
+  const detail = ready ? readyResultDetail(issue) : issue;
+  failTask(label, 'weak_result', detail);
+}
+
 function textFlag(args, names) {
   for (const name of names) {
     const value = flag(args, name);
@@ -416,17 +488,27 @@ function landingNeedsDayOnePm(sentence, title) {
   const text = normalizedLandingSentence(sentence);
   if (!text) return true;
   if (text.toLowerCase() === normalizedLandingSentence(defaultLandingSentenceForTitle(title)).toLowerCase()) return true;
-  return hasAgentJargon(text) || !operatorReady(text);
+  return hasAgentJargon(text) || /\bas\s+exists?\b/i.test(text) || !operatorReady(text);
 }
 
 function warnIfLandingNeedsDayOnePm(landing, title) {
   const sentence = landing && typeof landing === 'object' ? landing.happened : '';
   if (!landingNeedsDayOnePm(sentence, title)) return null;
-  const warning = 'Advisory: add --landing with one capability sentence a day-one PM could read, with the result in plain words and no flags or identifiers.';
+  const warning = 'Advisory: add --landing with one plain sentence saying what someone can do now, in words a new teammate would get. No flags, no ids.';
   console.error(warning);
   return warning;
 }
 
+function requireExplicitLandingDayOnePm(label, landing, title) {
+  const sentence = landing && typeof landing === 'object' ? normalizedLandingSentence(landing.happened) : '';
+  if (!sentence || !landingNeedsDayOnePm(sentence, title)) return;
+  failTask(
+    label,
+    'weak_landing',
+    'landing needs one plain sentence saying what someone can do now and why it matters, in words a new teammate would understand. no flags, ids, or unnamed filters.',
+  );
+}
+
 function numericFlag(args, name) {
   const value = flag(args, name);
   if (value === null || value === true || value === undefined) return null;
@@ -441,6 +523,102 @@ function meaningfulTaskProofIssue(proof, { required = true } = {}) {
   return state.ok ? null : state.reason;
 }
 
+function goldenPathMissionXpTask(task) {
+  if (!task) return false;
+  const metadata = task.metadata || {};
+  const text = [
+    task.title,
+    task.tag,
+    metadata.goal_id,
+    metadata.goalId,
+    metadata.mission_id,
+    metadata.stop_condition,
+    metadata.goal_objective,
+    metadata.objective,
+  ].filter(Boolean).join(' ');
+  const missionXp = String(task.title || '').trim().toLowerCase().startsWith('mission xp:')
+    || String(task.tag || '').toLowerCase() === 'agent-xp';
+  return missionXp
+    && /\b(?:golden[- ]path|zero[- ]knowledge|zero[- ]papercuts?|fresh[- ](?:laptop|environment|install|home)|self[- ]landed)\b/i.test(text);
+}
+
+function receiptTextForProof(proof, root = process.cwd()) {
+  const chunks = [];
+  const pattern = new RegExp(RECEIPT_PATH_PATTERN.source, 'g');
+  let match;
+  while ((match = pattern.exec(String(proof || ''))) && chunks.length < 3) {
+    const rel = match[1];
+    if (!rel || rel.includes('*')) continue;
+    try {
+      const raw = fs.readFileSync(path.resolve(root, rel), 'utf8');
+      const parsed = JSON.parse(raw);
+      chunks.push(JSON.stringify({
+        schema: parsed.schema || null,
+        mission_id: parsed.mission_id || null,
+        result: parsed.result || null,
+        landing: parsed.landing || null,
+        last_landing: parsed.last_landing || null,
+        summary: parsed.summary || null,
+      }).slice(0, 12000));
+    } catch {}
+  }
+  return chunks.join(' ');
+}
+
+// Mission ticks already compose a real landing sentence into the run receipt.
+// When a mission-bridged task lands with only a receipt proof, lift that
+// sentence so the review queue shows the work instead of echoing the title.
+function missionReceiptResultForProof(task, proof, root = process.cwd()) {
+  const metadata = task?.metadata || {};
+  if (!metadata.mission_id && !metadata.goal_id) return null;
+  const pattern = new RegExp(RECEIPT_PATH_PATTERN.source, 'g');
+  let match;
+  while ((match = pattern.exec(String(proof || '')))) {
+    const rel = match[1];
+    if (!rel || rel.includes('*')) continue;
+    let landing = null;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(path.resolve(root, rel), 'utf8'));
+      landing = parsed?.result?.landing || parsed?.landing || parsed?.last_landing || null;
+    } catch { continue; }
+    const changed = String(landing?.changed || landing?.happened || '').replace(/\s+/g, ' ').trim();
+    if (!changed) continue;
+    if (/\brecorded tick \d+\.?$/i.test(changed) || /^recorded a proof heartbeat\b/i.test(changed)) continue;
+    const reason = String(landing?.reason || landing?.why || '').replace(/\s+/g, ' ').trim();
+    return { changed, reason: reason && !isRetiredFillerReason(reason) ? reason : null };
+  }
+  return null;
+}
+
+function missionXpEndToEndProofIssue(task, proof, root = process.cwd()) {
+  if (!goldenPathMissionXpTask(task)) return null;
+  const corpus = `${String(proof || '')} ${receiptTextForProof(proof, root)}`
+    .replace(/\s+/g, ' ')
+    .trim();
+  const hasZeroPapercut = /\b(?:zero|0|no)\s+(?:new\s+)?papercuts?\b|\bzero[- ]papercut\b/i.test(corpus);
+  const hasEndToEnd = /\bend[- ]to[- ]end\b|\bfull\s+(?:fresh[- ](?:laptop|environment)\s+)?pass\b|\bfresh[- ](?:laptop|environment|install)\b|\bclean\s+temp\s+home\b|\bnpm\s+pack\b/i.test(corpus);
+  const hasSelfLanded = /\bself[- ]landed\b|\bfirst\s+self[- ]landed\s+task\b|\btask\s+reaches\s+done\b|\binstall\b.{0,120}\binit\b.{0,120}\bmission\b.{0,120}\b(?:self[- ]landed|task)\b/i.test(corpus);
+  return hasZeroPapercut && hasEndToEnd && hasSelfLanded ? null : MISSION_XP_END_TO_END_DETAIL;
+}
+
+function missionXpProofBoundaryEvaluation(task, proofOverride = null) {
+  if (!goldenPathMissionXpTask(task)) return null;
+  const metadata = task.metadata || {};
+  const review = task.review || {};
+  const proof = proofOverride === null
+    ? String(review.proof || metadata.latest_agent_proof || '').trim()
+    : String(proofOverride || '').trim();
+  const issue = missionXpEndToEndProofIssue(task, proof, task.workspace_root || process.cwd());
+  if (!issue) return null;
+  return {
+    eligible: false,
+    ref: taskRef(task),
+    reason: MISSION_XP_END_TO_END_REASON,
+    next_action: 'attach the zero-papercut end-to-end fresh-laptop receipt, then resubmit Mission XP proof',
+    proof,
+  };
+}
+
 function requireMeaningfulTaskProof(label, proof, { required = true } = {}) {
   const issue = meaningfulTaskProofIssue(proof, { required });
   if (issue) failTask(label, 'weak_proof', `meaningful proof required: ${issue}`);
@@ -462,14 +640,22 @@ function positional(args) {
   });
 }
 
-function writeDefaultProjection(taskDb, db, { all = false } = {}) {
+function writeDefaultProjection(taskDb, db, options = {}) {
+  const workspaceRoot = scopedWorkspaceRoot(taskDb, [], options);
   const projection = enrichTaskProjection(taskDb.taskProjection(db, {
-    workspaceRoot: all ? null : taskDb.workspaceRoot(),
-    limit: 500,
+    workspaceRoot,
+    limit: options.all ? null : 500,
   }));
   const outPath = path.resolve(path.join('.atris', 'state', 'tasks.projection.json'));
+  const output = JSON.stringify(projection, null, 2) + '\n';
   fs.mkdirSync(path.dirname(outPath), { recursive: true });
-  fs.writeFileSync(outPath, JSON.stringify(projection, null, 2) + '\n', 'utf8');
+  let shouldWrite = true;
+  try {
+    shouldWrite = fs.readFileSync(outPath, 'utf8') !== output;
+  } catch {
+    shouldWrite = true;
+  }
+  if (shouldWrite) fs.writeFileSync(outPath, output, 'utf8');
   return { projection, outPath };
 }
 
@@ -692,6 +878,11 @@ function certifiedReviewNextAction(nextTaskTitle) {
 }
 
 function proofBoundaryBlockedEvaluation(task) {
+  const missionXpBoundary = missionXpProofBoundaryEvaluation(task);
+  if (missionXpBoundary) return missionXpBoundary;
+  // strictVerify stays off here: this is a render-path probe for the boundary
+  // reason only, and the default-true strict mode would spawn the verify
+  // subprocess for every certified row just to draw the desk.
   const evaluation = evaluateAutoAccept(task, { strictVerify: false, minPasses: 0 });
   return evaluation && evaluation.reason === 'proof_unmerged_or_draft_pr_boundary'
     ? evaluation
@@ -882,26 +1073,11 @@ function proofToReasonText(proof) {
   return /[.!?]$/.test(section) ? section : `${section}.`;
 }
 
-function titleToReasonText(task, proof = '') {
-  const title = String(task?.title || '').replace(/\s+/g, ' ').trim();
-  const text = `${title} ${proof || ''}`.toLowerCase();
-  if (/\b(priv(?:ate|acy)|secret|payload|leak|redact)\b/.test(text)) {
-    return 'It keeps private data out of the fast human decision screen.';
-  }
-  if (/\bapprove\b/.test(text) && /\b(command|exact|preview|ux)\b/.test(text)) {
-    return 'It lets the operator see the next command without hunting.';
-  }
-  if (/\b(stale|expire|expired)\b/.test(text) && /\bapproval/.test(text)) {
-    return 'It stops old approvals from running after their context has gone stale.';
-  }
-  if (/\bapproval|approve|permission\b/.test(text)) {
-    return 'It keeps real-world side effects behind a clear human decision.';
-  }
-  if (/\btest|self-test|harness|verifier|proof\b/.test(text)) {
-    return 'It gives the human a repeatable check before approval.';
-  }
-  return 'It turns the task title into a concrete result the human can approve.';
-}
+// A landing sentence written for --result already carries its own why
+// ("..., so operators keep deciding instead of waiting"). Reuse that clause
+// as the reason instead of inventing one; with no clause, stay silent.
+// landingWhyClause lives in lib/voice-gate.js so every human-bound landing
+// composer (task reviews, mission receipts) shares the same why extraction.
 
 function proofToHumanCheck(proof) {
   const text = String(proof || '').replace(/\s+/g, ' ').trim();
@@ -1011,17 +1187,30 @@ function taskReviewLanding(task, review = {}, payload = {}) {
   const agentCertified = review.agent_certified === true || metadata.agent_certified === true;
   const approvalStatus = review.approval_status || metadata.approval_status || null;
   const explicitHappened = landingPayloadValue(payload, metadata, 'happened')
-    || payload.changed || metadata.result_changed || metadata.human_changed || metadata.changed;
+    || payload.result || metadata.result || payload.changed || metadata.result_changed || metadata.human_changed || metadata.changed;
   const explicitChecked = landingPayloadValue(payload, metadata, 'checked')
     || payload.checked || metadata.result_checked || metadata.human_checked || metadata.checked;
   const explicitTested = landingPayloadValue(payload, metadata, 'tested');
   const explicitDecision = landingPayloadValue(payload, metadata, 'decision');
-  const explicitReason = landingPayloadValue(payload, metadata, 'reason')
+  const explicitReasonRaw = landingPayloadValue(payload, metadata, 'reason')
     || landingPayloadValue(payload, metadata, 'why')
     || payload.reason || payload.why || metadata.result_reason || metadata.review_reason || metadata.why_it_matters;
+  const explicitReason = explicitReasonRaw && !isRetiredFillerReason(explicitReasonRaw) ? explicitReasonRaw : null;
+  const missionLift = explicitHappened
+    ? null
+    : missionReceiptResultForProof(task, proof, task.workspace_root || process.cwd());
+  let happened = clipStatusText(explicitHappened || (missionLift && missionLift.changed) || titleToResultText(task.title), 220);
+  let reason = clipStatusText(explicitReason || proofToReasonText(proof) || (missionLift && missionLift.reason) || '', 220);
+  if (!reason) {
+    const clause = landingWhyClause(happened);
+    if (clause) {
+      happened = clipStatusText(clause.change, 220);
+      reason = clipStatusText(clause.why, 220);
+    }
+  }
   return {
-    happened: clipStatusText(explicitHappened || titleToResultText(task.title), 220),
-    reason: clipStatusText(explicitReason || proofToReasonText(proof) || titleToReasonText(task, proof), 220),
+    happened,
+    reason,
     checked: clipStatusText(explicitChecked || proofToHumanCheck(proof), 220),
     tested: clipStatusText(explicitTested || taskReviewLandingTested(proof), 260),
     decision: clipStatusText(explicitDecision || (task.status === 'done'
@@ -1057,11 +1246,65 @@ function taskReviewSavedText(task, review = {}, ref = taskRef(task)) {
   return `Work record saved as ${ref}.`;
 }
 
+function cleanReviewProofText(value) {
+  const text = String(value || '').trim();
+  return text || null;
+}
+
+function reviewMessageLooksLikeProof(value) {
+  const text = cleanReviewProofText(value);
+  return Boolean(text && /\b(?:proof|verified|verifier|passed|receipt|git diff --check|node --test|npm test|pnpm test|yarn test|pytest|typecheck)\b/i.test(text));
+}
+
+function taskReviewEventProof(task) {
+  const events = Array.isArray(task.events) ? task.events : [];
+  for (const event of events.slice().reverse()) {
+    const payload = event && event.payload && typeof event.payload === 'object' ? event.payload : {};
+    const explicit = cleanReviewProofText(payload.proof || payload.verify);
+    if (explicit) return explicit;
+    const message = cleanReviewProofText(payload.content || payload.chat_packet || payload.stage_packet);
+    if (message && reviewMessageLooksLikeProof(message)) return message;
+  }
+  const messages = Array.isArray(task.messages) ? task.messages : [];
+  for (const message of messages.slice().reverse()) {
+    const content = cleanReviewProofText(message && message.content);
+    if (content && reviewMessageLooksLikeProof(content)) return content;
+  }
+  return null;
+}
+
+function taskReviewProofFallback(task, payload = {}) {
+  if (!task || task.status !== 'review') return null;
+  const metadata = task.metadata || {};
+  return cleanReviewProofText(metadata.latest_agent_proof)
+    || cleanReviewProofText(payload.proof)
+    || cleanReviewProofText(metadata.proof)
+    || cleanReviewProofText(metadata.verify)
+    || cleanReviewProofText(metadata.latest_agent_verify)
+    || cleanReviewProofText(payload.verify)
+    || taskReviewEventProof(task);
+}
+
+function reviewReceiptPath(proofText, root) {
+  const evidence = extractReceiptEvidence(proofText, root);
+  if (!evidence) return null;
+  return evidence.receipts?.[0]?.path || evidence.missing?.[0] || null;
+}
+
+function withReviewReceiptPath(review, root) {
+  if (!review) return null;
+  return {
+    ...review,
+    receipt_path: reviewReceiptPath(review.proof, root),
+  };
+}
+
 function taskReviewSummary(task) {
   const reviewed = (task.events || []).slice().reverse().find(e => e.event_type === 'reviewed' || e.event_type === 'proof_ready' || e.event_type === 'revision_requested');
   const payload = reviewed && reviewed.payload || {};
   const metadata = task.metadata || {};
-  if (!reviewed && !metadata.approval_status && !metadata.agent_review_pass_count && !metadata.human_revision_count && !metadata.agent_certified) return null;
+  const fallbackProof = taskReviewProofFallback(task, payload);
+  if (!reviewed && !metadata.approval_status && !metadata.agent_review_pass_count && !metadata.human_revision_count && !metadata.agent_certified && !fallbackProof) return null;
   if (reviewed && reviewed.event_type === 'revision_requested') {
     const review = {
       summary: reviewSummary(task, payload),
@@ -1101,7 +1344,7 @@ function taskReviewSummary(task) {
   const review = {
     summary: reviewSummary(task, payload),
     reward: reviewed && reviewed.event_type === 'reviewed' && payload.reward !== undefined ? payload.reward : null,
-    proof: readyField('proof', 'latest_agent_proof'),
+    proof: readyField('proof', 'latest_agent_proof') || fallbackProof,
     lesson: readyField('lesson', 'latest_agent_lesson'),
     next_task: readyField('next_task', 'latest_agent_next_task'),
     approval_status: metadata.approval_status || (task.status === 'review' ? 'pending' : null),
@@ -1132,6 +1375,7 @@ function taskReviewInspectMetadata(task) {
     human_revision_count: review.human_revision_count || null,
     human_revision_note: review.human_revision_note || null,
     reward: review.reward ?? null,
+    receipt_path: review.receipt_path || null,
   };
 }
 
@@ -1317,7 +1561,7 @@ function enrichTaskProjection(projection) {
       const parentLinkType = parentFromParentId ? 'parent_task_id' : parentFromGoalId ? 'goal_id' : null;
       const parentId = parent ? parent.id : metadata.parent_task_id || null;
       const childTasks = children.get(task.id) || [];
-      const review = taskReviewSummary(task);
+      const review = withReviewReceiptPath(taskReviewSummary(task), root);
       return {
         ...task,
         objective: taskObjective(task, parent, goalSource.goals, { parentLinkType, baseObjectives }),
@@ -1502,6 +1746,44 @@ function latestTaskEvent(task) {
   return events.length ? events[events.length - 1] : null;
 }
 
+function verifiedProofCommand(proof) {
+  const match = String(proof || '').match(/\[verified\]\s+`([^`]+)`\s+passed\s+\(exit 0\)/i);
+  return match ? String(match[1] || '').trim() : '';
+}
+
+function autoCertifyCommandCandidatesForTask(task) {
+  const metadata = task && task.metadata || {};
+  const review = task && task.review || {};
+  const proof = String(review.proof || metadata.latest_agent_proof || '');
+  const candidates = [
+    metadata.verify,
+    metadata.latest_agent_verify,
+    verifiedProofCommand(review.proof),
+    verifiedProofCommand(metadata.latest_agent_proof),
+    ...taskReviewEvidenceCommands(proof),
+  ].map(value => String(value || '').trim()).filter(Boolean);
+  const seen = new Set();
+  return candidates.filter((candidate) => {
+    const key = candidate.toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function reviewBlockerForTask(task) {
+  const ref = taskRef(task);
+  const candidates = autoCertifyCommandCandidatesForTask(task);
+  const safe = candidates.find(command => isAutoCertifyVerifyCommandAllowed(command));
+  const unsafe = candidates.find(command => !isAutoCertifyVerifyCommandAllowed(command));
+  const reason = !safe && unsafe ? 'verify_command_not_allowed' : 'needs_second_actor_review';
+  return {
+    reason,
+    verify_command: (!safe && unsafe) ? unsafe : (safe || candidates[0] || null),
+    next_command: `atris task review-chat ${ref} --as codex-review`,
+  };
+}
+
 function reviewHandoffForTask(task, { suppressExistingFollowUp = false, hasExistingReviewFollowUp = null } = {}) {
   const review = task && task.review || {};
   if (task && task.status !== 'review') return null;
@@ -1521,7 +1803,15 @@ function reviewHandoffForTask(task, { suppressExistingFollowUp = false, hasExist
   if (proofBoundary) {
     handoff.reason = proofBoundary.reason;
     handoff.next_action_detail = proofBoundary.next_action || null;
-    handoff.revise_command = `atris task revise ${taskRef(task)} --note "<replace stale PR proof with merged proof or move back to Do>"`;
+    const note = proofBoundary.reason === MISSION_XP_END_TO_END_REASON
+      ? '<attach zero-papercut end-to-end fresh-laptop receipt or move back to Do>'
+      : '<replace stale PR proof with merged proof or move back to Do>';
+    handoff.revise_command = `atris task revise ${taskRef(task)} --note "${note}"`;
+  } else if (!agentCertified) {
+    const blocker = reviewBlockerForTask(task);
+    handoff.reason = blocker.reason;
+    handoff.next_action_detail = blocker.verify_command || null;
+    handoff.review_chat_command = blocker.next_command;
   } else if (agentCertified && nextTask && !hasExistingFollowUp) {
     handoff.next_task = nextTask;
     handoff.continue_work_command = continueWorkCommandForTask(task);
@@ -1960,7 +2250,8 @@ function compactTaskForStatus(task) {
     id: task.id,
     display_id: task.display_id || null,
     legacy_ref: task.legacy_ref || taskRef(task.id),
-    title: clipStatusText(task.title, 140),
+    title: clipStatusTitle(task.title, 140),
+    result: clipStatusText(task.result || metadata.result, 180) || null,
     status: task.status,
     updated_at: task.updated_at,
   };
@@ -1980,6 +2271,7 @@ function compactTaskForStatus(task) {
     if (task.review.proof) review.proof = clipStatusText(task.review.proof, 180);
     if (task.review.lesson) review.lesson = clipStatusText(task.review.lesson, 180);
     if (task.review.next_task) review.next_task = clipStatusText(task.review.next_task, 140);
+    if (Object.prototype.hasOwnProperty.call(task.review, 'receipt_path')) review.receipt_path = task.review.receipt_path || null;
     if (task.review.approval_status) review.approval_status = task.review.approval_status;
     if (task.review.agent_review_pass_count) review.agent_review_pass_count = task.review.agent_review_pass_count;
     if (task.review.agent_certified) review.agent_certified = task.review.agent_certified;
@@ -2013,7 +2305,7 @@ function compactTaskFromProjection(projection, id) {
 function compactEventPayload(payload) {
   if (!payload || typeof payload !== 'object') return null;
   const out = {};
-  for (const key of ['title', 'status', 'tag', 'content', 'goal', 'summary', 'proof', 'lesson', 'reward', 'next_task']) {
+  for (const key of ['title', 'status', 'tag', 'content', 'goal', 'summary', 'proof', 'lesson', 'reward', 'next_task', 'result']) {
     if (payload[key] !== undefined && payload[key] !== null && payload[key] !== '') out[key] = payload[key];
   }
   return Object.keys(out).length ? out : null;
@@ -2038,6 +2330,19 @@ function clipStatusText(value, max = 180) {
   return `${text.slice(0, max - 1)}…`;
 }
 
+function clipStatusTitle(value, max = 140) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (text.length <= max) return text;
+  const cut = text.slice(0, max + 1);
+  const boundaries = [...cut.matchAll(/[.!?;](?=\s|$)/g)];
+  const boundary = boundaries.map((match) => match.index).filter((index) => index >= max * 0.45).pop();
+  if (Number.isInteger(boundary)) {
+    return cut.slice(0, boundary + 1).replace(/[;:]+$/, '').trim();
+  }
+  const wholeWords = text.slice(0, max).replace(/\s+\S*$/, '').trim();
+  return `${wholeWords || text.slice(0, max).trim()}...`;
+}
+
 function compactReviewActionRef(task, { hasExistingReviewFollowUp = null } = {}) {
   if (!task) return null;
   const handoff = reviewHandoffForTask(task, { suppressExistingFollowUp: true, hasExistingReviewFollowUp }) || {};
@@ -3055,6 +3360,7 @@ function taskCapabilitiesCheckReport(taskDb, db, args = [], options = {}) {
   const owner = options.owner || flag(args, '--as') || flag(args, '--owner') || DEFAULT_OWNER;
   const reviewer = reviewActor(options.reviewer || flag(args, '--reviewer') || flag(args, '--as-reviewer') || 'codex-review');
   const all = options.all !== undefined ? Boolean(options.all) : hasFlag(args, '--all');
+  const everywhere = taskScopeEverywhere(args, options);
   const limit = options.limit !== undefined ? options.limit : taskQueueLimit(args);
   const scope = normalizeTaskQueueScope(options.scope || taskQueueScopeFromArgs(args));
   const standalone = taskCapabilitiesContract();
@@ -3062,6 +3368,7 @@ function taskCapabilitiesCheckReport(taskDb, db, args = [], options = {}) {
     owner,
     reviewer,
     all,
+    everywhere,
     limit,
     scope,
   });
@@ -3326,7 +3633,11 @@ function selectTaskForCurrent(projection, { owner = DEFAULT_OWNER, scope = {}, h
   if (reviewNeedsAgent) return { task: reviewNeedsAgent, reason: 'review_needs_agent_verification' };
   const reviewProofBoundaryBlocked = columns.review.find(task => reviewHandoffForTask(task, { suppressExistingFollowUp: true, hasExistingReviewFollowUp })?.next_action === PROOF_BOUNDARY_BLOCKED_ACTION);
   if (reviewProofBoundaryBlocked) return { task: reviewProofBoundaryBlocked, reason: 'review_proof_boundary_blocked' };
-  const planQueue = normalizedScope.goal_id ? sortTasksOldestFirst(columns.plan) : columns.plan;
+  // Scoped selection (goal_id, tag, status, or review_state) implies a sequenced
+  // work stream (e.g. golden-path "pass 1a" before "pass 2"): earlier-created
+  // tasks must win over newer ones, not the newest-first default used for the
+  // unscoped desk view.
+  const planQueue = !taskQueueScopeIsEmpty(normalizedScope) ? sortTasksOldestFirst(columns.plan) : columns.plan;
   const planReady = planQueue[0];
   if (planReady) return { task: planReady, reason: 'plan_ready' };
   const backlogIdea = columns.backlog[0];
@@ -3392,18 +3703,20 @@ function buildTaskCurrent(taskDb, db, args = [], options = {}) {
   const owner = options.owner || flag(args, '--as') || flag(args, '--owner') || DEFAULT_OWNER;
   const reviewer = reviewActor(options.reviewer || flag(args, '--reviewer') || flag(args, '--as-reviewer') || 'codex-review');
   const all = options.all !== undefined ? Boolean(options.all) : hasFlag(args, '--all');
+  const everywhere = taskScopeEverywhere(args, options);
+  const workspaceRoot = scopedWorkspaceRoot(taskDb, args, { everywhere });
   const limit = options.limit !== undefined ? options.limit : taskQueueLimit(args);
   const scope = normalizeTaskQueueScope(options.scope || taskQueueScopeFromArgs(args));
-  const { projection, outPath } = writeDefaultProjection(taskDb, db, { all });
+  const { projection, outPath } = writeDefaultProjection(taskDb, db, { all, everywhere });
   const hasExistingReviewFollowUp = buildReviewFollowUpChildPredicate(
     taskDb,
     db,
-    all ? null : taskDb.workspaceRoot(),
+    workspaceRoot,
   );
   const hasPendingReviewChat = buildPendingReviewChatPredicate(
     taskDb,
     db,
-    all ? null : taskDb.workspaceRoot(),
+    workspaceRoot,
   );
   return {
     projection,
@@ -3676,12 +3989,14 @@ function taskReviewLaneDrainReport(taskDb, db, args = [], options = {}) {
   const owner = options.owner || flag(args, '--as') || flag(args, '--owner') || DEFAULT_OWNER;
   const reviewer = reviewActor(options.reviewer || flag(args, '--reviewer') || flag(args, '--as-reviewer') || 'codex-review');
   const all = options.all !== undefined ? Boolean(options.all) : hasFlag(args, '--all');
+  const everywhere = taskScopeEverywhere(args, options);
   const limit = options.limit !== undefined ? options.limit : taskQueueLimit(args);
   const scope = normalizeTaskQueueScope(options.scope || taskQueueScopeFromArgs(args));
   const capabilitiesCheck = taskCapabilitiesCheckReport(taskDb, db, [], {
     owner,
     reviewer,
     all,
+    everywhere,
     limit,
     scope,
   });
@@ -3689,6 +4004,7 @@ function taskReviewLaneDrainReport(taskDb, db, args = [], options = {}) {
     owner,
     reviewer,
     all,
+    everywhere,
     limit,
     scope,
     excludeTaskIds: options.excludeTaskIds,
@@ -3749,6 +4065,7 @@ function taskReviewLaneActOptionsFromArgs(args = []) {
     owner: flag(args, '--as') || flag(args, '--owner') || DEFAULT_OWNER,
     reviewer: reviewActor(flag(args, '--reviewer') || flag(args, '--as-reviewer') || 'codex-review'),
     all: hasFlag(args, '--all'),
+    everywhere: hasFlag(args, '--everywhere'),
     limit: taskQueueLimit(args),
     scope: taskQueueScopeFromArgs(args),
     dryRun: hasFlag(args, '--dry-run'),
@@ -3766,6 +4083,7 @@ function taskReviewLaneActOptionsFromBody(body = {}, searchParams = new URLSearc
     owner: String(queryOwner || body.owner || body.as || body.actor || DEFAULT_OWNER),
     reviewer: reviewActor(queryReviewer || body.reviewer || body.review_actor || body.reviewActor || 'codex-review'),
     all: searchParams.get('all') === '1' || searchParams.get('all') === 'true' || Boolean(body.all),
+    everywhere: searchParams.get('everywhere') === '1' || searchParams.get('everywhere') === 'true' || Boolean(body.everywhere),
     limit: Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 8,
     scope: mergeTaskQueueScopes(queryScope, bodyScope),
     dryRun: searchParams.get('dry_run') === '1'
@@ -3831,6 +4149,7 @@ function taskReviewLaneAct(taskDb, db, options = {}) {
     owner,
     reviewer,
     all: Boolean(options.all),
+    everywhere: Boolean(options.everywhere),
     limit: options.limit !== undefined ? options.limit : 8,
     scope,
     excludeTaskIds: options.excludeTaskIds,
@@ -4069,6 +4388,7 @@ function taskReviewLaneLoop(taskDb, db, options = {}) {
 	      owner,
 	      reviewer,
 	      all: Boolean(options.all),
+	      everywhere: Boolean(options.everywhere),
 	      limit: options.limit !== undefined ? options.limit : 8,
 	      scope,
 	      excludeTaskIds,
@@ -4121,6 +4441,7 @@ function taskReviewLaneLoop(taskDb, db, options = {}) {
 	      owner,
 	      reviewer,
 	      all: Boolean(options.all),
+	      everywhere: Boolean(options.everywhere),
 	      limit: options.limit !== undefined ? options.limit : 8,
 	      scope,
 	      excludeTaskIds,
@@ -4308,6 +4629,7 @@ function taskReviewLaneRun(taskDb, db, options = {}) {
 	      owner,
 	      reviewer,
 	      all: Boolean(options.all),
+	      everywhere: Boolean(options.everywhere),
 	      limit: options.limit !== undefined ? options.limit : 8,
 	      scope,
 	      excludeTaskIds,
@@ -4417,6 +4739,483 @@ function cmdReviewLaneRun(args) {
   if (!result.ok) process.exit(1);
 }
 
+function configValueDisabled(value) {
+  if (value === false) return true;
+  const text = String(value === undefined || value === null ? '' : value).trim().toLowerCase();
+  return ['0', 'false', 'off', 'no'].includes(text);
+}
+
+function reviewAutoAcceptEnabled() {
+  try {
+    const { loadConfig } = require('../utils/config');
+    const config = loadConfig();
+    const value = Object.prototype.hasOwnProperty.call(config, 'autoaccept')
+      ? config.autoaccept
+      : Object.prototype.hasOwnProperty.call(config, 'review_autoaccept')
+        ? config.review_autoaccept
+        : config.reviewAutoaccept;
+    return !configValueDisabled(value);
+  } catch {
+    return true;
+  }
+}
+
+function reviewAutoAcceptStatePath(root = process.cwd()) {
+  return path.join(root, '.atris', 'state', 'review-autoaccept.json');
+}
+
+function readReviewAutoAcceptState(root = process.cwd()) {
+  const file = reviewAutoAcceptStatePath(root);
+  try {
+    if (!fs.existsSync(file)) return {};
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeReviewAutoAcceptState(root = process.cwd(), state = {}) {
+  const file = reviewAutoAcceptStatePath(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+function finiteNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function firstNumberFromObject(source, keys) {
+  if (!source || typeof source !== 'object') return null;
+  for (const key of keys) {
+    if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+    const value = source[key];
+    if (Array.isArray(value)) return value.length;
+    if (typeof value === 'string' && value.includes(',')) {
+      const parts = value.split(',').map(part => part.trim()).filter(Boolean);
+      if (parts.length > 1) return parts.length;
+    }
+    const number = finiteNumber(value);
+    if (number !== null) return number;
+  }
+  return null;
+}
+
+function arrayFromPathValue(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.flatMap(arrayFromPathValue);
+  if (typeof value === 'object') {
+    if (typeof value.path === 'string') return [value.path];
+    if (typeof value.file === 'string') return [value.file];
+    if (typeof value.filename === 'string') return [value.filename];
+    return [];
+  }
+  return String(value)
+    .split(/[\n,]+/)
+    .map(part => part.trim())
+    .filter(Boolean);
+}
+
+function collectRecordedDiffPaths(source) {
+  if (!source || typeof source !== 'object') return [];
+  const keys = [
+    'files',
+    'paths',
+    'touched_files',
+    'touchedFiles',
+    'changed_files',
+    'changedFiles',
+    'modified_files',
+    'modifiedFiles',
+  ];
+  const out = [];
+  for (const key of keys) out.push(...arrayFromPathValue(source[key]));
+  return out;
+}
+
+function normalizeRecordedDiffStats(source, label = 'recorded') {
+  if (!source || typeof source !== 'object') return null;
+  const fileKeys = [
+    'files_touched',
+    'filesTouched',
+    'changed_files_count',
+    'changedFilesCount',
+    'files_changed',
+    'filesChanged',
+    'file_count',
+    'fileCount',
+    'files',
+    'changed_files',
+    'changedFiles',
+  ];
+  const changedLineKeys = [
+    'changed_lines',
+    'changedLines',
+    'lines_changed',
+    'linesChanged',
+    'changed_line_count',
+    'changedLineCount',
+    'total_changed_lines',
+    'totalChangedLines',
+    'line_count',
+    'lineCount',
+  ];
+  const insertions = firstNumberFromObject(source, ['insertions', 'added', 'additions', 'lines_added', 'linesAdded']);
+  const deletions = firstNumberFromObject(source, ['deletions', 'deleted', 'removals', 'lines_deleted', 'linesDeleted']);
+  const paths = collectRecordedDiffPaths(source);
+  const filesTouched = firstNumberFromObject(source, fileKeys) ?? (paths.length ? paths.length : null);
+  const changedLines = firstNumberFromObject(source, changedLineKeys)
+    ?? (insertions !== null || deletions !== null ? Number(insertions || 0) + Number(deletions || 0) : null);
+  if (filesTouched === null && changedLines === null && !paths.length) return null;
+  return {
+    source: label,
+    files_touched: filesTouched,
+    changed_lines: changedLines,
+    paths,
+  };
+}
+
+function recordedDiffStatsForTask(task) {
+  const metadata = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  const candidates = [
+    metadata.diff_stats,
+    metadata.diffStats,
+    metadata.git_diff_stats,
+    metadata.gitDiffStats,
+    metadata.change_stats,
+    metadata.changeStats,
+    metadata.stats,
+    metadata,
+  ];
+  for (const candidate of candidates) {
+    const stats = normalizeRecordedDiffStats(candidate, 'recorded');
+    if (stats) return stats;
+  }
+  return null;
+}
+
+function proofDiffStats(proof) {
+  const text = String(proof || '').replace(/\s+/g, ' ').trim();
+  if (!text) return null;
+  let filesTouched = null;
+  let changedLines = null;
+  const gitStat = text.match(/(\d+)\s+files?\s+changed(?:,\s*(\d+)\s+insertions?\(\+\))?(?:,\s*(\d+)\s+deletions?\(-\))?/i);
+  if (gitStat) {
+    filesTouched = Number(gitStat[1]);
+    const insertions = gitStat[2] ? Number(gitStat[2]) : 0;
+    const deletions = gitStat[3] ? Number(gitStat[3]) : 0;
+    if (gitStat[2] || gitStat[3]) changedLines = insertions + deletions;
+  }
+  const filePatterns = [
+    /files?\s+(?:touched|changed|modified)\s*[:=]\s*(\d+)/i,
+    /(\d+)\s+files?\s+(?:touched|changed|modified)/i,
+  ];
+  for (const pattern of filePatterns) {
+    const match = text.match(pattern);
+    if (match) filesTouched = Number(match[1]);
+  }
+  const linePatterns = [
+    /changed\s+lines?\s*[:=]\s*(\d+)/i,
+    /(\d+)\s+changed\s+lines?/i,
+    /lines?\s+changed\s*[:=]\s*(\d+)/i,
+  ];
+  for (const pattern of linePatterns) {
+    const match = text.match(pattern);
+    if (match) changedLines = Number(match[1]);
+  }
+  if (filesTouched === null && changedLines === null) return null;
+  return {
+    source: 'proof',
+    files_touched: filesTouched,
+    changed_lines: changedLines,
+    paths: [],
+  };
+}
+
+function safeGitRef(value) {
+  const text = String(value || '').trim();
+  if (!text || text.startsWith('-') || text.includes('..')) return null;
+  if (!/^[a-zA-Z0-9_./@=+~^-]+$/.test(text)) return null;
+  return text;
+}
+
+function runGitForAutoAccept(root, args) {
+  try {
+    const { spawnSync } = require('child_process');
+    return spawnSync('git', args, {
+      cwd: root || process.cwd(),
+      encoding: 'utf8',
+      timeout: 10000,
+    });
+  } catch {
+    return { status: 1, stdout: '', stderr: '' };
+  }
+}
+
+function gitRefExists(root, ref) {
+  const result = runGitForAutoAccept(root, ['rev-parse', '--verify', `${ref}^{commit}`]);
+  return result.status === 0;
+}
+
+function defaultDiffBase(root) {
+  for (const ref of ['origin/master', 'origin/main', 'master', 'main']) {
+    if (gitRefExists(root, ref)) return ref;
+  }
+  return null;
+}
+
+function branchDiffStatsForTask(task, root) {
+  const metadata = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  const branch = safeGitRef(
+    metadata.branch
+      || metadata.worktree_branch
+      || metadata.git_branch
+      || metadata.pr_branch
+      || metadata.head_branch
+      || metadata.worktree?.branch
+  );
+  if (!branch) return null;
+  const base = safeGitRef(
+    metadata.base
+      || metadata.base_ref
+      || metadata.target_ref
+      || metadata.target_branch
+      || metadata.worktree?.base
+  ) || defaultDiffBase(root);
+  if (!base) return null;
+  const result = runGitForAutoAccept(root, ['diff', '--numstat', `${base}...${branch}`]);
+  if (result.status !== 0) return null;
+  const lines = String(result.stdout || '').split(/\r?\n/).filter(Boolean);
+  if (!lines.length) return { source: 'branch', files_touched: 0, changed_lines: 0, paths: [] };
+  let changedLines = 0;
+  let unknownLines = false;
+  const paths = [];
+  for (const line of lines) {
+    const parts = line.split(/\t+/);
+    const added = Number(parts[0]);
+    const deleted = Number(parts[1]);
+    if (!Number.isFinite(added) || !Number.isFinite(deleted)) unknownLines = true;
+    else changedLines += added + deleted;
+    if (parts[2]) paths.push(parts.slice(2).join('\t'));
+  }
+  return {
+    source: 'branch',
+    files_touched: lines.length,
+    changed_lines: unknownLines ? null : changedLines,
+    paths,
+  };
+}
+
+function reviewAutoAcceptDiffStats(task, root) {
+  const recorded = recordedDiffStatsForTask(task);
+  if (recorded) return recorded;
+  const branch = branchDiffStatsForTask(task, root);
+  if (branch) return branch;
+  const proof = String(task?.review?.proof || task?.metadata?.latest_agent_proof || '');
+  return proofDiffStats(proof);
+}
+
+function reviewAutoAcceptBigTitle(task) {
+  const metadata = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  const text = [
+    task && task.title,
+    metadata.kind,
+    metadata.type,
+    metadata.category,
+    metadata.report_type,
+  ].map(value => String(value || '')).join(' ').toLowerCase();
+  const match = text.match(/\b(daily\s+update|summary|report|digest|retro|retrospective)\b/i);
+  if (!match) return null;
+  return {
+    ok: false,
+    reason: `big_title_${match[1].toLowerCase().replace(/\s+/g, '_')}`,
+  };
+}
+
+function reviewAutoAcceptSizeGate(task, root) {
+  const titleGate = reviewAutoAcceptBigTitle(task);
+  if (titleGate) return titleGate;
+  const stats = reviewAutoAcceptDiffStats(task, root);
+  if (!stats) return { ok: false, reason: 'size_unknown', stats: null };
+  const filesTouched = finiteNumber(stats.files_touched);
+  const changedLines = finiteNumber(stats.changed_lines);
+  if (filesTouched !== null && filesTouched > REVIEW_AUTO_ACCEPT_FILE_LIMIT) {
+    return { ok: false, reason: 'big_files', stats };
+  }
+  if (changedLines !== null && changedLines > REVIEW_AUTO_ACCEPT_LINE_LIMIT) {
+    return { ok: false, reason: 'big_changed_lines', stats };
+  }
+  if (filesTouched === null || changedLines === null) {
+    return { ok: false, reason: 'size_unknown', stats };
+  }
+  return { ok: true, reason: 'small_change', stats };
+}
+
+function reviewAutoAcceptMetadataText(task) {
+  const metadata = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  return [
+    task && task.title,
+    task && task.tag,
+    task && task.source_key,
+    metadata.kind,
+    metadata.type,
+    metadata.category,
+    metadata.lane,
+    metadata.stage,
+    metadata.area,
+    JSON.stringify(metadata),
+  ].map(value => String(value || '')).join(' ').toLowerCase();
+}
+
+function reviewAutoAcceptTouchedPaths(task) {
+  const metadata = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  const stats = recordedDiffStatsForTask(task);
+  const proof = String(task?.review?.proof || metadata.latest_agent_proof || '');
+  return [
+    ...(stats && stats.paths ? stats.paths : []),
+    ...collectRecordedDiffPaths(metadata),
+    ...taskReviewEvidencePaths(proof, 50),
+  ].map(value => String(value || '').trim()).filter(Boolean);
+}
+
+function reviewProtectedMatch(task) {
+  const text = reviewAutoAcceptMetadataText(task);
+  const paths = reviewAutoAcceptTouchedPaths(task).join(' ').toLowerCase();
+  const combined = `${text} ${paths}`;
+  const checks = [
+    ['auth', /\b(auth|authentication|authorization|oauth|login|session)\b/i],
+    ['credentials', /\b(credentials?|secrets?|passwords?|api[-_ ]?keys?|tokens?)\b/i],
+    ['csp', /\b(csp|content[-_ ]security[-_ ]policy)\b/i],
+    ['sandbox', /\b(sandbox|allow-scripts|allow-same-origin)\b/i],
+    ['billing', /\b(billing|invoice|invoices|subscription|subscriptions)\b/i],
+    ['payments', /\b(payments?|stripe|checkout|refunds?)\b/i],
+    ['outbound_sends', /\b(outbound|send|sending|email|sms|webhook|notification|notifications)\b/i],
+  ];
+  for (const [key, pattern] of checks) {
+    if (pattern.test(combined)) return { ok: false, reason: `protected_${key}` };
+  }
+  return { ok: true };
+}
+
+function evaluateReviewAutoAccept(task, root) {
+  const ref = taskRef(task);
+  if (!task) return { eligible: false, ref, reason: 'task_not_found' };
+  const protectedGate = reviewProtectedMatch(task);
+  if (!protectedGate.ok) return { eligible: false, ref, reason: protectedGate.reason };
+  const sizeGate = reviewAutoAcceptSizeGate(task, root);
+  if (!sizeGate.ok) return { eligible: false, ref, reason: sizeGate.reason, size: sizeGate.stats };
+  const evaluation = evaluateAutoAccept(task, { strictVerify: true });
+  if (!evaluation.eligible) {
+    return {
+      ...evaluation,
+      size: sizeGate.stats,
+    };
+  }
+  return {
+    ...evaluation,
+    eligible: true,
+    reason: 'certified_small',
+    policy: REVIEW_AUTO_ACCEPT_POLICY,
+    size: sizeGate.stats,
+  };
+}
+
+function autoAcceptCertifiedSmallReviews(taskDb, db, projection) {
+  const enabled = reviewAutoAcceptEnabled();
+  const root = projection.workspace_root || process.cwd();
+  const results = [];
+  if (!enabled) {
+    return {
+      enabled,
+      scanned: 0,
+      accepted: 0,
+      changed: false,
+      results,
+    };
+  }
+  const certified = certifiedPendingReviewTasks(projection);
+  for (const item of certified) {
+    const fullProjection = enrichTaskProjection(taskDb.taskProjection(db, { taskId: item.id }));
+    const task = fullProjection.tasks[0] || null;
+    const evaluation = evaluateReviewAutoAccept(task, root);
+    if (!evaluation.eligible) {
+      results.push({ ...evaluation, action: 'queued', task_id: task?.id || item.id || null });
+      continue;
+    }
+    const accepted = acceptReviewTask(taskDb, db, task.id, {
+      actor: REVIEW_AUTO_ACCEPT_ACTOR,
+      proof: evaluation.proof,
+      reward: 1,
+      lesson: String(task.review?.lesson || task.metadata?.latest_agent_lesson || ''),
+      nextTask: String(task.review?.next_task || task.metadata?.latest_agent_next_task || ''),
+      autoAccepted: true,
+    });
+    if (!accepted.ok) {
+      results.push({ ...evaluation, action: 'accept_failed', task_id: task.id, reason: accepted.reason });
+      continue;
+    }
+    stampAutoAcceptMetadata(taskDb, db, task.id, REVIEW_AUTO_ACCEPT_ACTOR, REVIEW_AUTO_ACCEPT_POLICY);
+    refreshCareerXpAfterReview(accepted.reviewed);
+    results.push({
+      ...evaluation,
+      action: 'accepted',
+      task_id: task.id,
+      reward: accepted.reviewed.episode.reward.value,
+    });
+  }
+  const acceptedCount = results.filter(row => row.action === 'accepted').length;
+  return {
+    enabled,
+    scanned: certified.length,
+    accepted: acceptedCount,
+    changed: acceptedCount > 0,
+    results,
+  };
+}
+
+function autoAcceptedReviewRowsSince(taskDb, db, workspaceRoot, sinceIso, acceptedNowIds = []) {
+  const sinceMs = Date.parse(sinceIso || '');
+  const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot }));
+  const acceptedNow = new Set(acceptedNowIds.filter(Boolean));
+  const seen = new Set();
+  const out = [];
+  for (const row of rows) {
+    const metadata = row.metadata && typeof row.metadata === 'object' ? row.metadata : {};
+    const acceptedAt = Date.parse(metadata.auto_accepted_at || metadata.accepted_at || '');
+    const policyMatch = metadata.auto_accept_policy === REVIEW_AUTO_ACCEPT_POLICY
+      || metadata.auto_accepted_by === REVIEW_AUTO_ACCEPT_ACTOR
+      || metadata.accepted_by === REVIEW_AUTO_ACCEPT_ACTOR;
+    const isCurrent = acceptedNow.has(row.id);
+    const isSince = Number.isFinite(sinceMs) && Number.isFinite(acceptedAt) && acceptedAt > sinceMs;
+    const firstLook = !Number.isFinite(sinceMs) && Number.isFinite(acceptedAt);
+    if (row.status !== 'done' || !policyMatch || (!isCurrent && !isSince && !firstLook)) continue;
+    if (seen.has(row.id)) continue;
+    seen.add(row.id);
+    out.push({
+      id: row.id,
+      ref: row.display_id || taskRef(row),
+      title: row.title,
+      accepted_at: metadata.auto_accepted_at || metadata.accepted_at || null,
+    });
+  }
+  out.sort((a, b) => String(b.accepted_at || '').localeCompare(String(a.accepted_at || '')));
+  return out;
+}
+
+function reviewAutoAcceptRollup(taskDb, db, workspaceRoot, previousState, autoAcceptRun) {
+  const acceptedNowIds = (autoAcceptRun.results || [])
+    .filter(row => row.action === 'accepted')
+    .map(row => row.task_id)
+    .filter(Boolean);
+  const rows = autoAcceptedReviewRowsSince(taskDb, db, workspaceRoot, previousState.last_look_at, acceptedNowIds);
+  return {
+    count: rows.length,
+    items: rows,
+    since: previousState.last_look_at || null,
+  };
+}
+
 function reviewQueueLimit(args, total) {
   if (hasFlag(args, '--all')) return total;
   const raw = flag(args, '--limit');
@@ -4435,6 +5234,17 @@ function reviewGroupTextLimit(args, total) {
   return Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 10;
 }
 
+function plainReviewBlockerMessage(item) {
+  const ref = item.display_id || taskRef(item.id);
+  if (item.reason === 'verify_command_not_allowed') {
+    return `${ref} used a check command the system does not allow; rerun with an approved check`;
+  }
+  if (item.reason === 'needs_second_actor_review') {
+    return `${ref} needs a second reviewer before it can land`;
+  }
+  return `${ref} needs another check before it can land`;
+}
+
 // Risk order for human attention: named receipts that are missing/failing (0)
 // beat prose-only proofs (1) beat fully validated green evidence (2).
 function evidenceRiskRank(evidence) {
@@ -4488,7 +5298,20 @@ function reviewQueueItem(task, root = process.cwd(), evidence = undefined) {
   return item;
 }
 
-function reviewQueueHygiene(tasks) {
+function blockedReviewQueueItem(task, root = process.cwd()) {
+  const item = reviewQueueItem(task, root);
+  const blocker = reviewBlockerForTask(task);
+  item.queue_role = 'blocked';
+  item.reason = blocker.reason;
+  item.blocked_reason = blocker.reason;
+  item.next_command = blocker.next_command;
+  item.verify_command = blocker.verify_command;
+  item.accept_command = null;
+  item.land_command = null;
+  return item;
+}
+
+function reviewQueueHygiene(tasks) {
   const genericContinuations = (tasks || []).map(task => {
     const issues = genericContinuationIssues(task);
     if (!issues.length) return null;
@@ -4526,7 +5349,10 @@ function taskReviewQueue(projection, args = []) {
   const ordered = [...certified].sort((a, b) =>
     evidenceRiskRank(evidenceByTaskId.get(b.id)) - evidenceRiskRank(evidenceByTaskId.get(a.id))
     || Number(b.updated_at || 0) - Number(a.updated_at || 0));
-  const items = ordered.slice(0, limit).map((task) => reviewQueueItem(task, root, evidenceByTaskId.get(task.id)));
+  const certifiedItems = ordered.slice(0, limit).map((task) => reviewQueueItem(task, root, evidenceByTaskId.get(task.id)));
+  const blockedLimit = reviewQueueLimit(args, blocking.length);
+  const blockedItems = blocking.slice(0, blockedLimit).map((task) => blockedReviewQueueItem(task, root));
+  const items = [...certifiedItems, ...blockedItems];
   return {
     schema: 'atris.task_review_queue.v1',
     generated_at: projection.generated_at,
@@ -4537,7 +5363,8 @@ function taskReviewQueue(projection, args = []) {
       evidence_passing: certified.filter((task) => evidenceByTaskId.get(task.id)?.all_passing).length,
       blocking: blocking.length,
       proof_boundary_blocked: proofBoundaryBlocked.length,
-      shown: items.length,
+      shown: certifiedItems.length,
+      blocking_shown: blockedItems.length,
     },
     hygiene: reviewQueueHygiene(reviewTasks),
     items,
@@ -4595,30 +5422,72 @@ function taskReviewGroups(projection, key) {
   };
 }
 
+function taskReviewLandingLines(item) {
+  if (!item?.landing) return [];
+  const clean = value => value
+    ? gateForHuman(value, { title: item.title }).text
+    : '';
+  const happened = clean(item.landing.happened);
+  const reason = clean(item.landing.reason);
+  const unperiod = value => value.replace(/\.$/, '');
+  const checked = unperiod(clean(item.landing.checked));
+  const tested = unperiod(clean(item.landing.tested));
+  return [
+    happened ? `   what's new: ${happened}` : '',
+    reason ? `   why it matters: ${reason}` : '',
+    checked ? `   checked: ${checked}${tested && tested !== checked ? `; tested: ${tested}` : ''}.` : '',
+  ].filter(Boolean);
+}
+
 function cmdReviews(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
-  const { projection, outPath } = writeDefaultProjection(taskDb, db);
+  let { projection, outPath } = writeDefaultProjection(taskDb, db);
+  const workspaceRoot = projection.workspace_root || process.cwd();
+  const previousAutoAcceptState = readReviewAutoAcceptState(workspaceRoot);
+  const autoAcceptRun = autoAcceptCertifiedSmallReviews(taskDb, db, projection);
+  if (autoAcceptRun.changed) {
+    ({ projection, outPath } = writeDefaultProjection(taskDb, db));
+  }
+  const autoAcceptRollup = reviewAutoAcceptRollup(taskDb, db, workspaceRoot, previousAutoAcceptState, autoAcceptRun);
+  writeReviewAutoAcceptState(workspaceRoot, {
+    ...previousAutoAcceptState,
+    last_look_at: new Date().toISOString(),
+    last_count: autoAcceptRollup.count,
+  });
   const groupByRaw = flag(args, '--group-by');
   if (groupByRaw) {
     const key = reviewGroupKey(groupByRaw);
     const groups = taskReviewGroups(projection, key);
     if (wantsJson(args)) {
-      printJson({ ok: true, action: 'review_groups', projection_path: outPath, groups });
+      printJson({
+        ok: true,
+        action: 'review_groups',
+        projection_path: outPath,
+        autoaccept: {
+          enabled: autoAcceptRun.enabled,
+          accepted_now: autoAcceptRun.accepted,
+          accepted_since_last_look: autoAcceptRollup.count,
+          results: autoAcceptRun.results,
+        },
+        groups,
+      });
       return;
     }
-    console.log(`READY FOR APPROVAL — grouped by ${key}`);
-    console.log(`${groups.total_certified} ready for approval across ${groups.group_count} ${key} group(s)`);
+    console.log(gateForHuman(`${numberWord(groups.total_certified)} finished things are waiting, grouped by ${key}.`).text);
+    if (autoAcceptRollup.count > 0) {
+      console.log(gateForHuman(`${numberWord(autoAcceptRollup.count)} landed on their own since you last looked.`).text);
+    }
     const visibleGroups = groups.groups.slice(0, reviewGroupTextLimit(args, groups.groups.length));
     visibleGroups.forEach((g, index) => {
       console.log('');
-      console.log(`${index + 1}. ${g.value} — ${g.count} task${g.count === 1 ? '' : 's'}`);
-      g.sample_titles.forEach(title => console.log(`   • ${title}`));
+      console.log(`${index + 1}. ${g.value} - ${numberWord(g.count)} task${g.count === 1 ? '' : 's'}`);
+      g.sample_titles.forEach(title => console.log(`   • ${gateForHuman(title, { title }).text}`));
       console.log(`   approve this group: ${g.accept_group_command} --confirm-human-accept --as <you>`);
     });
     if (visibleGroups.length < groups.groups.length) {
       console.log('');
-      console.log(`Showing ${visibleGroups.length}/${groups.groups.length} groups; rerun with --all for every group or --limit N to adjust.`);
+      console.log(`showing ${numberWord(visibleGroups.length)} of ${numberWord(groups.groups.length)} groups; rerun with --all for every group or --limit N to adjust.`);
     }
     return;
   }
@@ -4629,30 +5498,45 @@ function cmdReviews(args) {
       ok: true,
       action: 'review_queue',
       projection_path: outPath,
+      autoaccept: {
+        enabled: autoAcceptRun.enabled,
+        accepted_now: autoAcceptRun.accepted,
+        accepted_since_last_look: autoAcceptRollup.count,
+        results: autoAcceptRun.results,
+      },
       queue,
     });
     return;
   }
-  console.log('READY FOR APPROVAL');
-  console.log(`${queue.counts.certified} ready for approval / ${queue.counts.blocking} need one more check / ${queue.counts.review} total waiting`);
-  if (!queue.items.length) {
-    console.log('Nothing is ready for approval.');
+  const approvalItems = queue.items.filter(item => item.queue_role !== 'blocked');
+  const blockedItems = queue.items.filter(item => item.queue_role === 'blocked');
+  if (!approvalItems.length && !blockedItems.length) {
+    console.log('nothing is waiting on you. everything that finished has already landed.');
+    if (autoAcceptRollup.count > 0) {
+      console.log(gateForHuman(`${numberWord(autoAcceptRollup.count)} landed on their own since you last looked.`).text);
+    }
     return;
   }
-  queue.items.forEach((item, index) => {
-    const tag = item.tag ? ` [${item.tag}]` : '';
-    const passes = item.review_pass_count ? ` (${item.review_pass_count} reviews)` : '';
-    const badge = item.evidence?.all_passing ? ' [evidence:passing]' : '';
-    console.log('');
-    console.log(`${index + 1}. ${item.display_id || taskRef(item.id)}${tag}${passes}: ${item.title}${badge}`);
+  if (queue.counts.certified > 0) {
+    const header = queue.counts.certified === 1
+      ? 'one finished thing is waiting for your ok. it passed both checks.'
+      : `${numberWord(queue.counts.certified)} finished things are waiting for your ok. all of them passed both checks.`;
+    console.log(gateForHuman(header).text);
+  }
+  if (queue.counts.blocking > 0) {
+    console.log(gateForHuman(queue.counts.blocking === 1
+      ? 'one more is almost ready; a second check is still running.'
+      : `${numberWord(queue.counts.blocking)} more are almost ready; second checks are still running.`).text);
+  }
+  if (autoAcceptRollup.count > 0) {
+    console.log(gateForHuman(`${numberWord(autoAcceptRollup.count)} landed on their own since you last looked.`).text);
+  }
+  approvalItems.forEach((item, index) => {
+    if (index > 0) console.log('');
+    console.log(`${index + 1}. ${gateForHuman(item.title, { title: item.title }).text}`);
     if (item.landing) {
-      console.log('   Result:');
-      if (item.landing.happened) console.log(`     What happened: ${item.landing.happened}`);
-      if (item.landing.reason) console.log(`     Why it matters: ${item.landing.reason}`);
-      if (item.landing.checked) console.log(`     How I checked: ${item.landing.checked}`);
-      if (item.landing.tested) console.log(`     What I tested: ${item.landing.tested}`);
-      if (item.result?.saved) console.log(`     Saved: ${item.result.saved}`);
-      if (item.landing.decision) console.log(`     Decision: ${item.landing.decision}`);
+      taskReviewLandingLines(item).forEach(line => console.log(line));
+      if (verbose && item.result?.saved) console.log(`   saved: ${item.result.saved}`);
     }
     if (verbose && item.proof) console.log(`   details: ${item.proof}`);
     if (verbose && item.evidence) {
@@ -4664,14 +5548,23 @@ function cmdReviews(args) {
       item.evidence.missing.forEach((missingPath) => console.log(`   receipt: ${missingPath} MISSING`));
     }
     if (verbose && item.review_chat_command) console.log(`   /codex: ${item.review_chat_command}`);
-    if (item.continue_work_command) console.log(`   continue: ${item.continue_work_command}`);
-    if (item.accept_command) console.log(`   approve: ${item.accept_command}`);
-    else if (item.blocked_accept_reason) console.log(`   approve: blocked (${item.blocked_accept_reason})`);
-    console.log(`   rework: ${item.revise_command}`);
+    if (item.accept_command) {
+      console.log(`   say yes: atris task accept ${item.display_id || taskRef(item.id)}`);
+    } else if (item.blocked_accept_reason) {
+      console.log(`   approve: blocked (${item.blocked_accept_reason})`);
+      console.log(`   rework: ${item.revise_command}`);
+    }
   });
+  if (blockedItems.length > 0) {
+    if (approvalItems.length > 0) console.log('');
+    console.log('still being checked:');
+    for (const item of blockedItems) {
+      console.log(`${plainReviewBlockerMessage(item)}; next: ${item.next_command}`);
+    }
+  }
   if (queue.counts.shown < queue.counts.certified) {
     console.log('');
-    console.log(`Showing ${queue.counts.shown}/${queue.counts.certified}; rerun with --all for every row or --verbose for proof details.`);
+    console.log(`showing ${numberWord(queue.counts.shown)} of ${numberWord(queue.counts.certified)}; rerun with --all for every row or --verbose for proof details.`);
   }
 }
 
@@ -4786,6 +5679,11 @@ function cmdAcceptGroup(args) {
     const isVerified = verifiedIds.has(task.id);
     const proof = String(task.review?.proof || task.metadata?.latest_agent_proof || '').trim()
       || `Accepted via group spot-check (${groupLabel}); human ${actor} verified ${verifiedIds.size}/${group.length}.`;
+    const missionXpIssue = missionXpEndToEndProofIssue(task, proof, task.workspace_root || taskDb.workspaceRoot());
+    if (missionXpIssue) {
+      accepted.push({ id: task.id, ok: false, reason: MISSION_XP_END_TO_END_REASON, detail: missionXpIssue });
+      continue;
+    }
     const done = taskDb.doneTask(db, {
       id: task.id,
       status: 'done',
@@ -4867,19 +5765,21 @@ function formatTaskLine(task) {
 
 function cmdStatus(args) {
   const all = hasFlag(args, '--all');
+  const everywhere = taskScopeEverywhere(args);
   const history = hasFlag(args, '--history');
   const taskDb = getTaskDb();
   const db = taskDb.open();
-  const compact = writeDefaultProjection(taskDb, db, { all });
+  const workspaceRoot = scopedWorkspaceRoot(taskDb, args, { everywhere });
+  const compact = writeDefaultProjection(taskDb, db, { all, everywhere });
   const projection = history
     ? enrichTaskProjection(taskDb.taskProjection(db, {
-      workspaceRoot: all ? null : taskDb.workspaceRoot(),
-      limit: 500,
+      workspaceRoot,
+      limit: all ? null : 500,
       includeHistory: true,
     }))
     : compact.projection;
   const outPath = compact.outPath;
-  const hasExistingReviewFollowUp = buildReviewFollowUpChildPredicate(taskDb, db, all ? null : taskDb.workspaceRoot());
+  const hasExistingReviewFollowUp = buildReviewFollowUpChildPredicate(taskDb, db, workspaceRoot);
   const status = taskStatusSummary(projection, { history, hasExistingReviewFollowUp });
   if (wantsJson(args)) {
     printJson({
@@ -4936,13 +5836,13 @@ function requireTaskId(taskDb, db, ref, label) {
   }
 }
 
-function workspaceRefRows(taskDb, db, all = false) {
-  return taskDb.listTasks(db, { workspaceRoot: all ? null : taskDb.workspaceRoot() });
+function workspaceRefRows(taskDb, db, options = {}) {
+  return taskDb.listTasks(db, { workspaceRoot: scopedWorkspaceRoot(taskDb, [], options) });
 }
 
 function renderTaskDesk(rows, refRows = rows) {
   const displayRows = getTaskDb().withTaskDisplayRefs(rows, refRows);
-  const active = displayRows.filter(r => r.status !== 'done');
+  const active = displayRows.filter(r => r.status !== 'done' && r.status !== 'archived');
   const done = displayRows.filter(r => r.status === 'done');
   if (rows.length === 0) {
     console.log('No tasks yet.');
@@ -5033,7 +5933,7 @@ function delegateHandoff(task, owner, via, tag) {
   return handoff;
 }
 
-function cmdDelegate(args) {
+function delegateTask(args, options = {}) {
   const pos = positional(args);
   const title = pos.join(' ').trim();
   if (!title) {
@@ -5051,7 +5951,7 @@ function cmdDelegate(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const ws = taskDb.workspaceRoot();
-  const operatorTitleWarning = warnIfTaskTitleNeedsOperatorWhy(title);
+  const operatorTitleWarning = warnIfTaskTitleNeedsOperatorWhy(title, { print: options.warnOperatorTitle !== false });
   const ownerResolution = resolveFunctionalTaskOwner({
     requestedOwner: requestedOwner && requestedOwner !== true ? requestedOwner : null,
     title,
@@ -5096,34 +5996,69 @@ function cmdDelegate(args) {
   const { projection, outPath } = writeDefaultProjection(taskDb, db);
   const task = compactTaskFromProjection(projection, result.id);
   const handoff = delegateHandoff(task, owner, via, typeof tag === 'string' ? tag : null);
+  return {
+    ok: true,
+    action: 'delegated',
+    task_id: result.id,
+    inserted: result.inserted !== false,
+    owner,
+    owner_resolution: ownerResolution,
+    executed_by: executedBy || null,
+    via,
+    tag: typeof tag === 'string' ? tag : null,
+    handoff,
+    proposed_member_command: metadata.proposed_member_command || null,
+    operator_title_warning: operatorTitleWarning,
+    projection_path: outPath,
+    task,
+  };
+}
+
+function cmdDelegate(args) {
+  const payload = delegateTask(args);
   if (wantsJson(args)) {
-    printJson({
-      ok: true,
-      action: 'delegated',
-      task_id: result.id,
-      inserted: result.inserted !== false,
-      owner,
-      owner_resolution: ownerResolution,
-      executed_by: executedBy || null,
-      via,
-      handoff,
-      operator_title_warning: operatorTitleWarning,
-      projection_path: outPath,
-      task,
-    });
+    printJson(payload);
     return;
   }
-  const tagText = tag && tag !== true ? ` #${tag}` : '';
-  console.log(`delegated ${taskRef(task)} -> ${owner}${tagText} via=${via}`);
-  if (executedBy) console.log(`executed_by: ${executedBy}`);
-  if (ownerResolution.proposed_member) console.log(`member: ${metadata.proposed_member_command}`);
-  console.log(`claim: ${handoff.command}`);
-  if (handoff.swarlo) console.log(`swarlo: ${handoff.swarlo.channel}/${handoff.swarlo.action}`);
+  const tagText = payload.tag ? ` #${payload.tag}` : '';
+  console.log(`delegated ${taskRef(payload.task)} -> ${payload.owner}${tagText} via=${payload.via}`);
+  if (payload.executed_by) console.log(`executed_by: ${payload.executed_by}`);
+  if (payload.proposed_member_command) console.log(`member: ${payload.proposed_member_command}`);
+  console.log(`claim: ${payload.handoff.command}`);
+  if (payload.handoff.swarlo) console.log(`swarlo: ${payload.handoff.swarlo.channel}/${payload.handoff.swarlo.action}`);
 }
 
 // Failed tasks older than this stop earning a daily owner-group row;
 // they collapse into one stale summary line instead (target state = clean day view).
 const DAY_STALE_FAILED_MS = 7 * 24 * 60 * 60 * 1000;
+const DAY_TEXT_TASK_LIMIT = 8;
+
+function taskDayTextGroups(groups, { full = false } = {}) {
+  if (full) return { groups, hiddenTasks: 0, hiddenOwners: 0 };
+  const statusOrder = { claimed: 0, open: 1, review: 2, failed: 3, done: 4 };
+  const ranked = groups
+    .flatMap((group) => group.tasks)
+    .sort((a, b) => ((statusOrder[a.status] ?? 5) - (statusOrder[b.status] ?? 5))
+      || ((b.updated_at || 0) - (a.updated_at || 0)));
+  const selected = new Set(ranked.slice(0, DAY_TEXT_TASK_LIMIT));
+  const visibleGroups = groups
+    .map((group) => ({ ...group, tasks: group.tasks.filter((task) => selected.has(task)) }))
+    .filter((group) => group.tasks.length > 0);
+  return {
+    groups: visibleGroups,
+    hiddenTasks: Math.max(0, ranked.length - selected.size),
+    hiddenOwners: Math.max(0, groups.length - visibleGroups.length),
+  };
+}
+
+function taskDayTitle(title, maxLength = 120) {
+  const text = String(title || '').replace(/\s*[—–]\s*/g, ' - ').replace(/\s+/g, ' ').trim();
+  if (text.length <= maxLength) return text;
+  const sentence = text.slice(0, maxLength + 1).match(/^(.{48,}?[.!?])(?:\s|$)/);
+  if (sentence) return sentence[1];
+  const clipped = text.slice(0, maxLength).replace(/\s+\S*$/, '').trim();
+  return `${clipped || text.slice(0, maxLength).trim()}...`;
+}
 
 function taskDayGroups(tasks, { now = Date.now() } = {}) {
   const active = tasks.filter(task => task.status !== 'done');
@@ -5158,9 +6093,11 @@ function taskDayGroups(tasks, { now = Date.now() } = {}) {
 
 function cmdDay(args) {
   const all = hasFlag(args, '--all');
+  const full = hasFlag(args, '--full');
+  const everywhere = taskScopeEverywhere(args);
   const taskDb = getTaskDb();
   const db = taskDb.open();
-  const { projection, outPath } = writeDefaultProjection(taskDb, db, { all });
+  const { projection, outPath } = writeDefaultProjection(taskDb, db, { all, everywhere });
   const { groups, staleFailed } = taskDayGroups(projection.tasks || []);
   const counts = {
     active: groups.reduce((sum, group) => sum + group.tasks.length, 0),
@@ -5187,24 +6124,30 @@ function cmdDay(args) {
     });
     return;
   }
-  console.log('TASK DAY');
+  const textView = taskDayTextGroups(groups, { full });
+  console.log('task day');
   const failedText = counts.failed > 0 ? ` / failed ${counts.failed}` : '';
   console.log(`${date}  active ${counts.active} / owners ${counts.owners} / review ${counts.review}${failedText}`);
   console.log('');
   if (!groups.length) {
     console.log('clear   no active tasks');
   }
-  for (const group of groups) {
+  for (const group of textView.groups) {
     console.log(`${group.owner}`);
-    for (const task of group.tasks.slice(0, 8)) {
+    for (const task of group.tasks) {
       const tag = task.tag ? ` #${task.tag}` : '';
       const claim = task.claimed_by ? ` @${task.claimed_by}` : '';
-      console.log(`  ${task.status.padEnd(7)} ${taskRef(task)}${claim}${tag} ${task.title}`);
+      console.log(`  ${task.status.padEnd(7)} ${taskRef(task)}${claim}${tag} ${taskDayTitle(task.title)}`);
     }
   }
+  if (textView.hiddenTasks > 0) {
+    console.log('');
+    const ownerText = textView.hiddenOwners > 0 ? `, ${textView.hiddenOwners} owners not shown` : '';
+    console.log(`more    ${textView.hiddenTasks} active rows hidden${ownerText} - atris task day --full`);
+  }
   if (staleFailed.length) {
     console.log('');
-    console.log(`stale   ${staleFailed.length} failed >7d hidden — atris task list --status failed`);
+    console.log(`stale   ${staleFailed.length} failed >7d hidden - atris task list --status failed`);
   }
   console.log('');
   console.log('add: atris task delegate "..." --to task-planner --tag tasks');
@@ -5212,13 +6155,15 @@ function cmdDay(args) {
 
 function cmdHome(args) {
   const all = hasFlag(args, '--all');
+  const everywhere = taskScopeEverywhere(args);
   const taskDb = getTaskDb();
   const db = taskDb.open();
+  const workspaceRoot = scopedWorkspaceRoot(taskDb, args, { everywhere });
   const rows = taskDb.listTasks(db, {
-    workspaceRoot: all ? null : taskDb.workspaceRoot(),
-    limit: 200,
+    workspaceRoot,
+    limit: all ? null : 200,
   });
-  const { projection, outPath } = writeDefaultProjection(taskDb, db, { all });
+  const { projection, outPath } = writeDefaultProjection(taskDb, db, { all, everywhere });
   if (wantsJson(args)) {
     printJson({
       ok: true,
@@ -5235,18 +6180,20 @@ function cmdHome(args) {
 
 function cmdList(args) {
   const all = hasFlag(args, '--all');
+  const everywhere = taskScopeEverywhere(args);
   const status = flag(args, '--status');
   const scope = taskQueueScopeFromArgs(args);
   const scoped = !taskQueueScopeIsEmpty(scope);
   const taskDb = getTaskDb();
   const db = taskDb.open();
+  const workspaceRoot = scopedWorkspaceRoot(taskDb, args, { everywhere });
   const rawRows = taskDb.listTasks(db, {
-    workspaceRoot: all ? null : taskDb.workspaceRoot(),
+    workspaceRoot,
     status: typeof status === 'string' ? status : null,
-    limit: scoped ? null : 200,
+    limit: scoped || all ? null : 200,
   });
   const rows = filterTasksByScope(rawRows, scope);
-  const displayRows = taskDb.withTaskDisplayRefs(rows, workspaceRefRows(taskDb, db, all));
+  const displayRows = taskDb.withTaskDisplayRefs(rows, workspaceRefRows(taskDb, db, { everywhere }));
   if (wantsJson(args)) {
     printJson({ ok: true, action: 'list', scope: normalizeTaskQueueScope(scope), tasks: displayRows });
     return;
@@ -5263,12 +6210,49 @@ function cmdList(args) {
   }
 }
 
+// judge != worker support: reserved system names (autoland-verifier and co)
+// can never be assumed via --as, and unknown names warn by default or fail
+// under ATRIS_ACTOR_VALIDATION=enforce. Only explicit --as values are
+// checked; the DEFAULT_OWNER fallback stays silent.
+function guardExplicitActor(command, value) {
+  if (typeof value !== 'string' || !value.trim()) return;
+  const check = reviewIntegrity.validateActor(value, { root: process.cwd() });
+  if (!check.ok) {
+    if (check.reason === 'reserved_actor') {
+      console.error(`${command}: reserved_actor: '${value}' is a system actor and cannot be used with --as`);
+    } else {
+      console.error(`${command}: actor_not_on_roster: '${value}' is not a workspace member or engine (actor validation is enforced)`);
+    }
+    process.exit(1);
+  }
+  if (check.reason === 'actor_not_on_roster' && check.mode === 'warn') {
+    console.error(`Warning: '${value}' is not a workspace member or engine; reviews under unknown names weaken the audit trail.`);
+  }
+}
+
+// A claim against an already-done task burns a whole dispatch when a
+// rendered view (atris/TODO.md) is stale: the agent claims, builds, then
+// discovers the work was already done. Point straight at a real open task
+// instead of just reporting the failure, straight from the live projection
+// (never the rendered file), preferring the same tag when one is open.
+function suggestNextClaimableTask(projection, { excludeId = null, tag = '' } = {}) {
+  const open = (projection && projection.tasks || []).filter((t) => t && t.status === 'open' && t.id !== excludeId);
+  if (!open.length) return null;
+  const normalizedTag = String(tag || '').trim().toLowerCase();
+  if (normalizedTag) {
+    const sameTag = open.find((t) => String(t.tag || '').trim().toLowerCase() === normalizedTag);
+    if (sameTag) return sameTag;
+  }
+  return open[0];
+}
+
 function cmdClaim(args) {
   const pos = positional(args);
   const id = pos[0];
   if (!id) {
     failTask('atris task claim', 'missing_id', 'id required');
   }
+  guardExplicitActor('atris task claim', flag(args, '--as'));
   const owner = flag(args, '--as') || DEFAULT_OWNER;
   const taskDb = getTaskDb();
   const db = taskDb.open();
@@ -5287,11 +6271,21 @@ function cmdClaim(args) {
       });
       return;
     }
-    console.log(`claimed ${taskRef(compactTaskFromProjection(projection, taskId))} as ${owner}`);
+    const ref = taskRef(compactTaskFromProjection(projection, taskId));
+    console.log(`claimed ${ref} as ${owner}`);
+    console.log(`Next: make the change, then run: atris task ready ${ref} --verify "git diff --check" --result "<who can do what now and why>" --landing "<what someone can do now>"`);
+    console.log('Use a different verifier only if autoland can rerun it, such as `node --test <file>`.');
+    console.log('Then: atris autoland tick');
   } else {
     const recoveryCommand = result.reason === 'already_claimed' && result.claimed_by
       ? `atris task release ${id} --as ${result.claimed_by}`
       : null;
+    let nextClaimable = null;
+    if (result.reason === 'already_done') {
+      const doneRow = taskDb.getTask(db, taskId);
+      const { projection } = writeDefaultProjection(taskDb, db);
+      nextClaimable = suggestNextClaimableTask(projection, { excludeId: taskId, tag: doneRow && doneRow.tag });
+    }
     if (wantsJson(args)) {
       printJson({
         ok: false,
@@ -5299,12 +6293,16 @@ function cmdClaim(args) {
         reason: result.reason,
         claimed_by: result.claimed_by || null,
         recovery_command: recoveryCommand,
+        next_claimable: nextClaimable ? { id: nextClaimable.id, ref: taskRef(nextClaimable), tag: nextClaimable.tag || null, title: nextClaimable.title } : null,
         detail: `claim failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`,
       });
       process.exit(1);
     }
     console.error(`claim failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`);
     if (recoveryCommand) console.error(`Recovery: ${recoveryCommand}`);
+    if (nextClaimable) {
+      console.error(`next claimable: ${taskRef(nextClaimable)} ${String(nextClaimable.title || '').slice(0, 80)} (atris task claim ${taskRef(nextClaimable)} --as ${owner})`);
+    }
     process.exit(1);
   }
 }
@@ -5503,7 +6501,7 @@ function cmdNext(args) {
       const continueWorkCommand = handoff.next_action === 'continue_work'
         ? continueWorkCommandForTask(reviewTask, { owner })
         : null;
-      const nextAgentAction = handoff.next_action === 'human_accept_waiting'
+      const nextAgentAction = handoff.next_action === 'human_accept_waiting' && !scoped
         ? readEndgameAgentAction(taskDb.workspaceRoot(), owner, { tasks: projection.tasks || [] })
         : null;
       if (hasFlag(args, '--create-next')) {
@@ -5724,6 +6722,131 @@ function cmdNote(args) {
   console.log(`noted ${taskRef(compactTaskFromProjection(projection, taskId))} v${result.event.version}`);
 }
 
+function cmdRetitle(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  const title = pos.slice(1).join(' ').trim();
+  if (!id) failTask('atris task retitle', 'missing_id', 'task id required');
+  if (!title) failTask('atris task retitle', 'missing_title', 'new title required');
+  warnIfTaskTitleNeedsOperatorWhy(title);
+
+  const actor = flag(args, '--as') || DEFAULT_OWNER;
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, id, 'atris task retitle');
+  const current = taskDb.getTask(db, taskId);
+  const oldTitle = String(current.title || '');
+  const now = Math.max(Date.now(), Number(current.updated_at || 0) + 1);
+  const updated = db.prepare(`
+    UPDATE tasks
+       SET title = ?,
+           updated_at = ?
+     WHERE id = ?
+       AND updated_at = ?
+  `).run(title, now, taskId, current.updated_at);
+  if (updated.changes !== 1) {
+    failTask('atris task retitle', 'stale_task_state', 'retitle failed: stale task state', 1);
+  }
+  const history = taskDb.noteTask(db, {
+    id: taskId,
+    actor: String(actor),
+    content: `previous title: ${oldTitle}`,
+  });
+  if (!history.noted) {
+    failTask('atris task retitle', history.reason || 'history_failed', `retitle history failed: ${history.reason || 'unknown'}`, 1);
+  }
+
+  const { projection, outPath } = writeDefaultProjection(taskDb, db);
+  const task = compactTaskFromProjection(projection, taskId);
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'retitled',
+      task_id: taskId,
+      old_title: oldTitle,
+      title,
+      version: history.event.version,
+      projection_path: outPath,
+      task,
+    });
+    return;
+  }
+  console.log(`retitled ${taskRef(task)}: ${title}`);
+}
+
+// Collect EVERY value for a repeatable flag (flag() only returns the first),
+// so `--add a --add b` and `--add a,b` both work.
+function collectFlagValues(args, name) {
+  const values = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === name && i + 1 < args.length && !String(args[i + 1]).startsWith('--')) {
+      values.push(args[i + 1]);
+    }
+  }
+  return values
+    .flatMap((value) => String(value).split(','))
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+function cmdTag(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) failTask('atris task tag', 'missing_id', 'task id required');
+  const add = collectFlagValues(args, '--add');
+  const remove = collectFlagValues(args, '--remove');
+  if (!add.length && !remove.length) {
+    failTask('atris task tag', 'missing_tags', 'at least one --add <tag> or --remove <tag> required');
+  }
+  const actor = flag(args, '--as') || DEFAULT_OWNER;
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, id, 'atris task tag');
+  const result = taskDb.tagTask(db, { id: taskId, actor: String(actor), add, remove });
+  if (!result.tagged) {
+    if (result.reason === 'no_changes') {
+      const { projection, outPath } = writeDefaultProjection(taskDb, db);
+      const task = compactTaskFromProjection(projection, taskId);
+      if (wantsJson(args)) {
+        printJson({
+          ok: true,
+          action: 'unchanged',
+          task_id: taskId,
+          added: [],
+          removed: [],
+          tags: result.tags || [],
+          projection_path: outPath,
+          task,
+        });
+        return;
+      }
+      console.log(`no change ${taskRef(task)} tags [${(result.tags || []).join(', ')}]`);
+      return;
+    }
+    failTask('atris task tag', result.reason || 'tag_failed', `tag failed: ${result.reason || 'unknown'}`, 1);
+  }
+  const { projection, outPath } = writeDefaultProjection(taskDb, db);
+  const task = compactTaskFromProjection(projection, taskId);
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'tagged',
+      task_id: taskId,
+      added: result.added,
+      removed: result.removed,
+      tags: result.tags,
+      version: result.event.version,
+      projection_path: outPath,
+      task,
+    });
+    return;
+  }
+  const parts = [];
+  if (result.added.length) parts.push(`+${result.added.join(' +')}`);
+  if (result.removed.length) parts.push(`-${result.removed.join(' -')}`);
+  console.log(`tagged ${taskRef(task)} ${parts.join(' ')} -> [${result.tags.join(', ')}] v${result.event.version}`);
+}
+
 function cmdChat(args) {
   const pos = positional(args);
   const id = pos[0];
@@ -6014,7 +7137,7 @@ function cmdShow(args) {
   const owner = task.claimed_by ? ` / ${task.claimed_by}` : '';
   const tag = task.tag ? ` #${task.tag}` : '';
   const statusLabel = task.status === 'review'
-    ? 'READY FOR APPROVAL'
+    ? 'ready for approval'
     : task.status === 'done'
       ? 'DONE'
       : task.status.toUpperCase();
@@ -6774,9 +7897,38 @@ function cmdResult(args) {
   const pos = positional(args);
   const id = pos[0];
   if (!id) failTask('atris task result', 'missing_id', 'id required');
+  const sentence = pos.slice(1).join(' ').trim();
+  if (sentence) {
+    const resultSentence = requireResultSentence('atris task result', sentence);
+    const actor = String(flag(args, '--as') || DEFAULT_OWNER);
+    const taskDb = getTaskDb();
+    const db = taskDb.open();
+    const taskId = requireTaskId(taskDb, db, id, 'atris task result');
+    const saved = taskDb.setTaskResult(db, {
+      id: taskId,
+      actor,
+      result: resultSentence,
+    });
+    if (!saved.saved) failTask('atris task result', saved.reason || 'result_failed', `result failed: ${saved.reason || 'result_failed'}`, 1);
+    const { projection, outPath } = writeDefaultProjection(taskDb, db);
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: 'result',
+        task_id: taskId,
+        version: saved.event.version,
+        result: resultSentence,
+        projection_path: outPath,
+        task: compactTaskFromProjection(projection, taskId),
+      });
+      return;
+    }
+    console.log(`result saved ${taskRef(compactTaskFromProjection(projection, taskId))}: ${resultSentence}`);
+    return;
+  }
   const fields = {
     purpose: textFlag(args, ['--purpose', '--goal', '--objective']),
-    changed: textFlag(args, ['--changed', '--result', '--done']),
+    changed: textFlag(args, ['--changed', '--done']),
     checked: textFlag(args, ['--checked', '--check', '--verified']),
     passed: textFlag(args, ['--passed', '--pass']),
     failed: textFlag(args, ['--failed', '--fail']),
@@ -6886,7 +8038,7 @@ function taskPageActions(task, { reviewer = 'codex-review', hasExistingReviewFol
     note_command: `atris task note ${ref} "<context>" --as ${owner}`,
     plan_command: `atris task plan ${ref} --goal ${taskCommandQuote(goal)} --exit "<exit condition>" --proof-needed "<verification command>" --first-move "<first move>"`,
     do_command: `atris task do ${ref} --as ${owner} --first-move "<first move>"`,
-    ready_command: `atris task ready ${ref} --as ${owner} --proof "<specific proof command/result>" --happened "<what happened>" --checked "<how you know>" --tested "<what you ran or inspected>" --decision "<accept/rework guidance>"`,
+    ready_command: `atris task ready ${ref} --as ${owner} --proof "<specific proof command/result>" --result "<one day-one PM sentence>" --happened "<what happened>" --checked "<how you know>" --tested "<what you ran or inspected>" --decision "<accept/rework guidance>"`,
     review_command: `atris task review ${ref} --reward 0 --as ${actor} --proof "<specific proof command/result>" --verify "<safe verifier command>"`,
   };
   if (task && task.status === 'review') {
@@ -7322,9 +8474,14 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
     if (proofIssue) {
       throw taskStepError(proof ? 'weak_proof' : 'proof_required', `meaningful proof required: ${proofIssue}`, { status: 400, exitCode: 2, page: actionPage });
     }
+    const missionXpIssue = missionXpEndToEndProofIssue(task, proof, task.workspace_root || process.cwd());
+    if (missionXpIssue) {
+      throw taskStepError(MISSION_XP_END_TO_END_REASON, missionXpIssue, { status: 409, exitCode: 1, page: actionPage });
+    }
     const lesson = String(options.lesson || '');
     const nextTask = String(options.nextTask || '');
     const resultTrace = buildAutomaticResultTrace(taskDb, db, taskId, { actor, proof });
+    const missionResult = missionReceiptResultForProof(task, proof, task.workspace_root || process.cwd());
     const ready = taskDb.readyTask(db, {
       id: taskId,
       actor,
@@ -7332,6 +8489,8 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
       lesson,
       nextTask,
       resultTrace: resultTrace && resultTrace.trace,
+      result: missionResult ? missionResult.changed : undefined,
+      reason: missionResult ? missionResult.reason : undefined,
     });
     if (!ready.ready) taskStepFailure('atris task step', ready, actionPage);
     task = taskDetail(taskDb, db, taskId) || task;
@@ -7341,7 +8500,10 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
   } else if (current === 'review' && task.status === 'review') {
     const handoffState = reviewHandoffForTask(task, { suppressExistingFollowUp: true });
     if (handoffState && handoffState.next_action === PROOF_BOUNDARY_BLOCKED_ACTION) {
-      throw taskStepError(PROOF_BOUNDARY_BLOCKED_REASON, 'atris task step: Review proof cites an open/draft/unmerged PR boundary; revise the row before further stepping', { status: 409, exitCode: 1, page: actionPage });
+      const detail = handoffState.reason === MISSION_XP_END_TO_END_REASON
+        ? `atris task step: ${MISSION_XP_END_TO_END_DETAIL}`
+        : 'atris task step: Review proof cites an open/draft/unmerged PR boundary; revise the row before further stepping';
+      throw taskStepError(PROOF_BOUNDARY_BLOCKED_REASON, detail, { status: 409, exitCode: 1, page: actionPage });
     }
     if (handoffState && (handoffState.next_action === 'continue_work' || handoffState.next_action === 'human_accept_waiting')) {
       const reason = handoffState.next_action === 'continue_work'
@@ -7466,9 +8628,13 @@ function runCurrentTaskStep(taskDb, db, { owner = DEFAULT_OWNER, reviewer = 'cod
     throw error;
   }
   if (nextActionKey === PROOF_BOUNDARY_BLOCKED_ACTION) {
+    const boundaryReason = current.page?.review?.handoff?.reason || current.selected?.review?.handoff?.reason || '';
+    const detail = boundaryReason === MISSION_XP_END_TO_END_REASON
+      ? `atris task current-step: ${MISSION_XP_END_TO_END_DETAIL}`
+      : 'atris task current-step: selected Review row has stale/open/draft/unmerged PR proof; revise it instead of accepting or auto-stepping';
     const error = taskStepError(
       PROOF_BOUNDARY_BLOCKED_REASON,
-      'atris task current-step: selected Review row has stale/open/draft/unmerged PR proof; revise it instead of accepting or auto-stepping',
+      detail,
       {
         status: 409,
         exitCode: 1,
@@ -7675,7 +8841,7 @@ function cmdDone(args) {
   if (agentProofOnlyMode() && !failed) {
     failAgentProofOnly(
       'atris task done',
-      'Agent proof-only mode cannot mark tasks done. Use `atris task ready <id> --proof "..."` or `atris task review <id> --reward 0 --proof "..."`.',
+      'Agent proof-only mode cannot mark tasks done. Use `atris task ready <id> --proof "..." --result "<day-one PM sentence>"` or `atris task review <id> --reward 0 --proof "..."`.',
     );
   }
   const canComplete = beforeTask && (beforeTask.status === 'open' || beforeTask.status === 'claimed');
@@ -7757,13 +8923,14 @@ function cmdFinish(args) {
   if (agentProofOnlyMode() && !failed) {
     failAgentProofOnly(
       'atris task finish',
-      'Agent proof-only mode cannot finish tasks. Use `atris task ready <id> --proof "..."` or `atris task review <id> --reward 0 --proof "..."`.',
+      'Agent proof-only mode cannot finish tasks. Use `atris task ready <id> --proof "..." --result "<day-one PM sentence>"` or `atris task review <id> --reward 0 --proof "..."`.',
     );
   }
   const canComplete = currentTask && (currentTask.status === 'open' || currentTask.status === 'claimed');
   if (canComplete) {
     if (!failed || hasReview) requireMeaningfulTaskProof('atris task finish', proof);
     else if (proof) requireMeaningfulTaskProof('atris task finish', proof);
+    if (!failed && hasReview) requireExplicitLandingDayOnePm('atris task finish', landing, currentTask.title);
   }
   const done = taskDb.doneTask(db, {
     id: taskId,
@@ -7839,6 +9006,197 @@ function cmdFinish(args) {
   console.log(`finished ${taskRef(compactTaskFromProjection(projection, taskId))}`);
 }
 
+// Distinct from `done --failed`: a bulk sweep of duplicates/off-roadmap work
+// closes the task without ever claiming it did or didn't succeed. Writing
+// 'failed' here would corrupt the reward signal readers rely on (see
+// atris/reports/failed-tasks-analysis-2026-07-03.md, cluster 2, OBL-1622).
+function cmdArchive(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) {
+    failTask('atris task archive', 'missing_id', 'id required');
+  }
+  const reason = textFlag(args, ['--reason']);
+  if (!reason) {
+    failTask('atris task archive', 'missing_reason', 'atris task archive requires --reason "<why this is being swept, not failed>"');
+  }
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, id, 'atris task archive');
+  const actor = String(flag(args, '--as') || DEFAULT_OWNER);
+  // Explicit opt-in for sanctioned failed→archived cleanup (e.g. duplicate
+  // loop-tick orphans fail-closed before 'archived' existed). Without the
+  // flag, failed rows stay failed; done rows are never archivable.
+  const fromFailed = hasFlag(args, '--from-failed');
+  const result = taskDb.archiveTask(db, { id: taskId, actor, reason, fromFailed });
+  if (result.archived) {
+    const { projection, outPath } = writeDefaultProjection(taskDb, db);
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: 'archived',
+        task_id: taskId,
+        reason,
+        archived_from: result.row && result.row.metadata && result.row.metadata.archived_from || null,
+        projection_path: outPath,
+        task: compactTaskFromProjection(projection, taskId),
+      });
+      return;
+    }
+    const fromNote = result.row && result.row.metadata && result.row.metadata.archived_from
+      ? ` (was ${result.row.metadata.archived_from})`
+      : '';
+    console.log(`archived ${taskRef(compactTaskFromProjection(projection, taskId))}${fromNote}: ${reason}`);
+  } else {
+    const hint = result.reason === 'already_failed'
+      ? ' (use --from-failed to archive a fail-closed duplicate/off-roadmap row)'
+      : '';
+    const detail = `archive failed: ${taskId} ${result.reason}${hint}`;
+    if (wantsJson(args)) {
+      printJson({ ok: false, command: 'atris task archive', reason: result.reason, task_id: taskId, detail });
+      process.exit(1);
+    }
+    console.error(detail);
+    process.exit(1);
+  }
+}
+
+function taskCompletionTime(row) {
+  const doneAt = Number(row && row.done_at);
+  if (Number.isFinite(doneAt) && doneAt > 0) return doneAt;
+  const acceptedAt = Date.parse(String(row && row.metadata && row.metadata.accepted_at || ''));
+  if (Number.isFinite(acceptedAt)) return acceptedAt;
+  return Number(row && (row.updated_at || row.created_at) || 0);
+}
+
+function cmdClearDone(args) {
+  const beforeRaw = flag(args, '--before');
+  let beforeDays = null;
+  if (beforeRaw !== null) {
+    beforeDays = Number(beforeRaw);
+    if (beforeRaw === true || !Number.isFinite(beforeDays) || beforeDays < 0) {
+      failTask('atris task clear-done', 'invalid_before', '--before requires a non-negative number of days');
+    }
+  }
+
+  const dryRun = hasFlag(args, '--dry-run');
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const workspaceRoot = taskDb.workspaceRoot();
+  const cutoff = beforeDays === null ? null : Date.now() - (beforeDays * 24 * 60 * 60 * 1000);
+  const candidates = taskDb.listTasks(db, { workspaceRoot, status: 'done', limit: null })
+    .filter(row => cutoff === null || taskCompletionTime(row) < cutoff)
+    .sort((a, b) => taskCompletionTime(a) - taskCompletionTime(b) || String(a.id).localeCompare(String(b.id)));
+  const sample = candidates.slice(0, 5).map(row => ({
+    task_id: row.id,
+    title: row.title,
+    completed_at: new Date(taskCompletionTime(row)).toISOString(),
+  }));
+
+  if (dryRun) {
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: 'clear-done',
+        dry_run: true,
+        before_days: beforeDays,
+        count: candidates.length,
+        sample,
+      });
+      return;
+    }
+    console.log(`clear-done dry-run: ${candidates.length} completed task(s) would be archived.`);
+    for (const row of sample) console.log(`  - ${row.title}`);
+    if (candidates.length > sample.length) console.log(`  ...and ${candidates.length - sample.length} more`);
+    return;
+  }
+
+  const reason = 'cleared by clear-done sweep';
+  for (const row of candidates) {
+    const result = taskDb.archiveTask(db, {
+      id: row.id,
+      actor: String(flag(args, '--as') || DEFAULT_OWNER),
+      reason,
+      fromDone: true,
+    });
+    if (!result.archived) {
+      failTask('atris task clear-done', result.reason, `clear-done failed: ${row.id} ${result.reason}`, 1);
+    }
+  }
+  const { outPath } = writeDefaultProjection(taskDb, db);
+
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'clear-done',
+      dry_run: false,
+      before_days: beforeDays,
+      count: candidates.length,
+      reason,
+      sample,
+      projection_path: outPath,
+    });
+    return;
+  }
+  console.log(`cleared ${candidates.length} completed task(s).`);
+}
+
+// One-time migration for OBL-1622: the 2026-06-10 "first-principles backlog
+// reset" archived ~125 certified, proof-backed tasks by writing status
+// 'failed' (no distinct archived status existed yet). This relabels exactly
+// the rows that carry that reset's metadata marker, using the same
+// UPDATE+appendTaskEvent write path as every other status transition in
+// lib/task-db.js — never a raw projection-JSON edit.
+function cmdRelabelArchived(args) {
+  const apply = hasFlag(args, '--apply');
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const workspaceRoot = taskDb.workspaceRoot();
+  const actor = String(flag(args, '--as') || DEFAULT_OWNER);
+  const result = taskDb.relabelArchivedTasks(db, { workspaceRoot, apply, actor });
+  if (apply && result.count > 0) {
+    appendRelabelArchivedJournalReceipt(workspaceRoot, { actor, count: result.count, ids: result.ids });
+  }
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: apply ? 'relabeled' : 'preview',
+      dry_run: !apply,
+      workspace_root: workspaceRoot,
+      ...result,
+    });
+    return;
+  }
+  if (!apply) {
+    console.log(`relabel-archived (dry-run): ${result.count} failed task(s) match the June 10 backlog-reset marker.`);
+    for (const s of result.sample) console.log(`  - ${s.id} ${s.title}`);
+    if (result.count > result.sample.length) console.log(`  ...and ${result.count - result.sample.length} more`);
+    console.log('Run with --apply --as <you> to relabel these failed -> archived.');
+    return;
+  }
+  console.log(`relabeled ${result.count} task(s) failed -> archived (June 10 backlog reset, OBL-1622).`);
+}
+
+function appendRelabelArchivedJournalReceipt(workspaceRoot, { actor, count, ids }) {
+  if (!workspaceRoot || !fs.existsSync(path.join(workspaceRoot, 'atris'))) return null;
+  const now = new Date();
+  const logName = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}.md`;
+  const stamp = now.toTimeString().slice(0, 5);
+  const projectDir = path.join(workspaceRoot, 'atris', 'logs', logName.slice(0, 4));
+  fs.mkdirSync(projectDir, { recursive: true });
+  const logPath = path.join(projectDir, logName);
+  const idPreview = ids.slice(0, 10).join(', ') + (ids.length > 10 ? `, ...(+${ids.length - 10} more)` : '');
+  fs.appendFileSync(logPath, [
+    `## ${stamp} · Task relabel: failed -> archived (OBL-1622)`,
+    `- count: ${count}`,
+    `- reason: June 10 backlog-reset rows mislabeled failed; relabeled to archived`,
+    `- actor: ${actor}`,
+    `- ids: ${idPreview}`,
+    '',
+  ].join('\n'), 'utf8');
+  return logPath;
+}
+
 function cmdReady(args) {
   const pos = positional(args);
   const id = pos[0];
@@ -7851,18 +9209,27 @@ function cmdReady(args) {
   // turning a claim into executed evidence. --verify can carry an optional --proof note.
   const proofFlag = flag(args, '--proof');
   const verifyFlag = flag(args, '--verify');
+  const resultSentence = requireResultSentence('atris task ready', textFlag(args, ['--result']), { ready: true });
+  const usedVerify = typeof verifyFlag === 'string' ? verifyFlag.trim() : '';
   let proof = typeof proofFlag === 'string' ? proofFlag : '';
-  if (typeof verifyFlag === 'string' && verifyFlag.trim()) {
-    const verified = buildVerifiedProof(verifyFlag, proof, undefined, { cwd: process.cwd() });
-    if (!verified.ok) {
-      const detail = verified.exit != null ? ` (exit ${verified.exit})` : (verified.signal ? ` (signal ${verified.signal})` : '');
+  const verifyAutoCertifyAllowed = !usedVerify || isAutoCertifyVerifyCommandAllowed(verifyFlag);
+  if (usedVerify) {
+    // Run the verifier once and write a receipt (pass or fail) so the review
+    // gate in lib/receipt-evidence.js can validate the exact path named in
+    // the proof, not just trust the prose.
+    const { writeTaskReceipt } = require('../lib/task-receipt');
+    const receipt = writeTaskReceipt({ taskId: id, command: verifyFlag, root: process.cwd() });
+    if (!receipt.passed) {
+      const detail = receipt.exit != null ? ` (exit ${receipt.exit})` : (receipt.signal ? ` (signal ${receipt.signal})` : '');
       console.error(`atris task ready: verifier failed${detail}: ${verifyFlag}`);
-      if (verified.output) console.error(verified.output);
-      else if (verified.error) console.error(verified.error);
+      if (receipt.output) console.error(receipt.output);
+      else if (receipt.error) console.error(receipt.error);
+      if (receipt.receiptPath) console.error(`receipt: ${receipt.receiptPath}`);
       process.exit(1);
     }
-    proof = verified.proof;
-    if (!wantsJson(args)) console.log(`✓ verified: \`${verifyFlag}\` exited 0`);
+    const base = proof.trim();
+    proof = `[verified] \`${verifyFlag}\` passed (exit 0)${base ? ` — ${base}` : ''}${receipt.output ? `\n${receipt.output}` : ''}\nReceipt: ${receipt.receiptPath}`;
+    if (!wantsJson(args)) console.log(`✓ verified: \`${verifyFlag}\` exited 0 (receipt ${receipt.receiptPath})`);
   }
   if (!proof) {
     console.error('atris task ready: --proof or --verify required');
@@ -7872,9 +9239,10 @@ function cmdReady(args) {
   const lesson = flag(args, '--lesson') || '';
   const nextTaskInput = normalizeReviewNextTaskInput(typeof flag(args, '--next') === 'string' ? flag(args, '--next') : '');
   const landing = landingFlags(args);
+  guardExplicitActor('atris task ready', flag(args, '--as'));
   const actor = String(flag(args, '--as') || DEFAULT_OWNER);
   const resultFields = {
-    changed: textFlag(args, ['--changed', '--result', '--done']),
+    changed: textFlag(args, ['--changed', '--done']),
     checked: textFlag(args, ['--checked', '--check', '--verified']),
     passed: textFlag(args, ['--passed', '--pass']),
     failed: textFlag(args, ['--failed', '--fail']),
@@ -7888,10 +9256,17 @@ function cmdReady(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const taskId = requireTaskId(taskDb, db, id, 'atris task ready');
+  const beforeTask = taskDetail(taskDb, db, taskId);
+  requireExplicitLandingDayOnePm('atris task ready', landing, beforeTask && beforeTask.title);
+  const missionXpIssue = missionXpEndToEndProofIssue(beforeTask, proof, taskDb.workspaceRoot());
+  if (missionXpIssue) {
+    failTask('atris task ready', MISSION_XP_END_TO_END_REASON, missionXpIssue);
+  }
   const resultTrace = buildAutomaticResultTrace(taskDb, db, taskId, {
     actor,
     proof: String(proof),
     ...resultFields,
+    changed: resultFields.changed || resultSentence,
   });
   const result = taskDb.readyTask(db, {
     id: taskId,
@@ -7901,11 +9276,17 @@ function cmdReady(args) {
     nextTask: nextTaskInput.nextTask,
     resultTrace: resultTrace && resultTrace.trace,
     landing,
+    result: resultSentence,
   });
   if (!result.ready) {
     console.error(`ready failed: ${result.reason}`);
     process.exit(1);
   }
+  // Store the exact verifier command on the task itself (not just baked into
+  // proof prose) so sweep --auto-accept and certify-verified can re-run it
+  // live against the current checkout later, instead of re-deriving it from
+  // text or trusting a receipt file that may no longer exist.
+  if (usedVerify) stampReadyVerifyMetadata(taskDb, db, taskId, usedVerify);
   const landingAdvisory = warnIfLandingNeedsDayOnePm(landing, result.row && result.row.title);
   const { projection, outPath } = writeDefaultProjection(taskDb, db);
   const agentCertified = result.event.payload.agent_certified === true;
@@ -7918,13 +9299,21 @@ function cmdReady(args) {
     nextTask: nextTaskInput.nextTask,
   });
   const reviewChat = taskReviewChatHandoff(verifierTask, { reviewer: 'codex-review' });
+  const autolandOn = require('../lib/autoland').liveAcceptAuthorization(taskDb.workspaceRoot()).ok;
+  const needsExternalVerifier = Boolean(usedVerify && !verifyAutoCertifyAllowed);
   const handoff = {
     native_goal_status: agentCertified ? 'agent_certified' : 'needs_second_agent_review',
     career_xp_status: 'pending_human_accept',
     next_action: agentCertified ? certifiedReviewNextAction(nextTaskInput.nextTask) : 'agent_review_again',
-    rule: agentCertified
-      ? 'Double-check complete; ready to keep moving. XP is awarded only after the human approves the task.'
-      : 'Proof is ready; one more agent check before human approval. XP waits for the human.',
+    rule: autolandOn
+      ? (agentCertified
+        ? 'double-check complete; autoland will accept this on the next tick.'
+        : needsExternalVerifier
+        ? 'proof is ready; this verifier needs a second agent review because autoland cannot rerun it.'
+        : 'proof is ready; autoland runs the second check and lands it on the next tick.')
+      : (agentCertified
+        ? 'double-check complete; ready to keep moving. XP is awarded only after the human approves the task.'
+        : 'proof is ready; one more agent check before human approval. XP waits for the human.'),
   };
   if (reviewChat) {
     handoff.review_chat_command = reviewChat.command;
@@ -7958,11 +9347,59 @@ function cmdReady(args) {
   console.log(`ready for approval ${taskRef(compactTaskFromProjection(projection, taskId))} v${result.event.version}`);
   if (resultTrace) console.log('Result trace recorded.');
   console.log(handoff.rule);
+  if (!verifyAutoCertifyAllowed) {
+    const ref = taskRef(compactTaskFromProjection(projection, taskId) || result.row || taskId);
+    console.log(`note: this verify command is outside the auto-certify allowlist, so autoland cannot run the second check itself. use a test command like node --test <file> or git diff --check, or have a second agent run: atris task review-chat ${ref} --as <reviewer>`);
+  }
   for (const hint of policyHints) {
     console.log(`policy (${hint.id}): ${hint.hint}`);
   }
 }
 
+// Standalone receipt writer: runs a verifier for a task and writes atris/runs/
+// evidence without moving the task to ready. Useful when you want a receipt
+// on record before or independent of a ready call, or to record a failed
+// verifier run for the audit trail. `atris task ready --verify` calls the
+// same writer inline and folds the resulting path into the proof.
+function cmdTaskReceipt(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) {
+    console.error('atris task receipt: id required');
+    process.exit(2);
+  }
+  const verifyFlag = flag(args, '--verify');
+  if (typeof verifyFlag !== 'string' || !verifyFlag.trim()) {
+    console.error('atris task receipt: --verify "<cmd>" required');
+    process.exit(2);
+  }
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, id, 'atris task receipt');
+  const { writeTaskReceipt } = require('../lib/task-receipt');
+  const receipt = writeTaskReceipt({ taskId, command: verifyFlag, root: process.cwd() });
+  if (wantsJson(args)) {
+    printJson({
+      ok: receipt.passed,
+      task_id: taskId,
+      command: verifyFlag,
+      receipt_path: receipt.receiptPath,
+      exit: receipt.exit,
+      passed: receipt.passed,
+    });
+    if (!receipt.passed) process.exit(1);
+    return;
+  }
+  if (receipt.passed) {
+    console.log(`receipt written: ${receipt.receiptPath} (exit 0)`);
+    console.log(`use: atris task ready ${taskId} --proof "Receipt: ${receipt.receiptPath}" --result "<what someone can do now and why it matters>"`);
+  } else {
+    console.error(`verifier failed (exit ${receipt.exit}); receipt written: ${receipt.receiptPath}`);
+    if (receipt.output) console.error(receipt.output);
+    process.exit(1);
+  }
+}
+
 async function cmdAccept(args) {
   const pos = positional(args);
   const id = pos[0];
@@ -7995,6 +9432,10 @@ async function cmdAccept(args) {
     process.exit(2);
   }
   requireMeaningfulTaskProof('atris task accept', proof);
+  const missionXpIssue = missionXpEndToEndProofIssue(beforeTask, proof, taskDb.workspaceRoot());
+  if (missionXpIssue) {
+    failTask('atris task accept', MISSION_XP_END_TO_END_REASON, missionXpIssue);
+  }
   const readyReview = beforeTask?.review || {};
   const clearLesson = hasEmptyFlagValue(args, '--lesson');
   const clearNextTask = hasEmptyFlagValue(args, '--next');
@@ -8041,6 +9482,7 @@ async function cmdAccept(args) {
   const xpProjection = refreshCareerXpAfterReview(reviewed);
   const { projection, outPath } = writeDefaultProjection(taskDb, db);
   const workspaceRoot = projection.workspace_root || process.cwd();
+  refreshExistingTodoMarkdown(taskDb, db, workspaceRoot);
   const brainScorecards = refreshBrainScorecardsAfterAccept(workspaceRoot);
   const nextMissionRoute = nextMissionRouteAfterAccept(workspaceRoot);
   // Inform the gate, never block it: show what the receipts named in the proof
@@ -8093,7 +9535,12 @@ function stampAutoAcceptMetadata(taskDb, db, taskId, actor, policy) {
   `).run(JSON.stringify(metadata), Date.now(), taskId);
 }
 
-function acceptReviewTask(taskDb, db, taskId, { actor, proof, reward, lesson = '', nextTask = '' }) {
+function acceptReviewTask(taskDb, db, taskId, { actor, proof, reward, lesson = '', nextTask = '', autoAccepted = false }) {
+  const task = taskDetail(taskDb, db, taskId);
+  const missionXpIssue = missionXpEndToEndProofIssue(task, proof, taskDb.workspaceRoot());
+  if (missionXpIssue) {
+    return { ok: false, reason: MISSION_XP_END_TO_END_REASON, detail: missionXpIssue };
+  }
   const done = taskDb.doneTask(db, {
     id: taskId,
     status: 'done',
@@ -8101,6 +9548,7 @@ function acceptReviewTask(taskDb, db, taskId, { actor, proof, reward, lesson = '
     allowReview: true,
     action: 'accepted',
     proof,
+    autoAccepted,
   });
   if (!done.updated) {
     return { ok: false, reason: 'not_open_claimed_or_review' };
@@ -8113,7 +9561,10 @@ function acceptReviewTask(taskDb, db, taskId, { actor, proof, reward, lesson = '
     nextTask,
     proof,
     careerXpEligible: true,
+    autoAccepted,
   });
+  const acceptedRow = taskDb.getTask(db, taskId);
+  refreshExistingTodoMarkdown(taskDb, db, acceptedRow && acceptedRow.workspace_root);
   return { ok: true, reviewed };
 }
 
@@ -8145,6 +9596,7 @@ function stampCertifyVerifyMetadata(taskDb, db, taskId, actor, verify) {
   metadata.verify = metadata.verify || verify;
   metadata.certified_verified_at = new Date().toISOString();
   metadata.certified_verified_by = actor;
+  metadata.machine_verified = true;
   db.prepare(`
     UPDATE tasks
        SET metadata = ?,
@@ -8153,9 +9605,69 @@ function stampCertifyVerifyMetadata(taskDb, db, taskId, actor, verify) {
   `).run(JSON.stringify(metadata), Date.now(), taskId);
 }
 
-function cmdCertifyVerified(args) {
+// `atris task ready --verify "<cmd>"` already runs the command live and
+// gates on exit 0, but that alone leaves no machine re-runnable trace once
+// the proof text scrolls out of easy reach: storing the exact command on
+// metadata.verify is what lets sweep --auto-accept (and certify-verified)
+// re-run it later against the current checkout instead of re-parsing prose.
+function stampReadyVerifyMetadata(taskDb, db, taskId, verify) {
+  const row = taskDb.getTask(db, taskId);
+  if (!row) return;
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  metadata.verify = verify;
+  db.prepare(`
+    UPDATE tasks
+       SET metadata = ?,
+           updated_at = ?
+     WHERE id = ?
+  `).run(JSON.stringify(metadata), Date.now(), taskId);
+}
+
+function landingVerifyFailureNote(verify, result) {
+  const exit = result && result.status != null ? result.status : 'unknown';
+  return `Autoland re-ran allowlisted verify at landing and it failed: ${verify} (exit ${exit}).`;
+}
+
+function reverifyBeforeLanding(taskDb, db, task, { actor = 'autoland-verifier', verifyCache = null } = {}) {
+  const verify = certifyVerifyCandidate(task);
+  if (!verify) {
+    // No runnable check on record. Landing anyway converts "never verified"
+    // into "accepted with XP" — the exact signal poisoning this gate exists
+    // to prevent — so bounce the task back for a recorded verify instead.
+    const note = 'Autoland refused to land without a runnable verify command: record one with `atris task ready --verify "<cmd>" --result "<sentence>"`.';
+    const revised = taskDb.reviseTask(db, { id: task.id, actor, note });
+    return {
+      ok: false,
+      verify: null,
+      result: { reason: 'strict_verify_missing', status: null },
+      note,
+      revised: revised.revised === true,
+      revise_reason: revised.reason || null,
+    };
+  }
+  const result = runVerifyCommandCached(verify, task.workspace_root || process.cwd(), verifyCache);
+  if (result.ok) return { ok: true, verify, result };
+  const note = landingVerifyFailureNote(verify, result);
+  const revised = taskDb.reviseTask(db, {
+    id: task.id,
+    actor,
+    note,
+  });
+  return {
+    ok: false,
+    verify,
+    result,
+    note,
+    revised: revised.revised === true,
+    revise_reason: revised.reason || null,
+  };
+}
+
+function cmdCertifyVerified(args, options = {}) {
   const dryRun = hasFlag(args, '--dry-run');
   const asJson = wantsJson(args);
+  const silent = options.silent === true;
+  const verifyCache = options.verifyCache || null;
   const actor = String(flag(args, '--as') || 'autoland-verifier');
   const limitRaw = flag(args, '--limit');
   const max = limitRaw && limitRaw !== true ? Math.max(1, Number(limitRaw) || 6) : 6;
@@ -8192,20 +9704,37 @@ function cmdCertifyVerified(args) {
       results.push({ ref, action: 'skipped', reason: `denied_tag_${tag}` });
       continue;
     }
+    const proofBoundary = proofBoundaryBlockedEvaluation(task);
+    if (proofBoundary) {
+      results.push({ ref, action: 'skipped', reason: proofBoundary.reason });
+      continue;
+    }
     // Skip only rows the accept lane can already land, or rows blocked by
     // something an executed second-actor check cannot cure. A row with two
     // passes from ONE actor is exactly what this command exists to cure —
     // "certified" alone is not landable.
+    // strictVerify stays off in this eligibility probe: certify-verified runs
+    // the check itself right below, and strict mode here would execute it a
+    // second time per row before the real run.
     const evaluation = evaluateAutoAccept(task, { strictVerify: false });
     if (evaluation.eligible) {
       results.push({ ref, action: 'skipped', reason: 'already_landable' });
       continue;
     }
-    const curable = ['not_agent_certified', 'needs_second_reviewer_or_third_pass', 'insufficient_review_passes'];
+    // proof_not_executed is curable by definition: this command re-runs the
+    // named check and replaces the free-text claim with executed evidence.
+    const curable = ['not_agent_certified', 'needs_independent_reviewer', 'needs_second_reviewer_or_third_pass', 'insufficient_review_passes', 'proof_not_executed'];
     if (!curable.includes(evaluation.reason)) {
       results.push({ ref, action: 'skipped', reason: evaluation.reason });
       continue;
     }
+    // judge != worker: the re-run only counts as an independent check when
+    // its actor is not the builder of the row it is judging.
+    const builder = reviewIntegrity.taskBuilder(task);
+    if (builder && reviewIntegrity.normalizeActor(actor) === builder) {
+      results.push({ ref, action: 'skipped', reason: 'verifier_is_builder' });
+      continue;
+    }
     const verify = certifyVerifyCandidate(task);
     if (!verify) {
       results.push({ ref, action: 'skipped', reason: 'no_runnable_check_in_proof' });
@@ -8215,7 +9744,7 @@ function cmdCertifyVerified(args) {
       results.push({ ref, action: 'would_certify', verify });
       continue;
     }
-    const run = runVerifyCommand(verify, task.workspace_root || process.cwd());
+    const run = runVerifyCommandCached(verify, task.workspace_root || process.cwd(), verifyCache);
     if (!run.ok) {
       results.push({ ref, action: 'verify_failed', reason: run.reason, verify });
       continue;
@@ -8249,6 +9778,9 @@ function cmdCertifyVerified(args) {
     results,
     projection_path: outPath,
   };
+  if (silent) {
+    return payload;
+  }
   if (asJson) {
     console.log(JSON.stringify(payload, null, 2));
   } else if (results.length === 0) {
@@ -8262,9 +9794,27 @@ function cmdCertifyVerified(args) {
   return payload;
 }
 
+// The landing: everything certified, one summary, one human gesture.
+// Review-by-N-pastes was the operator pain; this is the batch gate that
+// keeps human accept as the one gate without making it N gates.
+function cmdLanding(args) {
+  if (hasFlag(args, '--accept')) {
+    const passthrough = args.filter(arg => arg !== '--accept');
+    if (!passthrough.includes('--confirm-human-accept')) passthrough.push('--confirm-human-accept');
+    return cmdAutoAcceptCertified(passthrough);
+  }
+  cmdReviews(args);
+  console.log('');
+  console.log('land everything certified above in one gesture:');
+  console.log('  atris task landing --accept --as <you>');
+  console.log('(items needing one more check stay in review; only certified work lands)');
+}
+
 function cmdAutoAcceptCertified(args) {
   const dryRun = hasFlag(args, '--dry-run');
-  const strictVerify = hasFlag(args, '--strict-verify');
+  const acceptAll = hasFlag(args, '--all');
+  const certifyFirst = hasFlag(args, '--certify-first');
+  const strictVerify = !hasFlag(args, '--no-strict-verify') && !acceptAll;
   const actorFlag = flag(args, '--as');
   const hasHumanActor = validHumanActorFlag(actorFlag);
   const confirmedHumanAccept = hasFlag(args, '--confirm-human-accept');
@@ -8277,7 +9827,17 @@ function cmdAutoAcceptCertified(args) {
     : { ok: false };
   const actor = String(actorFlag || (policyAuth.ok ? policyAuth.actor : 'auto-accept-certified'));
   const limitRaw = flag(args, '--limit');
-  const max = limitRaw && limitRaw !== true ? Math.max(1, Number(limitRaw) || 12) : 12;
+  const hasExplicitLimit = Boolean(limitRaw) && limitRaw !== true;
+  // --all means sweep the full certified backlog, not just the first page of
+  // it. Before this fix `max` was hard-capped at 12 even under --all, so a
+  // real backlog (78 certified rows observed live) only ever drained 12/run —
+  // an invisible undercount the autoland heartbeat repeated every hour.
+  // AUTO_ACCEPT_ALL_SWEEP_CAP is a safety ceiling, not a target: a well-formed
+  // --all run should always scan fewer rows than this.
+  const AUTO_ACCEPT_ALL_SWEEP_CAP = 500;
+  const max = hasExplicitLimit
+    ? Math.max(1, Number(limitRaw) || 12)
+    : (acceptAll ? AUTO_ACCEPT_ALL_SWEEP_CAP : 12);
   const parsedReward = parseAcceptReward(flag(args, '--reward'));
   if (!parsedReward.ok) {
     console.error('atris task auto-accept-certified: reward must be a positive number');
@@ -8297,27 +9857,62 @@ function cmdAutoAcceptCertified(args) {
       'live auto-accept requires --as <human> so XP has an explicit human acceptance actor',
     );
   }
-  if (agentProofOnlyMode() && !dryRun) {
+  // The standing autoland policy clears this gate too, same as the two
+  // per-run human gates above: the owner flipped the policy, accepts run as
+  // that owner, and the cron tick would land the same rows an hour later
+  // anyway. Without this exception `atris autoland tick` was blind whenever
+  // invoked from an agent session (CLAUDECODE etc. in env): the spawned
+  // sweep failTask'd with no summary and the tick receipt showed nulls.
+  // A per-run --confirm-human-accept claim from an agent is still refused —
+  // policyAuth is only consulted when no per-run confirmation is passed.
+  if (agentProofOnlyMode() && !dryRun && !policyAuth.ok) {
     failAgentProofOnly(
       'atris task auto-accept-certified',
-      'Agent proof-only mode can preview certified rows with --dry-run, but cannot live-accept them.',
+      'Agent proof-only mode can preview certified rows with --dry-run, but cannot live-accept them without the standing autoland policy.',
     );
   }
 
+  // A heartbeat certifies and lands in one process so its live verifier result
+  // remains available to the landing gate. The cache is process-local and is
+  // never persisted: a later heartbeat must prove the checkout again.
+  const verifyCache = new Map();
+  const certification = certifyFirst && !dryRun
+    ? cmdCertifyVerified([], { verifyCache, silent: true })
+    : null;
+
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const { projection, outPath } = writeDefaultProjection(taskDb, db);
   const queue = taskReviewQueue(projection, ['--limit', String(max)]);
+  const pendingReview = (projection.tasks || [])
+    .filter((t) => t && t.status === 'review' && t.review && t.review.approval_status === 'pending');
+  // Honest denominator for the summary line below: how many rows the
+  // projection actually certified, independent of any scan cap. If `scanned`
+  // ever comes in under `certified`, the undercount is visible instead of
+  // silent (the exact failure mode this fix closes).
+  const certifiedTotal = pendingReview.filter((t) => isAgentCertified(t)).length;
+  // The review queue only surfaces certified rows. Under --all the bar is
+  // the protected lanes, not certification, so scan every pending review.
+  const pool = acceptAll
+    ? pendingReview
+      .sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0))
+      .slice(0, max)
+    : queue.items.filter(item => item.queue_role !== 'blocked');
   const results = [];
 
-  for (const item of queue.items) {
+  for (const item of pool) {
     const fullProjection = enrichTaskProjection(taskDb.taskProjection(db, { taskId: item.id }));
     const task = fullProjection.tasks[0] || null;
     if (!task) {
       results.push({ ref: item.display_id || item.id, eligible: false, reason: 'task_not_found', action: 'skipped' });
       continue;
     }
-    const evaluation = evaluateAutoAccept(task, { strictVerify });
+    const proofBoundary = proofBoundaryBlockedEvaluation(task);
+    if (proofBoundary) {
+      results.push({ ...proofBoundary, action: 'skipped' });
+      continue;
+    }
+    const evaluation = evaluateAutoAccept(task, { strictVerify, acceptAll, verifyCache });
     if (!evaluation.eligible) {
       results.push({ ...evaluation, action: 'skipped' });
       continue;
@@ -8326,12 +9921,27 @@ function cmdAutoAcceptCertified(args) {
       results.push({ ...evaluation, action: 'would_accept', reward: parsedReward.value });
       continue;
     }
+    const landingVerify = reverifyBeforeLanding(taskDb, db, task, { verifyCache });
+    if (!landingVerify.ok) {
+      results.push({
+        ...evaluation,
+        eligible: false,
+        action: landingVerify.revised ? 'revised' : 'revise_failed',
+        reason: landingVerify.result.reason || landingVerify.revise_reason || 'verify_failed',
+        verify: landingVerify.verify,
+        exit_code: landingVerify.result.status,
+        revision_note: landingVerify.note,
+        task_id: task.id,
+      });
+      continue;
+    }
     const accepted = acceptReviewTask(taskDb, db, task.id, {
       actor,
       proof: evaluation.proof,
       reward: parsedReward.value,
       lesson: String(task.review?.lesson || task.metadata?.latest_agent_lesson || ''),
       nextTask: String(task.review?.next_task || task.metadata?.latest_agent_next_task || ''),
+      autoAccepted: true,
     });
     if (!accepted.ok) {
       results.push({ ...evaluation, action: 'accept_failed', reason: accepted.reason });
@@ -8349,32 +9959,282 @@ function cmdAutoAcceptCertified(args) {
 
   const { projection: finalProjection, outPath: finalPath } = writeDefaultProjection(taskDb, db);
   const summary = {
-    scanned: queue.items.length,
+    certified: certifiedTotal,
+    scanned: pool.length,
     accepted: results.filter(row => row.action === 'accepted').length,
     would_accept: results.filter(row => row.action === 'would_accept').length,
+    revised: results.filter(row => row.action === 'revised').length,
     skipped: results.filter(row => row.action === 'skipped').length,
-    failed: results.filter(row => row.action === 'accept_failed').length,
+    failed: results.filter(row => row.action === 'accept_failed' || row.action === 'revise_failed').length,
+    // Visible undercount flag: true only if the pool was cut short by `max`
+    // while certified rows still existed beyond it. --all uses a high safety
+    // cap (AUTO_ACCEPT_ALL_SWEEP_CAP), so this should stay false in practice;
+    // if it ever flips true, the cap itself needs raising, not silence.
+    undercounted: certifiedTotal > pool.length,
   };
   if (wantsJson(args)) {
     printJson({
       ok: true,
       action: dryRun ? 'auto_accept_certified_dry_run' : 'auto_accept_certified',
       strict_verify: strictVerify,
+      accept_all: acceptAll,
       summary,
       ...summary,
       results,
+      certification,
       projection_path: finalPath,
       queue,
     });
-    return;
+    return { ...summary, results, certification, projection_path: finalPath, queue };
   }
   console.log(`AUTO-ACCEPT CERTIFIED (${dryRun ? 'dry-run' : 'execute'})`);
-  console.log(`${summary.accepted || summary.would_accept} accepted / ${summary.skipped} skipped / ${summary.failed} failed / ${summary.scanned} scanned`);
+  console.log(`${summary.certified} certified, ${summary.scanned} scanned, ${summary.accepted || summary.would_accept} accepted, ${summary.skipped} skipped${summary.revised ? `, ${summary.revised} revised` : ''}${summary.failed ? `, ${summary.failed} failed` : ''}${summary.undercounted ? ' (UNDERCOUNTED — raise --limit or the sweep cap)' : ''}`);
   for (const row of results) {
     const nextAction = row.next_action ? ` next_action=${row.next_action}` : '';
     const reviewChat = row.review_chat_command ? ` review_chat=${row.review_chat_command}` : '';
     console.log(`${row.action.toUpperCase()} ${row.ref}: ${row.reason}${row.reward ? ` reward=${row.reward}` : ''}${nextAction}${reviewChat}`);
   }
+  return { ...summary, results, certification, projection_path: finalPath, queue };
+}
+
+const SWEEP_AUTO_ACCEPT_PROTECTED = new Set([
+  'money', 'deploy', 'release', 'publish', 'security', 'customer', 'outward',
+]);
+
+function autoAcceptSweepLabelValues(task) {
+  const metadata = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  const tags = Array.isArray(metadata.tags) ? metadata.tags : [];
+  return [
+    task && task.tag,
+    task && task.lane,
+    metadata.tag,
+    metadata.lane,
+    metadata.mission_lane,
+    metadata.stage,
+    ...tags,
+  ].filter(value => value !== undefined && value !== null && String(value).trim());
+}
+
+function autoAcceptSweepNormalizedTokens(value) {
+  const normalized = String(value || '').trim().toLowerCase().replace(/_/g, '-');
+  if (!normalized) return [];
+  return [normalized, ...normalized.split(/[^a-z0-9-]+/).filter(Boolean)];
+}
+
+function autoAcceptSweepDeniedReason(task) {
+  for (const value of autoAcceptSweepLabelValues(task)) {
+    const tokens = autoAcceptSweepNormalizedTokens(value);
+    for (const token of tokens) {
+      if (token === 'needs-human' || token === 'needshuman') {
+        return 'needs_human';
+      }
+      const protectedLane = [...SWEEP_AUTO_ACCEPT_PROTECTED].find((denied) =>
+        token === denied || token.replace(/s$/, '') === denied
+      );
+      if (protectedLane) return 'protected_lane';
+    }
+  }
+  return null;
+}
+
+function autoAcceptSweepLatestProof(task) {
+  const metadata = task && task.metadata || {};
+  const review = task && task.review || {};
+  return String(review.proof || metadata.latest_agent_proof || '').trim();
+}
+
+function autoAcceptSweepVerifierEvidence(proof, root) {
+  const evidence = extractReceiptEvidence(proof, root);
+  if (!evidence || !evidence.receipts || !evidence.receipts.length) {
+    return { ok: false, reason: 'no_passing_verifier', evidence: evidence || null };
+  }
+  if (evidence.missing && evidence.missing.length) {
+    return { ok: false, reason: 'receipt_missing', evidence };
+  }
+  const passing = evidence.receipts.filter((receipt) => receipt.verifier_passed === true);
+  if (!passing.length) {
+    return { ok: false, reason: 'no_passing_verifier', evidence };
+  }
+  const notPassed = evidence.receipts.find((receipt) => receipt.verifier_passed !== true);
+  if (notPassed) {
+    return { ok: false, reason: 'receipt_verifier_not_passed', evidence };
+  }
+  return {
+    ok: true,
+    evidence,
+    passing,
+    proved_by: passing.map((receipt) => `${receipt.path} verifier_passed=true`),
+  };
+}
+
+function autoAcceptSweepHappened(task) {
+  const review = task && task.review || {};
+  return clipStatusText(
+    review.landing?.happened
+      || review.result?.changed
+      || task?.title
+      || 'accepted verified task',
+    180,
+  );
+}
+
+function evaluateSweepAutoAccept(task, root) {
+  const ref = taskRef(task);
+  if (!task) return { eligible: false, ref, reason: 'task_not_found' };
+  if (task.status !== 'review') return { eligible: false, ref, reason: 'not_in_review' };
+  const metadata = task.metadata || {};
+  const review = task.review || {};
+  const approval = String(review.approval_status || metadata.approval_status || 'pending').toLowerCase();
+  if (approval !== 'pending') return { eligible: false, ref, reason: `approval_${approval}` };
+  if (metadata.auto_accepted_at) return { eligible: false, ref, reason: 'already_auto_accepted' };
+  const denied = autoAcceptSweepDeniedReason(task);
+  if (denied) return { eligible: false, ref, reason: denied };
+  const proof = autoAcceptSweepLatestProof(task);
+  if (!proof) return { eligible: false, ref, reason: 'no_proof' };
+
+  // 1. An explicit, stored verifier (`atris task ready --verify`, or a prior
+  // certify-verified stamp) is the strongest signal: re-run it live, right
+  // now, against the current checkout, and let it decide outright. This is
+  // what unblocks CLI-762/CLI-861-shaped proofs: a real green test cited (or
+  // executed) in the proof, but the older receipt-path check below could not
+  // find file evidence for it once `ready --verify` stopped writing a
+  // receipt file and started embedding the executed result into proof text.
+  const storedVerify = typeof metadata.verify === 'string' ? metadata.verify.trim() : '';
+  if (storedVerify) {
+    const result = runVerifyCommand(storedVerify, root);
+    if (!result.ok) return { eligible: false, ref, reason: result.reason, verify: storedVerify };
+    return {
+      eligible: true,
+      ref,
+      reason: 'verified_command',
+      policy: 'sweep_auto_accept_verified_command',
+      proof,
+      verify: storedVerify,
+      proved_by: [`${storedVerify} exited 0`],
+      happened: autoAcceptSweepHappened(task),
+    };
+  }
+
+  // 2. Legacy path: a receipt file explicitly named in proof text.
+  const verifier = autoAcceptSweepVerifierEvidence(proof, root);
+  if (verifier.ok) {
+    return {
+      eligible: true,
+      ref,
+      reason: 'verified_receipt',
+      policy: 'sweep_auto_accept_verified',
+      proof,
+      evidence: verifier.evidence,
+      proved_by: verifier.proved_by,
+      happened: autoAcceptSweepHappened(task),
+    };
+  }
+
+  // 3. No stored verifier and no receipt was even cited: try deriving a
+  // safe, runnable command straight from the proof text itself (same
+  // extractor certify-verified uses) and re-run it live. Only reached when
+  // there is nothing else to go on, so a proof that legitimately cites a
+  // real receipt keeps taking the receipt path above rather than racing an
+  // unrelated command mentioned in the same sentence.
+  if (verifier.reason === 'no_passing_verifier') {
+    const derived = certifyVerifyCandidate(task);
+    if (derived) {
+      const result = runVerifyCommand(derived, root);
+      if (result.ok) {
+        return {
+          eligible: true,
+          ref,
+          reason: 'verified_derived_command',
+          policy: 'sweep_auto_accept_verified_derived',
+          proof,
+          verify: derived,
+          proved_by: [`${derived} exited 0`],
+          happened: autoAcceptSweepHappened(task),
+        };
+      }
+      return { eligible: false, ref, reason: result.reason, verify: derived };
+    }
+  }
+
+  return { eligible: false, ref, reason: verifier.reason, evidence: verifier.evidence };
+}
+
+function cmdSweep(args) {
+  if (!hasFlag(args, '--auto-accept')) {
+    failTask(
+      'atris task sweep',
+      'missing_auto_accept',
+      'atris task sweep currently requires --auto-accept for the explicit verified accept policy',
+    );
+  }
+  const actor = String(flag(args, '--as') || 'orb-autoaccept');
+  const parsedReward = parseAcceptReward(flag(args, '--reward'));
+  if (!parsedReward.ok) {
+    failTask('atris task sweep', 'invalid_reward', 'atris task sweep --auto-accept reward must be a positive number');
+  }
+  const limitRaw = flag(args, '--limit');
+  const explicitLimit = limitRaw && limitRaw !== true ? Math.max(1, Number(limitRaw) || 0) : null;
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const { projection } = writeDefaultProjection(taskDb, db);
+  const root = projection.workspace_root || process.cwd();
+  let pendingReview = (projection.tasks || [])
+    .filter((task) => task && task.status === 'review' && task.review && task.review.approval_status === 'pending')
+    .sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0));
+  if (explicitLimit) pendingReview = pendingReview.slice(0, explicitLimit);
+  const results = [];
+  for (const item of pendingReview) {
+    const fullProjection = enrichTaskProjection(taskDb.taskProjection(db, { taskId: item.id }));
+    const task = fullProjection.tasks[0] || null;
+    const evaluation = evaluateSweepAutoAccept(task, root);
+    if (!evaluation.eligible) {
+      results.push({ ...evaluation, action: 'skipped', task_id: task?.id || item.id || null });
+      continue;
+    }
+    const accepted = acceptReviewTask(taskDb, db, task.id, {
+      actor,
+      proof: evaluation.proof,
+      reward: parsedReward.value,
+      lesson: String(task.review?.lesson || task.metadata?.latest_agent_lesson || ''),
+      nextTask: String(task.review?.next_task || task.metadata?.latest_agent_next_task || ''),
+      autoAccepted: true,
+    });
+    if (!accepted.ok) {
+      results.push({ ...evaluation, action: 'accept_failed', task_id: task.id, reason: accepted.reason });
+      continue;
+    }
+    stampAutoAcceptMetadata(taskDb, db, task.id, actor, evaluation.policy);
+    refreshCareerXpAfterReview(accepted.reviewed);
+    results.push({
+      ...evaluation,
+      action: 'accepted',
+      task_id: task.id,
+      reward: accepted.reviewed.episode.reward.value,
+    });
+  }
+  const { outPath } = writeDefaultProjection(taskDb, db);
+  const summary = {
+    scanned: pendingReview.length,
+    accepted: results.filter((row) => row.action === 'accepted').length,
+    skipped: results.filter((row) => row.action === 'skipped').length,
+    failed: results.filter((row) => row.action === 'accept_failed').length,
+  };
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'sweep_auto_accept',
+      actor,
+      summary,
+      ...summary,
+      results,
+      projection_path: outPath,
+    });
+    return;
+  }
+  console.log(`TASK SWEEP AUTO-ACCEPT: ${summary.accepted} accepted / ${summary.scanned} scanned / ${summary.skipped} skipped${summary.failed ? ` / ${summary.failed} failed` : ''}`);
+  for (const row of results.filter((item) => item.action === 'accepted')) {
+    console.log(`ACCEPTED ${row.ref}: ${row.happened} | proved by ${row.proved_by.join(', ')}`);
+  }
 }
 
 function cmdRevise(args) {
@@ -8416,6 +10276,138 @@ function cmdRevise(args) {
   console.log(`revise ${taskRef(compactTaskFromProjection(projection, taskId))} v${result.event.version}`);
 }
 
+function taskAuditTimestamp(task) {
+  const acceptedAt = Date.parse(String(task?.metadata?.accepted_at || ''));
+  if (Number.isFinite(acceptedAt)) return acceptedAt;
+  return Number(task?.done_at || task?.updated_at || task?.created_at || 0);
+}
+
+function taskAuditOutput(value, max = 800) {
+  const text = String(value || '').trim();
+  if (text.length <= max) return text;
+  return `...${text.slice(-max)}`;
+}
+
+function taskAuditReceiptPath(at) {
+  const safeTime = at.replace(/[:.]/g, '-');
+  return path.join('atris', 'runs', `task-audit-${safeTime}.json`);
+}
+
+function runTaskAuditVerify(task, verify) {
+  const { spawnSync } = require('child_process');
+  const result = spawnSync('bash', ['-c', verify], {
+    cwd: task.workspace_root,
+    encoding: 'utf8',
+    timeout: 120000,
+  });
+  const passed = !result.error && result.status === 0;
+  return {
+    passed,
+    exit: result.status,
+    signal: result.signal || null,
+    error: result.error ? result.error.message : null,
+    output: taskAuditOutput(`${result.stdout || ''}${result.stderr || ''}`),
+  };
+}
+
+function cmdAudit(args) {
+  const limitRaw = flag(args, '--limit');
+  const limit = limitRaw === null ? 20 : Number(limitRaw);
+  if (!Number.isInteger(limit) || limit < 1) {
+    console.error('atris task audit: --limit must be a positive integer');
+    process.exit(2);
+  }
+
+  const revise = hasFlag(args, '--revise');
+  const actor = String(flag(args, '--as') || 'task-audit');
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const workspaceRoot = taskDb.workspaceRoot();
+  const allRows = taskDb.listTasks(db, { workspaceRoot });
+  const accepted = taskDb.withTaskDisplayRefs(
+    allRows
+      .filter(task => task.status === 'done' && task.metadata?.approval_status === 'accepted')
+      .sort((a, b) => taskAuditTimestamp(b) - taskAuditTimestamp(a))
+      .slice(0, limit),
+    allRows,
+  );
+  const at = new Date().toISOString();
+  const receiptPath = taskAuditReceiptPath(at);
+  const results = accepted.map(task => {
+    const verify = typeof task.metadata?.verify === 'string' ? task.metadata.verify : '';
+    if (!verify.trim()) {
+      return {
+        task_id: task.id,
+        ref: task.display_id || task.legacy_ref || taskRef(task),
+        status: 'skipped-no-verify',
+        verify: null,
+      };
+    }
+    const run = runTaskAuditVerify(task, verify);
+    return {
+      task_id: task.id,
+      ref: task.display_id || task.legacy_ref || taskRef(task),
+      status: run.passed ? 'passed' : 'failed',
+      verify,
+      exit: run.exit,
+      signal: run.signal,
+      error: run.error,
+      output: run.output,
+    };
+  });
+
+  const failing = results.filter(row => row.status === 'failed');
+  if (revise) {
+    const note = `task audit re-ran the stored verify and it failed; see ${receiptPath}`;
+    for (const row of failing) {
+      const revised = taskDb.reviseTask(db, {
+        id: row.task_id,
+        actor,
+        note,
+        allowDone: true,
+      });
+      row.revised = revised.revised === true;
+      row.revise_reason = revised.revised ? null : revised.reason;
+    }
+    if (failing.some(row => row.revised)) writeDefaultProjection(taskDb, db);
+  }
+
+  const summary = {
+    sampled: results.length,
+    passed: results.filter(row => row.status === 'passed').length,
+    failed: failing.length,
+    'skipped-no-verify': results.filter(row => row.status === 'skipped-no-verify').length,
+    revised: results.filter(row => row.revised === true).length,
+  };
+  const receipt = {
+    schema: 'atris.task_audit_receipt.v1',
+    at,
+    workspace_root: workspaceRoot,
+    limit,
+    revise,
+    summary,
+    failing_task_ids: failing.map(row => row.task_id),
+    results,
+  };
+  const receiptFile = path.join(workspaceRoot, receiptPath);
+  fs.mkdirSync(path.dirname(receiptFile), { recursive: true });
+  fs.writeFileSync(receiptFile, `${JSON.stringify(receipt, null, 2)}\n`, 'utf8');
+
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'task_audit',
+      receipt_path: receiptPath,
+      ...receipt,
+    });
+    return;
+  }
+  console.log(`task audit: sampled ${summary.sampled}, passed ${summary.passed}, failed ${summary.failed}, skipped-no-verify ${summary['skipped-no-verify']}`);
+  console.log(`failing task ids: ${failing.length ? failing.map(row => row.ref).join(', ') : 'none'}`);
+  if (revise) console.log(`revised: ${summary.revised}`);
+  console.log(`receipt: ${receiptPath}`);
+}
+
 function cmdReview(args) {
   const pos = positional(args);
   const id = pos[0];
@@ -8444,6 +10436,7 @@ function cmdReview(args) {
   if (clearNextTask || (typeof nextTaskFlag === 'string' && !String(nextTaskFlag).trim())) clearedFields.push('next_task');
   const proof = proofFlagValue(args);
   const verify = textFlag(args, ['--verify']);
+  guardExplicitActor('atris task review', flag(args, '--as'));
   const actor = flag(args, '--as') || DEFAULT_OWNER;
   const rewardValue = reward === true || reward === null ? 0 : reward;
   if (agentProofOnlyMode() && Number(rewardValue) > 0) {
@@ -8481,7 +10474,11 @@ function cmdReview(args) {
     clearedFields,
   });
   if (!result.reviewed) {
-    console.error(`review failed: ${result.reason}`);
+    if (result.reason === 'judge_equals_worker') {
+      console.error(`review failed: judge_equals_worker: ${result.builder} built this task and cannot judge it. Hand off: atris task review ${id} --reward 1 --as <another member>`);
+    } else {
+      console.error(`review failed: ${result.reason}`);
+    }
     process.exit(1);
   }
   const nextCreated = createNextTaskIfRequested(taskDb, db, args, currentTask, result.episode.next_task_suggestion);
@@ -8587,21 +10584,23 @@ function cmdEvents(args) {
   const pos = positional(args);
   let taskId = pos[0] || null;
   const all = hasFlag(args, '--all');
+  const everywhere = taskScopeEverywhere(args);
   const rawLimit = flag(args, '--limit');
   const explicitLimit = rawLimit && rawLimit !== true ? Number(rawLimit) : null;
   const defaultRecentLimit = 24;
-  const limit = explicitLimit || (taskId ? 500 : (all ? null : defaultRecentLimit));
+  const limit = explicitLimit || (taskId ? 500 : (all || everywhere ? null : defaultRecentLimit));
   const taskDb = getTaskDb();
   const db = taskDb.open();
   if (taskId) taskId = requireTaskId(taskDb, db, taskId, 'atris task events');
+  const workspaceRoot = scopedWorkspaceRoot(taskDb, args, { everywhere });
   const events = taskDb.listTaskEvents(db, {
     taskId,
-    workspaceRoot: all || taskId ? null : taskDb.workspaceRoot(),
+    workspaceRoot: taskId ? null : workspaceRoot,
     limit,
-    order: taskId || all ? 'asc' : 'desc',
+    order: taskId || all || everywhere ? 'asc' : 'desc',
   });
   const refRows = taskDb.listTasks(db, {
-    workspaceRoot: all ? null : (taskId ? (taskDb.getTask(db, taskId) || {}).workspace_root : taskDb.workspaceRoot()),
+    workspaceRoot: everywhere ? null : (taskId ? (taskDb.getTask(db, taskId) || {}).workspace_root : workspaceRoot),
   });
   const refById = taskDb.taskDisplayRefMap(refRows);
   if (wantsJson(args)) {
@@ -8609,7 +10608,7 @@ function cmdEvents(args) {
       ok: true,
       action: 'events',
       task_id: taskId,
-      mode: taskId ? 'task' : (all ? 'ledger' : 'recent'),
+      mode: taskId ? 'task' : (everywhere ? 'ledger_everywhere' : (all ? 'ledger' : 'recent')),
       limit,
       events,
     });
@@ -8619,7 +10618,7 @@ function cmdEvents(args) {
     console.log('(no task events)');
     return;
   }
-  if (!taskId && !all) {
+  if (!taskId && !all && !everywhere) {
     console.log('TASK EVENTS');
     console.log(`recent ${events.length} event${events.length === 1 ? '' : 's'} (use --all for the full ledger, --limit N to adjust)`);
     console.log('');
@@ -8720,12 +10719,13 @@ function cmdLineage(args) {
 function cmdExport(args) {
   const out = flag(args, '--out') || path.join('.atris', 'state', 'tasks.projection.json');
   const all = hasFlag(args, '--all');
+  const everywhere = taskScopeEverywhere(args);
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const outPath = path.resolve(String(out));
   const projection = enrichTaskProjection(taskDb.taskProjection(db, {
-    workspaceRoot: all ? null : taskDb.workspaceRoot(),
-    limit: 500,
+    workspaceRoot: scopedWorkspaceRoot(taskDb, args, { everywhere }),
+    limit: all ? null : 500,
   }));
   fs.mkdirSync(path.dirname(outPath), { recursive: true });
   fs.writeFileSync(outPath, JSON.stringify(projection, null, 2) + '\n', 'utf8');
@@ -8902,21 +10902,61 @@ function taskRenderSummaryLine(counts) {
   ].join('; ');
 }
 
+function refreshExistingTodoMarkdown(taskDb, db, workspaceRoot) {
+  const ws = workspaceRoot || taskDb.workspaceRoot();
+  const outPath = path.join(ws, 'atris', 'TODO.md');
+  if (!fs.existsSync(outPath)) return null;
+  const rows = taskDb.listTasks(db, { workspaceRoot: ws, limit: 500 });
+  const refRows = taskDb.listTasks(db, { workspaceRoot: ws });
+  const existingTodo = fs.readFileSync(outPath, 'utf8');
+  const preservedSections = [];
+  const endgameSection = extractTodoSectionMarkdown(existingTodo, 'Endgame');
+  if (endgameSection) preservedSections.push(endgameSection);
+  const markdownRows = markdownRowsForRender(taskDb, outPath, rows, refRows);
+  const markdown = taskDb.renderTodoMarkdown([...rows, ...markdownRows], {
+    refRows,
+    preservedSections,
+  });
+  fs.writeFileSync(outPath, markdown, 'utf8');
+  return outPath;
+}
+
+// TODO.md is a projection of task-db state. Keep this best-effort and silent
+// because it runs after every successful mutating task command.
+function autoRenderTodoFromDb(cwd = process.cwd()) {
+  try {
+    const atrisDir = path.join(cwd, 'atris');
+    if (!fs.existsSync(atrisDir)) return null;
+    const taskDb = getTaskDb();
+    const db = taskDb.open();
+    const outPath = path.join(atrisDir, 'TODO.md');
+    if (fs.existsSync(outPath)) return refreshExistingTodoMarkdown(taskDb, db, cwd);
+    const rows = taskDb.listTasks(db, { workspaceRoot: cwd, limit: 500 });
+    const refRows = taskDb.listTasks(db, { workspaceRoot: cwd });
+    fs.writeFileSync(outPath, taskDb.renderTodoMarkdown(rows, { refRows }), 'utf8');
+    return outPath;
+  } catch {
+    return null;
+  }
+}
+
 function cmdRender(args) {
   const out = flag(args, '--out') || path.join('atris', 'TODO.md');
   const all = hasFlag(args, '--all');
+  const everywhere = taskScopeEverywhere(args);
   const doneLimitRaw = flag(args, '--done-limit');
   const doneLimit = doneLimitRaw && doneLimitRaw !== true ? Number(doneLimitRaw) : undefined;
   const failedLimitRaw = flag(args, '--failed-limit');
   const failedLimit = failedLimitRaw && failedLimitRaw !== true ? Number(failedLimitRaw) : undefined;
   const taskDb = getTaskDb();
   const db = taskDb.open();
+  const workspaceRoot = scopedWorkspaceRoot(taskDb, args, { everywhere });
   const rows = taskDb.listTasks(db, {
-    workspaceRoot: all ? null : taskDb.workspaceRoot(),
-    limit: 500,
+    workspaceRoot,
+    limit: all ? null : 500,
   });
   const refRows = taskDb.listTasks(db, {
-    workspaceRoot: all ? null : taskDb.workspaceRoot(),
+    workspaceRoot,
   });
   const outPath = path.resolve(String(out));
   const existingTodo = fs.existsSync(outPath) ? fs.readFileSync(outPath, 'utf8') : '';
@@ -9525,6 +11565,7 @@ async function handleTaskApi(req, res, taskDb, db) {
       owner,
       reviewer,
       all: url.searchParams.get('all') === '1' || url.searchParams.get('all') === 'true',
+      everywhere: url.searchParams.get('everywhere') === '1' || url.searchParams.get('everywhere') === 'true',
       limit: Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 8,
       scope,
     });
@@ -9540,6 +11581,7 @@ async function handleTaskApi(req, res, taskDb, db) {
       owner,
       reviewer,
       all: url.searchParams.get('all') === '1' || url.searchParams.get('all') === 'true',
+      everywhere: url.searchParams.get('everywhere') === '1' || url.searchParams.get('everywhere') === 'true',
       limit: Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 8,
       scope,
     });
@@ -9570,6 +11612,7 @@ async function handleTaskApi(req, res, taskDb, db) {
       owner,
       reviewer,
       all: url.searchParams.get('all') === '1' || url.searchParams.get('all') === 'true',
+      everywhere: url.searchParams.get('everywhere') === '1' || url.searchParams.get('everywhere') === 'true',
       limit: Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 8,
       scope,
     });
@@ -9880,10 +11923,15 @@ async function handleTaskApi(req, res, taskDb, db) {
     if (proofIssue) return sendProofIssue(res, proof, proofIssue);
     const nextTaskInput = normalizeReviewNextTaskInput(body.next);
     const actor = String(body.actor || DEFAULT_OWNER);
+    const resultText = String(body.result || '').replace(/\s+/g, ' ').trim();
+    if (resultText) {
+      const resultIssue = resultSentenceIssue(resultText);
+      if (resultIssue) return sendJson(res, 400, { ok: false, reason: 'weak_result', detail: resultIssue });
+    }
     const resultTrace = buildAutomaticResultTrace(taskDb, db, taskId, {
       actor,
       proof,
-      changed: body.changed || body.result || body.done,
+      changed: body.changed || resultText || body.done,
       checked: body.checked || body.check || body.verified,
       passed: body.passed || body.pass,
       failed: body.failed || body.fail,
@@ -9901,6 +11949,7 @@ async function handleTaskApi(req, res, taskDb, db) {
       lesson: String(body.lesson || ''),
       nextTask: nextTaskInput.nextTask,
       resultTrace: resultTrace && resultTrace.trace,
+      result: resultText,
       landing: body.landing || {
         happened: body.happened,
         checked: body.checked,
@@ -10041,7 +12090,7 @@ function cmdServe(args) {
   });
 }
 
-async function run(args) {
+async function runTaskCommand(args) {
   const raw = args || [];
   if (raw.includes('--help') || raw.includes('-h')) return help();
   const first = raw[0];
@@ -10114,6 +12163,10 @@ async function run(args) {
       return cmdPlanPreview(rest);
     case 'note':   return cmdNote(rest);
     case 'say':    return cmdNote(rest);
+    case 'retitle': return cmdRetitle(rest);
+    case 'tag':
+    case 'tags':
+      return cmdTag(rest);
     case 'show':   return cmdShow(rest);
     case 'inspect': return cmdInspect(rest);
     case 'page':   return cmdPage(rest);
@@ -10122,11 +12175,18 @@ async function run(args) {
     case 'chat-review':
       return cmdReviewChat(rest);
     case 'ready':  return cmdReady(rest);
+    case 'receipt': return cmdTaskReceipt(rest);
     case 'result': return cmdResult(rest);
     case 'accept': return cmdAccept(rest);
+    case 'landing':
+    case 'land-review':
+      return cmdLanding(rest);
     case 'auto-accept-certified':
     case 'auto-accept':
       return cmdAutoAcceptCertified(rest);
+    case 'sweep':
+      return cmdSweep(rest);
+    case 'audit': return cmdAudit(rest);
     case 'certify-verified':
       return cmdCertifyVerified(rest);
     case 'accept-group':
@@ -10135,6 +12195,9 @@ async function run(args) {
     case 'done':   return cmdDone(rest);
     case 'finish': return cmdFinish(rest);
     case 'fail':   return cmdDone([...rest, '--failed']);
+    case 'archive': return cmdArchive(rest);
+    case 'clear-done': return cmdClearDone(rest);
+    case 'relabel-archived': return cmdRelabelArchived(rest);
     case 'review': return cmdReview(rest);
     case 'reviews':
     case 'review-queue':
@@ -10168,4 +12231,34 @@ async function run(args) {
   }
 }
 
-module.exports = { run, taskDayGroups, AGENT_ENV_MARKERS };
+const MUTATING_TASK_COMMANDS = new Set([
+  'add', 'new', 'delegate', 'assign', 'plan', 'do', 'backlog', 'unplan',
+  'clear-plan', 'clearplan', 'claim', 'start', 'release', 'unclaim', 'next',
+  'continue-work', 'continue', 'chat', 'note', 'say', 'retitle', 'tag', 'tags', 'step',
+  'ready', 'result', 'accept', 'landing', 'land-review', 'auto-accept-certified',
+  'auto-accept', 'sweep', 'audit', 'certify-verified', 'accept-group', 'revise',
+  'done', 'finish', 'fail', 'archive', 'clear-done', 'relabel-archived', 'review', 'import',
+  'setup', 'review-lane-act', 'review-act', 'act-review', 'review-lane-loop',
+  'review-loop', 'loop-review', 'review-lane-run', 'review-run', 'run-review',
+]);
+
+async function run(args) {
+  const raw = args || [];
+  const sub = !raw[0] || raw[0].startsWith('--') ? 'desk' : raw[0];
+  const result = await runTaskCommand(raw);
+  const skipsRender = sub === 'clear-done' && hasFlag(raw, '--dry-run');
+  if (MUTATING_TASK_COMMANDS.has(sub) && !skipsRender) autoRenderTodoFromDb();
+  return result;
+}
+
+module.exports = {
+  run,
+  taskDayGroups,
+  taskDayTextGroups,
+  taskDayTitle,
+  taskReviewLanding,
+  taskReviewLandingLines,
+  delegateTask,
+  AGENT_ENV_MARKERS,
+  autoRenderTodoFromDb,
+};