atris 3.35.0 → 3.36.0

package/commands/task.js

@@ -14,16 +14,18 @@ const {
   isAutoCertifyVerifyCommandAllowed,
   parseVerifyCommand,
   runVerifyCommand,
+  runVerifyCommandCached,
   DENIED_TAGS,
 } = require('../lib/auto-accept-certified');
-const { extractReceiptEvidence } = require('../lib/receipt-evidence');
+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,
@@ -46,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',
@@ -107,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;
 }
 
@@ -133,16 +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
@@ -153,6 +165,7 @@ atris task - durable local task state (SQLite, gitignored)
   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
@@ -163,7 +176,8 @@ atris task - durable local task state (SQLite, gitignored)
                                            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 [--all] [--everywhere] [--json]  show today's owner-grouped task list
+  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
@@ -183,6 +197,7 @@ 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
@@ -196,6 +211,7 @@ atris task - durable local task state (SQLite, gitignored)
   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
@@ -427,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);
@@ -456,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;
@@ -481,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}`);
@@ -509,8 +647,15 @@ function writeDefaultProjection(taskDb, db, options = {}) {
     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 };
 }
 
@@ -733,6 +878,8 @@ 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.
@@ -926,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();
@@ -1055,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'
@@ -1658,7 +1803,10 @@ 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;
@@ -2102,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,
   };
@@ -2156,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;
@@ -2181,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 }) || {};
@@ -4577,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');
@@ -4595,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) {
@@ -4772,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;
   }
@@ -4806,32 +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`);
   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 ready for approval.');
+    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;
   }
+  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) => {
-    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 (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) {
@@ -4843,18 +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}`);
+    }
   });
-  for (const item of blockedItems) {
-    console.log('');
-    console.log(`blocked: ${item.display_id || taskRef(item.id)}: ${item.reason}; next: ${item.next_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.`);
   }
 }
 
@@ -4969,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',
@@ -5218,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) {
@@ -5236,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,
@@ -5281,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');
@@ -5343,6 +6093,7 @@ 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();
@@ -5373,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');
@@ -5514,7 +6271,11 @@ 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}`
@@ -5740,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')) {
@@ -5961,6 +6722,58 @@ 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) {
@@ -6324,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();
@@ -7084,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']),
@@ -7196,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') {
@@ -7632,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,
@@ -7642,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;
@@ -7651,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'
@@ -7776,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,
@@ -7985,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');
@@ -8067,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,
@@ -8204,6 +9061,86 @@ function cmdArchive(args) {
   }
 }
 
+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
@@ -8272,6 +9209,7 @@ 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 : '';
   const verifyAutoCertifyAllowed = !usedVerify || isAutoCertifyVerifyCommandAllowed(verifyFlag);
@@ -8304,7 +9242,7 @@ function cmdReady(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']),
@@ -8318,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,
@@ -8331,6 +9276,7 @@ function cmdReady(args) {
     nextTask: nextTaskInput.nextTask,
     resultTrace: resultTrace && resultTrace.trace,
     landing,
+    result: resultSentence,
   });
   if (!result.ready) {
     console.error(`ready failed: ${result.reason}`);
@@ -8354,6 +9300,7 @@ function cmdReady(args) {
   });
   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',
@@ -8361,6 +9308,8 @@ function cmdReady(args) {
     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.'
@@ -8443,7 +9392,7 @@ function cmdTaskReceipt(args) {
   }
   if (receipt.passed) {
     console.log(`receipt written: ${receipt.receiptPath} (exit 0)`);
-    console.log(`use: atris task ready ${taskId} --proof "Receipt: ${receipt.receiptPath}"`);
+    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);
@@ -8483,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');
@@ -8583,6 +9536,11 @@ function stampAutoAcceptMetadata(taskDb, db, taskId, actor, policy) {
 }
 
 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',
@@ -8665,9 +9623,51 @@ function stampReadyVerifyMetadata(taskDb, db, taskId, verify) {
   `).run(JSON.stringify(metadata), Date.now(), taskId);
 }
 
-function cmdCertifyVerified(args) {
+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;
@@ -8704,6 +9704,11 @@ 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 —
@@ -8739,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;
@@ -8773,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) {
@@ -8805,6 +9813,7 @@ function cmdLanding(args) {
 function cmdAutoAcceptCertified(args) {
   const dryRun = hasFlag(args, '--dry-run');
   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);
@@ -8863,6 +9872,14 @@ function cmdAutoAcceptCertified(args) {
     );
   }
 
+  // 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);
@@ -8890,7 +9907,12 @@ function cmdAutoAcceptCertified(args) {
       results.push({ ref: item.display_id || item.id, eligible: false, reason: 'task_not_found', action: 'skipped' });
       continue;
     }
-    const evaluation = evaluateAutoAccept(task, { strictVerify, acceptAll });
+    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;
@@ -8899,6 +9921,20 @@ 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,
@@ -8927,8 +9963,9 @@ function cmdAutoAcceptCertified(args) {
     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;
@@ -8944,18 +9981,20 @@ function cmdAutoAcceptCertified(args) {
       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.certified} certified, ${summary.scanned} scanned, ${summary.accepted || summary.would_accept} accepted, ${summary.skipped} skipped${summary.failed ? `, ${summary.failed} failed` : ''}${summary.undercounted ? ' (UNDERCOUNTED — raise --limit or the sweep cap)' : ''}`);
+  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([
@@ -9237,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];
@@ -9750,6 +10921,25 @@ function refreshExistingTodoMarkdown(taskDb, db, workspaceRoot) {
   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');
@@ -10733,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,
@@ -10754,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,
@@ -10894,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];
@@ -10967,6 +12163,7 @@ 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);
@@ -10989,6 +12186,7 @@ async function run(args) {
       return cmdAutoAcceptCertified(rest);
     case 'sweep':
       return cmdSweep(rest);
+    case 'audit': return cmdAudit(rest);
     case 'certify-verified':
       return cmdCertifyVerified(rest);
     case 'accept-group':
@@ -10998,6 +12196,7 @@ async function run(args) {
     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':
@@ -11032,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,
+};