atris 3.30.12 → 3.32.0

package/commands/task.js

@@ -8,13 +8,14 @@ const http = require('http');
 const path = require('path');
 const os = require('os');
 const { taskProofState, buildVerifiedProof } = require('../lib/task-proof');
-const { evaluateAutoAccept, parseVerifyCommand } = require('../lib/auto-accept-certified');
+const { evaluateAutoAccept, parseVerifyCommand, runVerifyCommand, DENIED_TAGS } = require('../lib/auto-accept-certified');
 const { extractReceiptEvidence } = require('../lib/receipt-evidence');
 const escapeRegExp = require('../lib/escape-regexp');
 const {
   normalizeOwnerSlug,
   resolveFunctionalOwner: resolveFunctionalTaskOwner,
 } = require('../lib/functional-owner');
+const { operatorReady, hasAgentJargon } = require('./autoland');
 
 const DEFAULT_OWNER = process.env.ATRIS_AGENT_ID
   || process.env.USER
@@ -90,6 +91,14 @@ function getTaskDb() {
   }
 }
 
+function warnIfTaskTitleNeedsOperatorWhy(title) {
+  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);
+  return warning;
+}
+
 function taskUsageText() {
   return `
 atris task - durable local task state (SQLite, gitignored)
@@ -113,6 +122,8 @@ atris task - durable local task state (SQLite, gitignored)
   atris task review-chat <id> [--as <owner>]  Start a task-owned /codex verification chat
   atris task accept <id> [--proof "..."] [--public]
                                            Human accepts proof, marks done; --public also publishes AgentXP
+  atris task certify-verified [--dry-run] [--limit <n>] [--as <actor>]
+                                           Re-run the runnable check named in each Review proof as a second actor; passing rows certify (denied lanes and check-less rows wait for a human)
   atris task auto-accept-certified --dry-run [--strict-verify] [--limit <n>]
                                            Preview certified Review rows; live accept needs --confirm-human-accept --as <human>
   atris task revise <id> --note "..."      Send reviewed work back to Do
@@ -150,8 +161,8 @@ atris task - durable local task state (SQLite, gitignored)
   atris task finish <id> --proof "..."     Legacy alias for done with proof
   atris task review <id> --reward <n> [--verify "<cmd>"]
                                            Write review event + RSI episode
-  atris task reviews [--limit <n>]         Show certified Review items for human accept/revise
-  atris task reviews --group-by <tag|owner|source>   Cluster ready-to-land work for fast triage
+  atris task reviews [--all|--limit <n>] [--verbose]   Show certified Review items for human accept/revise
+  atris task reviews --group-by <tag|owner|source>   Cluster approval-ready work for fast triage
   atris task accept-group <key>=<value> --spot-check K --confirm-human-accept --as <you> --verified <ids>
                                            Accept a whole cluster; career XP only on the K you verified
   atris task status [--json] [--history]   Compact live status for web/Swarlo
@@ -284,6 +295,63 @@ function refreshCareerXpAfterReview(reviewed) {
   return refreshCareerXpProjection(reviewed?.episode?.workspace_root);
 }
 
+function compactCareerXpProjection(projection) {
+  if (!projection || typeof projection !== 'object') return projection;
+  const progress = projection.next_level_progress && typeof projection.next_level_progress === 'object'
+    ? {
+      level: projection.next_level_progress.level ?? null,
+      next_level: projection.next_level_progress.next_level ?? null,
+      current_xp: projection.next_level_progress.current_xp ?? null,
+      required_xp: projection.next_level_progress.required_xp ?? null,
+      remaining_xp: projection.next_level_progress.remaining_xp ?? null,
+      percent: projection.next_level_progress.percent ?? null,
+    }
+    : null;
+  const latest = projection.latest_accepted_proof && typeof projection.latest_accepted_proof === 'object'
+    ? {
+      label: projection.latest_accepted_proof.label ?? null,
+      receipt_id: projection.latest_accepted_proof.receipt_id ?? null,
+      source: projection.latest_accepted_proof.source ?? null,
+      source_task_id: projection.latest_accepted_proof.source_task_id ?? null,
+      title: projection.latest_accepted_proof.title ?? null,
+      xp: projection.latest_accepted_proof.xp ?? null,
+      reward: projection.latest_accepted_proof.reward ?? null,
+      accepted_at: projection.latest_accepted_proof.accepted_at ?? null,
+      goal: projection.latest_accepted_proof.goal ?? null,
+    }
+    : null;
+  const integrity = projection.integrity && typeof projection.integrity === 'object'
+    ? {
+      status: projection.integrity.status ?? null,
+      receipts_count: projection.integrity.receipts_count ?? projection.receipts_count ?? null,
+      head_hash: projection.integrity.head_hash ?? null,
+    }
+    : null;
+  return {
+    schema: projection.schema,
+    compact: true,
+    total_xp: projection.total_xp ?? projection.total_agent_xp ?? projection.agent_xp ?? null,
+    agent_xp: projection.agent_xp ?? projection.total_agent_xp ?? null,
+    today_xp: projection.today_xp ?? projection.today_agent_xp ?? null,
+    collected_receipts: projection.collected_receipts ?? 0,
+    receipts_count: projection.receipts_count ?? null,
+    level: projection.level ?? null,
+    leaderboard_eligible: projection.leaderboard_eligible ?? null,
+    integrity_status: projection.integrity_status ?? integrity?.status ?? null,
+    next_level_progress: progress,
+    latest_accepted_proof: latest,
+    integrity,
+    omitted: [
+      'contribution_graph',
+      'career',
+      'earning_model',
+      'local_activity',
+      'ledger',
+      'sources',
+    ],
+  };
+}
+
 function jsonModeActive() {
   return process.argv.includes('--json');
 }
@@ -317,13 +385,36 @@ function textFlag(args, names) {
 
 function landingFlags(args) {
   return {
-    happened: textFlag(args, ['--happened', '--what-happened']),
+    happened: textFlag(args, ['--landing', '--happened', '--what-happened']),
     checked: textFlag(args, ['--checked', '--how-checked']),
     tested: textFlag(args, ['--tested', '--what-tested']),
     decision: textFlag(args, ['--decision', '--acceptance']),
   };
 }
 
+function normalizedLandingSentence(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function defaultLandingSentenceForTitle(title) {
+  return `Completed: ${String(title || '').trim()}.`;
+}
+
+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);
+}
+
+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.';
+  console.error(warning);
+  return warning;
+}
+
 function numericFlag(args, name) {
   const value = flag(args, name);
   if (value === null || value === true || value === undefined) return null;
@@ -540,18 +631,19 @@ function buildPendingReviewChatPredicate(taskDb, db, workspaceRoot) {
 function createReviewNextTask(taskDb, db, currentTask, title) {
   const nextTitle = String(title || '').trim();
   if (!nextTitle) return null;
+  const operatorTitleWarning = warnIfTaskTitleNeedsOperatorWhy(nextTitle);
   const currentMetadata = currentTask && currentTask.metadata && typeof currentTask.metadata === 'object'
     ? currentTask.metadata
     : {};
   const existing = findExistingReviewNextTask(taskDb, db, currentTask, nextTitle);
-  if (existing) return { id: existing.id, inserted: false };
+  if (existing) return { id: existing.id, inserted: false, operator_title_warning: operatorTitleWarning };
   const goalId = currentMetadata.goal_id || currentMetadata.goalId || null;
   const parentId = currentTask && currentTask.id || null;
   const sourceKey = parentId && typeof taskDb.sourceKey === 'function'
     ? taskDb.sourceKey(`task_review_next:${parentId}`, nextTitle)
     : null;
   try {
-    return taskDb.addTask(db, {
+    const created = taskDb.addTask(db, {
       title: nextTitle,
       tag: currentTask && currentTask.tag || null,
       workspaceRoot: taskDb.workspaceRoot(),
@@ -562,10 +654,11 @@ function createReviewNextTask(taskDb, db, currentTask, title) {
         source: 'task_review_next',
       },
     });
+    return { ...created, operator_title_warning: operatorTitleWarning };
   } catch (error) {
     if (sourceKey && /constraint|unique/i.test(String(error && (error.code || error.message) || error))) {
       const racedExisting = findExistingReviewNextTask(taskDb, db, currentTask, nextTitle);
-      if (racedExisting) return { id: racedExisting.id, inserted: false };
+      if (racedExisting) return { id: racedExisting.id, inserted: false, operator_title_warning: operatorTitleWarning };
     }
     throw error;
   }
@@ -678,47 +771,103 @@ function reviewSummary(task, payload = {}) {
     || careerText.includes('agent xp')
   ) {
     if (task.status === 'done') {
-      return `Landed AgentXP result for ${plainTitle}.`;
+      return `Completed AgentXP result for ${plainTitle}.`;
     }
     if (task.status === 'review') {
-      return `${plainTitle} is ready to land; land only if the proof is real.`;
+      return `${plainTitle}: proof is ready for human approval; approve only if the evidence is real.`;
     }
-    return `This explains what landing ${plainTitle} would make real for AgentXP.`;
+    return `This explains the AgentXP result ${plainTitle} would make real.`;
   }
   if (task.status === 'done') {
-    return `Landed result for ${plainTitle}.`;
+    return `Completed result for ${plainTitle}.`;
   }
   if (task.status === 'review') {
-    return `${plainTitle} is ready to land; land it or send it back.`;
+    return `${plainTitle}: review the completed result, then approve or ask for rework.`;
   }
-  return `This explains what landing ${plainTitle} would make real.`;
+  return `This explains what ${plainTitle} would make real.`;
 }
 
 function titleToResultText(title) {
   const text = String(title || 'this task').replace(/\s+/g, ' ').trim();
-  if (!text) return 'This task is ready to review.';
+  if (!text) return 'Completed this task.';
+  const resultSentence = (prefix, body) => {
+    const clean = String(body || '').replace(/\s+/g, ' ').trim().replace(/[.!?]+$/, '');
+    return clean ? `${prefix} ${clean}.` : `${prefix}.`;
+  };
+  const missionXp = text.match(/^Mission XP:\s*(.+)$/i);
+  if (missionXp) {
+    const missionResult = titleToResultText(missionXp[1]).replace(/[.!?]+$/, '');
+    return resultSentence('Completed mission work:', missionResult.replace(/^Completed:\s*/i, ''));
+  }
   const [first, ...restParts] = text.split(' ');
   const rest = restParts.join(' ');
+  const firstLower = String(first || '').toLowerCase();
+  const compound = rest.match(/^and\s+([a-z]+)\s+(.+)$/i);
+  const compoundPast = compound ? ({
+    audit: { close: 'Audited and closed' },
+    decide: { start: 'Decided and started' },
+    prune: { compress: 'Pruned and compressed' },
+  }[firstLower] || {})[String(compound[1] || '').toLowerCase()] : null;
+  if (compoundPast && compound[2]) return resultSentence(compoundPast, compound[2]);
   const past = {
     add: 'Added',
     approve: 'Prepared approval for',
+    audit: 'Audited',
+    batch: 'Batched',
     build: 'Built',
     clean: 'Cleaned',
     create: 'Created',
+    decide: 'Decided',
     design: 'Designed',
     document: 'Documented',
+    find: 'Found',
     fix: 'Fixed',
+    heal: 'Healed',
+    ignore: 'Ignored',
+    infer: 'Inferred',
+    keep: 'Kept',
     make: 'Made',
+    number: 'Numbered',
+    prune: 'Pruned',
+    reconcile: 'Reconciled',
+    refresh: 'Refreshed',
+    render: 'Rendered',
+    repair: 'Repaired',
     replace: 'Replaced',
+    respect: 'Respected',
     route: 'Routed',
     run: 'Ran',
     ship: 'Shipped',
+    show: 'Showed',
+    stop: 'Stopped',
+    summarize: 'Summarized',
+    suppress: 'Suppressed',
+    trim: 'Trimmed',
     update: 'Updated',
+    use: 'Used',
     validate: 'Validated',
     wire: 'Wired',
-  }[String(first || '').toLowerCase()];
-  if (past && rest) return `${past} ${rest}.`;
-  return `${text} is ready to review.`;
+  }[firstLower];
+  if (past && rest) return resultSentence(past, rest);
+  return resultSentence('Completed:', text);
+}
+
+function proofToReasonText(proof) {
+  const text = String(proof || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  const label = /\b(?:Product proof|Why it matters)\s*:\s*/i.exec(text);
+  if (!label) return '';
+  const rest = text.slice(label.index + label[0].length);
+  const stop = rest.search(/(?:^|[.;]\s+)\b(?:Checks?|Mission receipt|Receipt|Landing|Changed|How I checked|What I tested|Saved|Decision)\s*:/i);
+  let section = (stop >= 0 ? rest.slice(0, stop) : rest)
+    .replace(/^(?:[-:]\s*)+/, '')
+    .replace(/\s+/g, ' ')
+    .replace(/\s*[;,:-]\s*$/, '')
+    .trim();
+  const sentenceStop = section.search(/[.!?]\s+/);
+  if (sentenceStop >= 0) section = section.slice(0, sentenceStop + 1).trim();
+  if (!section) return '';
+  return /[.!?]$/.test(section) ? section : `${section}.`;
 }
 
 function titleToReasonText(task, proof = '') {
@@ -737,35 +886,102 @@ function titleToReasonText(task, proof = '') {
     return 'It keeps real-world side effects behind a clear human decision.';
   }
   if (/\btest|self-test|harness|verifier|proof\b/.test(text)) {
-    return 'It makes the check repeatable before the work lands.';
+    return 'It gives the human a repeatable check before approval.';
   }
-  return 'It closes the user-visible gap named by the task.';
+  return 'It turns the task title into a concrete result the human can approve.';
 }
 
 function proofToHumanCheck(proof) {
   const text = String(proof || '').replace(/\s+/g, ' ').trim();
   if (!text) return 'Proof is attached below.';
   const lower = text.toLowerCase();
+  const passSignal = /\b(?:pass(?:es|ed|ing)?|ok|green|succeeded|verified)\b/.test(lower);
+  const verifierCommandSignal = /\b(?:npm|node|git|atris|npx|pnpm|yarn|python3?|pytest|bash|sh|tsc|vitest|curl|gh|rg)\s+\S+/.test(lower);
   if (/\b(?:atris\s+)?task\s+(?:show|page)\b/.test(lower) && /\b(?:print|prints|printed|render|renders|rendered|show|shows|showed)\b/.test(lower)) {
     return 'I opened the real task screen and checked the receipt renders before raw proof.';
   }
-  if (/git\s+diff\s+--check/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) {
+  if (/git\s+diff\s+--check/.test(lower) && passSignal) {
     if (/node\s+--test/.test(lower)) return 'I ran the behavior check and the diff cleanliness check.';
     return 'I ran the diff cleanliness check.';
   }
-  if (/\btypecheck\b/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) return 'I ran the typecheck.';
-  if (/\bbuild\b/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) return 'I ran the build check.';
-  if (/\btest\b/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) return 'I ran the verifier named in the proof.';
-  if (/\bvalidat(?:e|ion|ed)\b/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) return 'I ran the validation check.';
+  if (/\btypecheck\b/.test(lower) && passSignal) return 'I ran the typecheck.';
+  if (/\bbuild\b/.test(lower) && passSignal) return 'I ran the build check.';
+  if (/\btest\b/.test(lower) && passSignal) return 'I ran the verifier named in the proof.';
+  if (/\bvalidat(?:e|ion|ed)\b/.test(lower) && passSignal) return 'I ran the validation check.';
+  if (verifierCommandSignal && /\b(?:print|prints|printed|show|shows|showed|report|reports|reported|return|returns|returned)\b/.test(lower)) {
+    return 'I checked the verifier output named in the proof.';
+  }
+  if (verifierCommandSignal && passSignal) return 'I ran the verifier named in the proof.';
+  if (/atris\/runs\/[^\s),.;:]+\.json/.test(text)) {
+    return passSignal
+      ? 'I inspected the passing receipt named in the proof.'
+      : 'I inspected the receipt named in the proof.';
+  }
+  if (/(?:^|\s)(?:\.{0,2}\/)?scripts\/[^\s),.;:]+\.(?:js|mjs|cjs|py|sh)\b/.test(text)) {
+    return 'I inspected the verifier artifact named in the proof.';
+  }
   if (/\breview(?:ed)?\b/.test(lower)) return 'Review proof is attached below.';
   return 'Proof is attached below.';
 }
 
+function taskReviewFormatCommandList(commands) {
+  const list = Array.isArray(commands)
+    ? commands.map(command => String(command || '').trim()).filter(Boolean)
+    : [];
+  if (!list.length) return '';
+  if (list.length > 1) {
+    return list.map((command, index) => `command ${index + 1}: ${command}`).join('; ');
+  }
+  return list[0];
+}
+
+function taskReviewProseCheckLabels(proof) {
+  const text = String(proof || '').replace(/\s+/g, ' ').trim();
+  if (!text) return [];
+  const lower = text.toLowerCase();
+  const hasPass = /\b(?:pass(?:es|ed|ing)?|green|verified|current|clean|complete|completed)\b/.test(lower);
+  if (!hasPass) return [];
+  const labels = [];
+  const add = label => {
+    if (!labels.includes(label)) labels.push(label);
+  };
+  if (/\bhelp output\b/.test(lower)) add('help output');
+  if (/\b(?:wiki verify|public wiki verify|loop wiki)\b/.test(lower)) add('wiki verification');
+  if (/\bclean dry-run\b/.test(lower)) add('clean dry-run');
+  if (/\b(?:test slice|regression run|tests?|test)\b.*\bpass(?:es|ed|ing)?\b/.test(lower)
+    || /\bpass(?:es|ed|ing)?\b.*\b(?:test slice|regression run|tests?|test)\b/.test(lower)) {
+    add('passing tests');
+  }
+  if (/\bverifier\b.*\bpass(?:es|ed|ing)?\b/.test(lower)
+    || /\bpass(?:es|ed|ing)?\b.*\bverifier\b/.test(lower)) {
+    add('passing verifier');
+  }
+  if (/\bmission\b.*\bcomplete(?:d)?\b/.test(lower)) add('completed mission');
+  if (/\bgit diff --check\b/.test(lower) || /\bdiff cleanliness\b/.test(lower)) add('diff cleanliness');
+  return labels;
+}
+
 function taskReviewLandingTested(proof) {
-  const commands = taskReviewEvidenceCommands(proof, 3);
-  if (commands.length) return `I ran: ${commands.join(' | ')}.`;
-  const paths = taskReviewEvidencePaths(proof, 3);
-  if (paths.length) return `I inspected: ${paths.join(', ')}.`;
+  const maxVisible = 3;
+  const commands = taskReviewEvidenceCommands(proof, 20);
+  if (commands.length) {
+    return commands.length === 1
+      ? 'I ran the listed check for this result.'
+      : 'I ran the listed checks for this result.';
+  }
+  const paths = taskReviewEvidencePaths(proof, 20);
+  if (paths.length) {
+    return paths.length === 1
+      ? 'I inspected the artifact named in the proof.'
+      : `I inspected ${paths.length} artifacts named in the proof.`;
+  }
+  const proseChecks = taskReviewProseCheckLabels(proof);
+  if (proseChecks.length) {
+    const visible = proseChecks.slice(0, maxVisible);
+    const omitted = proseChecks.length - visible.length;
+    const suffix = omitted > 0 ? `, and ${omitted} more ${omitted === 1 ? 'check' : 'checks'}` : '';
+    return `I checked: ${visible.join(', ')}${suffix}.`;
+  }
   return String(proof || '').trim() ? 'I attached the proof below.' : 'No verifier command recorded yet.';
 }
 
@@ -793,16 +1009,16 @@ function taskReviewLanding(task, review = {}, payload = {}) {
     || payload.reason || payload.why || metadata.result_reason || metadata.review_reason || metadata.why_it_matters;
   return {
     happened: clipStatusText(explicitHappened || titleToResultText(task.title), 220),
-    reason: clipStatusText(explicitReason || titleToReasonText(task, proof), 220),
+    reason: clipStatusText(explicitReason || proofToReasonText(proof) || titleToReasonText(task, proof), 220),
     checked: clipStatusText(explicitChecked || proofToHumanCheck(proof), 220),
     tested: clipStatusText(explicitTested || taskReviewLandingTested(proof), 260),
     decision: clipStatusText(explicitDecision || (task.status === 'done'
-      ? 'Landed. No action needed unless this regresses.'
+      ? 'Done. No action needed unless this regresses.'
       : approvalStatus === 'revise'
         ? 'Rework requested. Fix the note, then send a new receipt.'
         : approvalStatus === 'pending' && !agentCertified
-          ? 'Needs one more check before landing; send it back if the receipt misses the point.'
-          : 'Land it if this matches the request; send it back if not.'), 220),
+          ? 'Needs one more check; ask for rework if the receipt misses the point.'
+          : 'Approve if this matches the request; ask for rework if not.'), 220),
   };
 }
 
@@ -815,13 +1031,20 @@ function taskReviewResult(task, review = {}, payload = {}) {
     changed: landing.happened,
     reason: landing.reason,
     checked: landing.checked,
-    saved: clipStatusText(explicitSaved || (task.status === 'done'
-      ? `Landed as ${ref}.`
-      : `Ready to land as ${ref}.`), 180),
+    saved: clipStatusText(explicitSaved || taskReviewSavedText(task, review, ref), 180),
     accept: landing.decision,
   };
 }
 
+function taskReviewSavedText(task, review = {}, ref = taskRef(task)) {
+  if (task.status === 'done') return `Result accepted as ${ref}.`;
+  const metadata = task.metadata || {};
+  const agentCertified = review.agent_certified === true || metadata.agent_certified === true;
+  if (task.status === 'review' && agentCertified) return `Result is ready for human approval as ${ref}.`;
+  if (task.status === 'review') return `Completed result saved for review as ${ref}.`;
+  return `Work record saved as ${ref}.`;
+}
+
 function taskReviewSummary(task) {
   const reviewed = (task.events || []).slice().reverse().find(e => e.event_type === 'reviewed' || e.event_type === 'proof_ready' || e.event_type === 'revision_requested');
   const payload = reviewed && reviewed.payload || {};
@@ -978,6 +1201,8 @@ function buildTaskStreams(tasks, goals) {
     if (column === 'doing') stream.doing_count += 1;
     if (column === 'blocked') stream.blocked_count += 1;
     if (column === 'review') stream.review_count += 1;
+    const review = task.review || {};
+    const metadata = task.metadata || {};
     stream.tasks.push({
       id: task.id,
       title: task.title,
@@ -987,7 +1212,7 @@ function buildTaskStreams(tasks, goals) {
       assigned_to: taskAssignee(task),
       parent_task_id: task.lineage && task.lineage.parent_task_id || null,
       child_task_ids: task.lineage && task.lineage.child_task_ids || [],
-      proof: task.review && task.review.proof || null,
+      proof: review.proof || metadata.latest_agent_proof || null,
     });
   }
   for (const goal of goals) {
@@ -1292,17 +1517,142 @@ function taskReviewCommandLooksSpecific(command) {
   if (/^atris\s+task\s+\w+\s*$/i.test(text)) return false;
   if (/^atris\s+task\s+(?:accept|auto-accept-certified)\b/i.test(text)) return false;
   if (/^atris[/.]/i.test(text)) return false;
+  if (/^atris-\S+/i.test(text)) return false;
   if (/^atris\s+task\s+\w+\s+json\s*$/i.test(text) && !/--json\b/i.test(text)) return false;
   if (/^atris\s+(?:command|review-chat|smoke|temp)\b/i.test(text)) return false;
   if (/^(?:npm|npx|pnpm|yarn|python3?|pytest|bash|sh|tsc|vitest|curl|gh|rg|git)\s+commands?\b/i.test(text)) return false;
   if (/^(?:npm|pnpm|yarn)\s+(?:tests|checks?)$/i.test(text)) return false;
   if (/^(?:git|gh|rg|curl|bash|sh|tsc)\s+(?:tests?|checks?)$/i.test(text)) return false;
-  if (/\s+(?:and|then)\s+\S+/i.test(text)) return false;
+  if (/\s+(?:and|then)\s+\S+/i.test(taskReviewWithoutQuotedSegments(text))) return false;
   if (/^node\s+(?!-|\S*(?:[/.]))/i.test(text)) return false;
   if (/^node\s+--test\s+[\w-]+(?:\s+[\w-]+)+$/i.test(text)) return false;
   return true;
 }
 
+function taskReviewUnescapedQuoteCount(text, quote) {
+  let count = 0;
+  const source = String(text || '');
+  for (let index = 0; index < source.length; index += 1) {
+    if (source[index] === quote && source[index - 1] !== '\\') count += 1;
+  }
+  return count;
+}
+
+function taskReviewCommandStartsInsideQuote(clause, commandIndex) {
+  const before = String(clause || '').slice(0, Math.max(0, commandIndex));
+  return taskReviewUnescapedQuoteCount(before, "'") % 2 === 1
+    || taskReviewUnescapedQuoteCount(before, '"') % 2 === 1;
+}
+
+function taskReviewWithoutQuotedSegments(text) {
+  const source = String(text || '');
+  let quote = null;
+  let out = '';
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    if ((char === "'" || char === '"') && source[index - 1] !== '\\') {
+      quote = quote === char ? null : (!quote ? char : quote);
+      out += ' ';
+      continue;
+    }
+    out += quote ? ' ' : char;
+  }
+  return out;
+}
+
+function taskReviewTrimOutsideQuotedTail(text, pattern) {
+  const source = String(text || '');
+  const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+  const scanner = new RegExp(pattern.source, flags);
+  let match;
+  while ((match = scanner.exec(source)) !== null) {
+    if (!taskReviewCommandStartsInsideQuote(source, match.index)) {
+      return source.slice(0, match.index);
+    }
+    if (match[0] === '') scanner.lastIndex += 1;
+  }
+  return source;
+}
+
+function taskReviewTrimTrailingOutsideQuote(text) {
+  let clean = String(text || '');
+  while (clean.length > 0) {
+    const index = clean.length - 1;
+    if (!/[\]),.;:]/.test(clean[index])) break;
+    if (taskReviewCommandStartsInsideQuote(clean, index)) break;
+    clean = clean.slice(0, index);
+  }
+  return clean;
+}
+
+function taskReviewCleanEvidenceCommand(command) {
+  let clean = String(command || '');
+  const tailPatterns = [
+    /\s+from\s+[^,;]*(?:showed|shows|showing|returned|returns|printed|prints|wrote|writes|reported|reports)\b.*$/i,
+    /\s+(?:showed|shows|showing|returned|returns|printed|prints|wrote|writes|reported|reports)\b.*$/i,
+    /\.\s+(?:Reward remains|No human|Human accept|AgentXP|XP)\b.*$/i,
+    /\s+with\s+\d+\s+(?:passing\s+)?(?:tests?|checks?|passes|passed|pass|ok|clean)\b.*$/i,
+    /\s+\((?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)\)$/i,
+    /\s+\(?(?:exit|status|code)\s+\d+\)?$/i,
+    /\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)\s+\d+\/\d+(?:[,.]\s+.*)?$/i,
+    /\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)\s+\d+\/\d+(?:\s+(?:tests?|checks?|passed|pass|ok|clean|failed|failures?))?$/i,
+    /\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)(?:[,.]\s+.*|\s+and\b.*)$/i,
+    /\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)\s+with\b.*$/i,
+    /,\s+(?:command suite|mission-status tests?|live\b|focused suite|clean dry-run|brain compile)\b.*$/i,
+    /\.\s+(?:The|This|It|Focused|Dogfood|Landing|Product|Review|Receipt|Human|No|Note)\b.*$/i,
+    /\s+\(?\d+\s+(?:passes|passed|pass|ok|clean|tests?|checks?)\)?$/i,
+    /\s+only$/i,
+    /\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)(?:[.:]\s+.*|\s+after\b.*)$/i,
+    /\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)\)?$/i,
+    /\s+\(?\d+\/\d+(?:\s+(?:tests?|checks?|passed|pass|ok|clean|failed|failures?))?\)?$/i,
+    /\s+\d+\/\d+(?:\s+(?:tests?|checks?|passed|pass|ok|clean|failed|failures?))?$/i,
+  ];
+  for (const pattern of tailPatterns) {
+    clean = taskReviewTrimOutsideQuotedTail(clean, pattern);
+    clean = taskReviewTrimTrailingOutsideQuote(clean);
+  }
+  return clean.replace(/\s+/g, ' ').trim();
+}
+
+function taskReviewSplitEvidenceClauses(source, commandStart) {
+  const text = String(source || '');
+  const hardBoundaryPattern = /^(?:;\s*|\n\s*|\s+&&\s+)/;
+  const softBoundaryPattern = new RegExp(`^(?:,\\s+|\\.\\s+|\\s+and\\s+|\\s+then\\s+|\\.\\s+(?:focused|full|behavior|verifier)[^\\n.;:]{0,80}:\\s+)(?=${commandStart})`, 'i');
+  const clauses = [];
+  let clause = '';
+  let quote = null;
+  for (let index = 0; index < text.length;) {
+    const char = text[index];
+    if ((char === "'" || char === '"') && text[index - 1] !== '\\') {
+      if (quote === char) quote = null;
+      else if (!quote) quote = char;
+      clause += char;
+      index += 1;
+      continue;
+    }
+    if (!quote) {
+      const rest = text.slice(index);
+      const boundary = rest.match(hardBoundaryPattern) || rest.match(softBoundaryPattern);
+      if (boundary) {
+        if (clause.trim()) clauses.push(clause);
+        clause = '';
+        index += boundary[0].length;
+        continue;
+      }
+    }
+    clause += char;
+    index += 1;
+  }
+  if (clause.trim()) clauses.push(clause);
+  return clauses;
+}
+
+function taskReviewCommandIsDescribedSubject(clause, commandIndex) {
+  const before = String(clause || '').slice(Math.max(0, commandIndex - 80), commandIndex);
+  return /\b(?:contains?|displays?|extracts?|lists?|mentions?|names?|prints?|renders?|shows?)\s+(?:only\s+)?$/i.test(before)
+    || /\b(?:including|includes?|like|such as|for example|e\.g\.)\s+$/i.test(before);
+}
+
 function taskReviewEvidenceCommands(text, limit = 8) {
   const source = String(text || '').trim();
   if (!source) return [];
@@ -1310,17 +1660,14 @@ function taskReviewEvidenceCommands(text, limit = 8) {
   const envPrefix = '(?:(?:[A-Z_][A-Z0-9_]*=[^\\s,;|]+)\\s+)*';
   const prosePrefix = '(?:(?:rechecked|reran|re-run|run|verified|validated|passed|validation(?:\\s+passed)?|verification(?:\\s+passed)?|focused|live|scoped|installed|direct|full|current|fresh|then|and|commands?|checks?)[:\\s]+)*';
   const commandStart = `${prosePrefix}${envPrefix}${commandWord}\\b`;
-  const commandStartPattern = new RegExp(`(^|[^\\w./-])(${commandStart})`, 'i');
+  const commandStartPattern = new RegExp(`(^|[^\\w./=-])(${commandStart})`, 'i');
   const commandStartInnerPattern = new RegExp(`${envPrefix}${commandWord}\\b`, 'i');
-  const commandBoundaryPattern = new RegExp(`(?:;\\s*|\\n\\s*|\\s+&&\\s+|,\\s+|\\.\\s+|\\s+and\\s+|\\s+then\\s+)(?=${commandStart})`, 'gi');
-  const clauses = source
+  const normalized = source
     .replace(/\r/g, '\n')
     .replace(/```[ \t]*(?:bash|sh|shell|zsh|console|text|txt)?[ \t]*\n/gi, '\n')
     .replace(/```/g, '\n')
-    .replace(/`/g, '')
-    .replace(/(?:;\s*|\n\s*|\s+&&\s+)/g, '\n')
-    .replace(commandBoundaryPattern, '\n')
-    .split('\n');
+    .replace(/`/g, '');
+  const clauses = taskReviewSplitEvidenceClauses(normalized, commandStart);
   const out = [];
   const seen = new Set();
   for (const clause of clauses) {
@@ -1330,22 +1677,13 @@ function taskReviewEvidenceCommands(text, limit = 8) {
     const raw = clause.slice(start.index + Math.max(0, commandStartOffset));
     const prefix = raw.match(commandStartInnerPattern);
     const commandOffset = prefix && prefix.index != null ? prefix.index : 0;
+    const commandIndex = start.index + Math.max(0, commandStartOffset) + Math.max(0, commandOffset);
+    if (
+      taskReviewCommandStartsInsideQuote(clause, commandIndex)
+      || taskReviewCommandIsDescribedSubject(clause, commandIndex)
+    ) continue;
     const command = raw.slice(Math.max(0, commandOffset));
-    const clean = command
-      .replace(/\s+from\s+[^,;]*(?:showed|shows|showing|returned|returns|printed|prints|wrote|writes|reported|reports)\b.*$/i, '')
-      .replace(/\s+(?:showed|shows|showing|returned|returns|printed|prints|wrote|writes|reported|reports)\b.*$/i, '')
-      .replace(/\.\s+(?:Reward remains|No human|Human accept|AgentXP|XP)\b.*$/i, '')
-      .replace(/\s+\((?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)\)$/i, '')
-      .replace(/\s+\(?(?:exit|status|code)\s+\d+\)?$/i, '')
-      .replace(/[\]),.;:]+$/g, '')
-      .replace(/\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)\s+\d+\/\d+(?:\s+(?:tests?|checks?|passed|pass|ok|clean|failed|failures?))?$/i, '')
-      .replace(/\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)(?:[.:]\s+.*|\s+after\b.*)$/i, '')
-      .replace(/\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)\)?$/i, '')
-      .replace(/\s+\(?\d+\/\d+(?:\s+(?:tests?|checks?|passed|pass|ok|clean|failed|failures?))?\)?$/i, '')
-      .replace(/\s+\d+\/\d+(?:\s+(?:tests?|checks?|passed|pass|ok|clean|failed|failures?))?$/i, '')
-      .replace(/[\]),.;:]+$/g, '')
-      .replace(/\s+/g, ' ')
-      .trim();
+    const clean = taskReviewCleanEvidenceCommand(command);
     if (!taskReviewCommandLooksSpecific(clean) || seen.has(clean.toLowerCase())) continue;
     seen.add(clean.toLowerCase());
     out.push(clean);
@@ -1365,13 +1703,24 @@ function taskReviewRecentThread(task, limit = 4) {
     .filter(message => message.content);
 }
 
+function taskReviewObjective(task) {
+  const metadata = task && task.metadata || {};
+  return task && (
+    metadata.task_goal
+    || task.title
+    || metadata.goal_objective
+    || metadata.objective
+    || task.objective
+  ) || '';
+}
+
 function taskReviewVerificationFocus(task) {
   const review = task && task.review || {};
   const metadata = task && task.metadata || {};
   const proof = review.proof || metadata.latest_agent_proof || '';
   const lesson = review.lesson || metadata.latest_agent_lesson || '';
   const nextTask = review.next_task || metadata.latest_agent_next_task || '';
-  const objective = task && (task.objective || metadata.task_goal || metadata.goal_objective || metadata.objective) || '';
+  const objective = taskReviewObjective(task);
   const evidenceText = [proof].filter(Boolean).join('\n');
   return {
     objective: taskReviewClip(objective, 260) || null,
@@ -1388,7 +1737,7 @@ function taskReviewSpecificCodexPrompt(task, focus, actor) {
   const title = taskReviewClip(task && task.title, 180);
   const proof = focus && focus.proof_claim ? ` Proof: ${taskReviewClip(focus.proof_claim, 1800)}` : '';
   const commands = focus && focus.commands_to_verify && focus.commands_to_verify.length
-    ? ` Commands: ${focus.commands_to_verify.join(' | ')}.`
+    ? ` Commands: ${taskReviewFormatCommandList(focus.commands_to_verify)}.`
     : '';
   const files = focus && focus.files_to_inspect && focus.files_to_inspect.length
     ? ` Files/artifacts: ${focus.files_to_inspect.join(', ')}.`
@@ -1475,7 +1824,7 @@ function taskReviewChatContract(task, { reviewer = 'codex-review', allowCertifie
   const proof = review.proof || metadata.latest_agent_proof || '';
   const lesson = review.lesson || metadata.latest_agent_lesson || '';
   const nextTask = review.next_task || metadata.latest_agent_next_task || '';
-  const objective = task && (task.objective || metadata.task_goal || metadata.goal_objective || metadata.objective) || '';
+  const objective = taskReviewObjective(task);
   const verificationFocus = taskReviewVerificationFocus(task);
   const actor = reviewActor(reviewer);
   return {
@@ -1501,7 +1850,7 @@ function taskReviewChatContract(task, { reviewer = 'codex-review', allowCertifie
     required_checks: [
       `Run ${`atris task show ${taskRef(task)} --json`} and read the current proof plus dialogue.`,
       verificationFocus.commands_to_verify.length
-        ? `Re-run or inspect these proof commands: ${verificationFocus.commands_to_verify.join(' | ')}.`
+        ? `Re-run or inspect these proof commands: ${taskReviewFormatCommandList(verificationFocus.commands_to_verify)}.`
         : 'Find the concrete verifier command because the proof did not name one.',
       verificationFocus.files_to_inspect.length
         ? `Inspect these named files/artifacts before certifying: ${verificationFocus.files_to_inspect.join(', ')}.`
@@ -1755,6 +2104,17 @@ function taskStatusSummary(projection, { history = false, hasExistingReviewFollo
       doing_count: stream.doing_count,
       review_count: stream.review_count,
       blocked_count: stream.blocked_count,
+      tasks: (stream.tasks || []).map(task => ({
+        id: task.id,
+        title: clipStatusText(task.title, 120),
+        status: task.status,
+        tag: task.tag || null,
+        claimed_by: task.claimed_by || null,
+        assigned_to: task.assigned_to || null,
+        parent_task_id: task.parent_task_id || null,
+        child_task_ids: task.child_task_ids || [],
+        proof: task.proof || null,
+      })),
     })),
     last_updated_at: lastUpdated ? new Date(lastUpdated).toISOString() : null,
   };
@@ -3999,8 +4359,19 @@ function cmdReviewLaneRun(args) {
 function reviewQueueLimit(args, total) {
   if (hasFlag(args, '--all')) return total;
   const raw = flag(args, '--limit');
-  const limit = raw && raw !== true ? Number(raw) : 12;
-  return Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 12;
+  const limit = raw && raw !== true ? Number(raw) : 5;
+  return Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 5;
+}
+
+function reviewQueueVerbose(args) {
+  return hasFlag(args, '--verbose') || hasFlag(args, '--details') || hasFlag(args, '--all');
+}
+
+function reviewGroupTextLimit(args, total) {
+  if (hasFlag(args, '--all')) return total;
+  const raw = flag(args, '--limit');
+  const limit = raw && raw !== true ? Number(raw) : 10;
+  return Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 10;
 }
 
 // Risk order for human attention: named receipts that are missing/failing (0)
@@ -4175,17 +4546,23 @@ function cmdReviews(args) {
       printJson({ ok: true, action: 'review_groups', projection_path: outPath, groups });
       return;
     }
-    console.log(`READY TO LAND — grouped by ${key}`);
-    console.log(`${groups.total_certified} ready to land across ${groups.group_count} ${key} group(s)`);
-    groups.groups.forEach((g, index) => {
+    console.log(`READY FOR APPROVAL — grouped by ${key}`);
+    console.log(`${groups.total_certified} ready for approval across ${groups.group_count} ${key} group(s)`);
+    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(`   land this group: ${g.accept_group_command} --confirm-human-accept --as <you>`);
+      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.`);
+    }
     return;
   }
   const queue = taskReviewQueue(projection, args);
+  const verbose = reviewQueueVerbose(args);
   if (wantsJson(args)) {
     printJson({
       ok: true,
@@ -4195,10 +4572,10 @@ function cmdReviews(args) {
     });
     return;
   }
-  console.log('READY TO LAND');
-  console.log(`${queue.counts.certified} ready to land / ${queue.counts.blocking} need one more check / ${queue.counts.review} total waiting`);
+  console.log('READY FOR APPROVAL');
+  console.log(`${queue.counts.certified} ready for approval / ${queue.counts.blocking} need one more check / ${queue.counts.review} total waiting`);
   if (!queue.items.length) {
-    console.log('Nothing is ready to land.');
+    console.log('Nothing is ready for approval.');
     return;
   }
   queue.items.forEach((item, index) => {
@@ -4216,8 +4593,8 @@ function cmdReviews(args) {
       if (item.result?.saved) console.log(`     Saved: ${item.result.saved}`);
       if (item.landing.decision) console.log(`     Decision: ${item.landing.decision}`);
     }
-    if (item.proof) console.log(`   details: ${item.proof}`);
-    if (item.evidence) {
+    if (verbose && item.proof) console.log(`   details: ${item.proof}`);
+    if (verbose && item.evidence) {
       item.evidence.receipts.forEach((receipt) => {
         const verdict = receipt.verifier_passed === true ? ' verifier:passed'
           : receipt.verifier_passed === false ? ' verifier:FAILED' : '';
@@ -4225,15 +4602,15 @@ function cmdReviews(args) {
       });
       item.evidence.missing.forEach((missingPath) => console.log(`   receipt: ${missingPath} MISSING`));
     }
-    if (item.review_chat_command) console.log(`   /codex: ${item.review_chat_command}`);
+    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(`   land: ${item.accept_command}`);
-    else if (item.blocked_accept_reason) console.log(`   land: blocked (${item.blocked_accept_reason})`);
-    console.log(`   send back: ${item.revise_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 (queue.counts.shown < queue.counts.certified) {
     console.log('');
-    console.log(`Showing ${queue.counts.shown}/${queue.counts.certified}; rerun with --all or --limit ${queue.counts.certified}.`);
+    console.log(`Showing ${queue.counts.shown}/${queue.counts.certified}; rerun with --all for every row or --verbose for proof details.`);
   }
 }
 
@@ -4544,6 +4921,7 @@ function cmdAdd(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const ws = taskDb.workspaceRoot();
+  const operatorTitleWarning = warnIfTaskTitleNeedsOperatorWhy(title);
   // Generation throttle — the named root cause is generation > human-review rate. An AGENT cannot keep
   // minting tasks while a wall of certified-but-unaccepted work waits; that treadmill is what accept-group
   // only drains. Humans and --force bypass. Closes the tap instead of just enlarging the bucket.
@@ -4569,6 +4947,7 @@ function cmdAdd(args) {
       action: 'created',
       task_id: result.id,
       inserted: result.inserted !== false,
+      operator_title_warning: operatorTitleWarning,
       projection_path: outPath,
       task,
     });
@@ -4611,6 +4990,7 @@ function cmdDelegate(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const ws = taskDb.workspaceRoot();
+  const operatorTitleWarning = warnIfTaskTitleNeedsOperatorWhy(title);
   const ownerResolution = resolveFunctionalTaskOwner({
     requestedOwner: requestedOwner && requestedOwner !== true ? requestedOwner : null,
     title,
@@ -4666,6 +5046,7 @@ function cmdDelegate(args) {
       executed_by: executedBy || null,
       via,
       handoff,
+      operator_title_warning: operatorTitleWarning,
       projection_path: outPath,
       task,
     });
@@ -4858,7 +5239,17 @@ function cmdClaim(args) {
   }
 }
 
-function readEndgameAgentAction(root, owner) {
+function liveTaskWithTitle(tasks, title) {
+  const wanted = String(title || '').trim().toLowerCase();
+  if (!wanted) return null;
+  return (tasks || []).find(task => {
+    const taskTitle = String(task.title || task.task || '').trim().toLowerCase();
+    const status = String(task.status || '').toLowerCase();
+    return taskTitle === wanted && !new Set(['done', 'accepted', 'failed']).has(status);
+  }) || null;
+}
+
+function readEndgameAgentAction(root, owner, { tasks = [] } = {}) {
   const todoPath = path.join(root || process.cwd(), 'atris', 'TODO.md');
   if (!fs.existsSync(todoPath)) return null;
   const content = fs.readFileSync(todoPath, 'utf8');
@@ -4869,6 +5260,8 @@ function readEndgameAgentAction(root, owner) {
   if (!slug && !horizon) return null;
   const member = String(owner || DEFAULT_OWNER);
   const taskSeed = buildEndgameTaskSeed({ slug, horizon, owner: member });
+  const existing = liveTaskWithTitle(tasks, taskSeed.title);
+  if (existing) return null;
   return {
     kind: 'create_bounded_endgame_task',
     endgame_slug: slug || null,
@@ -4918,6 +5311,7 @@ function buildEndgameTaskSeed({ slug, horizon, owner }) {
 
 function createEndgameSeedTask(taskDb, db, seed, owner) {
   const taskOwner = String(owner || DEFAULT_OWNER);
+  const operatorTitleWarning = warnIfTaskTitleNeedsOperatorWhy(seed.title);
   const result = taskDb.addTask(db, {
     title: seed.title,
     tag: seed.tag,
@@ -4941,6 +5335,7 @@ function createEndgameSeedTask(taskDb, db, seed, owner) {
     ok: true,
     task_id: result.id,
     inserted: result.inserted !== false,
+    operator_title_warning: operatorTitleWarning,
     note_version: note.event.version,
   };
 }
@@ -4992,7 +5387,7 @@ function cmdNext(args) {
         ? continueWorkCommandForTask(reviewTask, { owner })
         : null;
       const nextAgentAction = handoff.next_action === 'human_accept_waiting'
-        ? readEndgameAgentAction(taskDb.workspaceRoot(), owner)
+        ? readEndgameAgentAction(taskDb.workspaceRoot(), owner, { tasks: projection.tasks || [] })
         : null;
       if (hasFlag(args, '--create-next')) {
         if (!nextAgentAction || !nextAgentAction.task_seed) {
@@ -5014,6 +5409,7 @@ function cmdNext(args) {
             handoff,
             next_agent_action: nextAgentAction,
             note_version: created.note_version,
+            operator_title_warning: created.operator_title_warning || null,
             task: createdTask,
             review_task: reviewTask,
           });
@@ -5042,12 +5438,12 @@ function cmdNext(args) {
       }
       console.log('No open tasks.');
       console.log(handoff.next_action === 'agent_review_again'
-        ? `${taskRef(reviewTask)} needs one more agent check before landing.`
-        : `${taskRef(reviewTask)} is ready to land.`);
+        ? `${taskRef(reviewTask)} needs one more agent check before approval.`
+        : `${taskRef(reviewTask)} is ready for approval.`);
       console.log(handoff.next_action === 'continue_work'
-        ? 'Continue work elsewhere; XP lands after the human lands this task.'
+        ? 'Continue work elsewhere; XP is awarded only after the human approves this task.'
         : handoff.next_action === 'human_accept_waiting'
-        ? (nextAgentAction ? nextAgentAction.message : 'No next agent task is attached; this task is ready to land when the human decides.')
+        ? (nextAgentAction ? nextAgentAction.message : 'No next agent task is attached; this task is ready for human approval.')
         : 'Review this task again before continuing.');
       if (nextAgentAction) console.log(`Command: ${nextAgentAction.command}`);
       if (nextAgentAction && nextAgentAction.task_seed) {
@@ -5092,6 +5488,9 @@ function cmdNext(args) {
   }
   console.log(`next ${taskRef(compactTaskFromProjection(projection, open[0].id))} @${owner}`);
   console.log(open[0].title);
+  const ref = taskRef(compactTaskFromProjection(projection, open[0].id));
+  const { printOperatorNext } = require('../lib/operator-next');
+  printOperatorNext(`atris task step ${ref}`);
 }
 
 function continueWorkForReviewTask(taskDb, db, taskId, { owner = DEFAULT_OWNER } = {}) {
@@ -5135,6 +5534,7 @@ function continueWorkForReviewTask(taskDb, db, taskId, { owner = DEFAULT_OWNER }
     parent_task_id: taskId,
     next_task_id: nextCreated ? nextCreated.id : null,
     created: Boolean(nextCreated && nextCreated.inserted !== false),
+    operator_title_warning: nextCreated ? nextCreated.operator_title_warning || null : null,
     owner: String(owner || DEFAULT_OWNER),
     projection_path: outPath,
     parent,
@@ -5459,9 +5859,9 @@ function cmdShow(args) {
   const owner = task.claimed_by ? ` / ${task.claimed_by}` : '';
   const tag = task.tag ? ` #${task.tag}` : '';
   const statusLabel = task.status === 'review'
-    ? 'READY TO LAND'
+    ? 'READY FOR APPROVAL'
     : task.status === 'done'
-      ? 'LANDED'
+      ? 'DONE'
       : task.status.toUpperCase();
   console.log(`${statusLabel} ${taskRef(task)} v${task.current_version}${owner}${tag}`);
   console.log(task.title);
@@ -5932,13 +6332,80 @@ function buildAcceptHumanResult({ task, proof, nextTask, publicSync }) {
   return { changed, checked, try_next: tryNext };
 }
 
-function renderAcceptLanding({ task, proof, nextTask, publicSync }) {
-  return renderPublicResult(buildAcceptHumanResult({
+function refreshBrainScorecardsAfterAccept(root = process.cwd()) {
+  try {
+    const { recordTaskEpisodeScorecards } = require('../commands/brain');
+    return { ok: true, ...recordTaskEpisodeScorecards({ root }) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error && error.message ? error.message : String(error),
+    };
+  }
+}
+
+function nextMissionRouteAfterAccept(root = process.cwd()) {
+  try {
+    const { selectCodexGoalMission } = require('../commands/mission');
+    const selected = selectCodexGoalMission(root);
+    const mission = selected && selected.mission;
+    if (!mission) return { ok: true, objective: null, route: 'next mission: none' };
+    return {
+      ok: true,
+      mission_id: mission.id,
+      objective: mission.objective,
+      reason: selected.reason,
+      route: `next mission: ${cleanPublicText(mission.objective, 160)}`,
+      command: mission.next_action || `atris mission run ${mission.id}`,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      route: 'next mission: needs refresh',
+      error: error && error.message ? error.message : String(error),
+    };
+  }
+}
+
+function xpLandingText(xpProjection) {
+  if (!xpProjection) return 'XP updated';
+  if (xpProjection.ok === false) return 'XP refresh failed';
+  const candidates = [
+    xpProjection.total_agent_xp,
+    xpProjection.total_xp,
+    xpProjection.summary && xpProjection.summary.total_agent_xp,
+    xpProjection.totals && xpProjection.totals.total_agent_xp,
+  ];
+  const total = candidates.map(Number).find((value) => Number.isFinite(value));
+  return Number.isFinite(total) ? `XP updated (${total} total)` : 'XP updated';
+}
+
+function brainScorecardLandingText(brainScorecards) {
+  if (!brainScorecards) return 'brain scorecards checked';
+  if (brainScorecards.ok === false) return 'brain scorecard refresh failed';
+  const written = Number(brainScorecards.written);
+  return Number.isFinite(written) ? `brain scorecards +${written}` : 'brain scorecards checked';
+}
+
+function buildVisibleAcceptReceipt(result, { xpProjection, brainScorecards, nextMissionRoute } = {}) {
+  const updates = [
+    xpLandingText(xpProjection),
+    brainScorecardLandingText(brainScorecards),
+  ].filter(Boolean);
+  const checked = updates.length ? `${result.checked}; ${updates.join('; ')}` : result.checked;
+  const route = cleanPublicText(nextMissionRoute && nextMissionRoute.route, 180);
+  const tryNext = route ? `${result.try_next}; ${route}` : result.try_next;
+  return { ...result, checked, try_next: tryNext };
+}
+
+function renderAcceptLanding({ task, proof, nextTask, publicSync, xpProjection, brainScorecards, nextMissionRoute }) {
+  const result = buildAcceptHumanResult({
     task,
     proof,
     nextTask,
     publicSync,
-  }));
+  });
+  return renderPublicResult(buildVisibleAcceptReceipt(result, { xpProjection, brainScorecards, nextMissionRoute }));
 }
 
 async function publishAcceptAgentXp(args, actor) {
@@ -6322,7 +6789,7 @@ function taskPageNextAction(task, current, actions, { hasExistingReviewFollowUp
     if (handoff && handoff.next_action === 'human_accept_waiting') {
       return {
         key: 'human_accept_waiting',
-        label: 'Ready to land',
+        label: 'Ready for approval',
         command: null,
         api: null,
         human_accept_command: actions.human_accept_command || null,
@@ -6444,7 +6911,7 @@ function appendTaskReviewChat(taskDb, db, taskId, { reviewer = 'codex-review', d
     throw taskReviewChatError(`not_reviewable_${task.status}`, `review chat requires a task in Review; current status is ${task.status}`, { status: 409, exitCode: 1 });
   }
   if (!taskAllowsReviewChat(task, { allowCertified: true })) {
-    throw taskReviewChatError('agent_certified_continue_work', 'review chat is closed after agent certification; continue other work or land/send back this task', { status: 409, exitCode: 1 });
+    throw taskReviewChatError('agent_certified_continue_work', 'review chat is closed after agent certification; continue other work or wait for human approval/rework on this task', { status: 409, exitCode: 1 });
   }
   const contract = taskReviewChatContract(task, { reviewer: actor, allowCertified: true });
   let event = null;
@@ -6601,8 +7068,8 @@ function readyHandoffForStep(task, proof, lesson, nextTask, agentCertified) {
     career_xp_status: 'pending_human_accept',
     next_action: agentCertified ? certifiedReviewNextAction(nextTask) : 'agent_review_again',
     rule: agentCertified
-      ? 'Double-check complete; ready to keep moving. XP lands only after the human lands the task.'
-      : 'Proof is ready; one more agent check before landing. XP waits for the human.',
+      ? 'Double-check complete; ready to keep moving. XP is awarded only after the human approves the task.'
+      : 'Proof is ready; one more agent check before human approval. XP waits for the human.',
   };
   if (reviewChat) {
     handoff.review_chat_command = reviewChat.command;
@@ -6623,7 +7090,7 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
     const reason = initialHandoffState.next_action === 'continue_work'
       ? 'agent_certified_continue_work'
       : 'agent_certified_waiting_human';
-    throw taskStepError(reason, 'atris task step: ready-to-land rows have no safe agent step; continue other work or land/send back this task', { status: 409, exitCode: 1, page: initialPage });
+    throw taskStepError(reason, 'atris task step: approval-ready rows have no safe agent step; continue other work or wait for human approval/rework on this task', { status: 409, exitCode: 1, page: initialPage });
   }
   let chat = null;
   const message = String(options.message || '').trim();
@@ -6725,7 +7192,7 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
       const reason = handoffState.next_action === 'continue_work'
         ? 'agent_certified_continue_work'
         : 'agent_certified_waiting_human';
-      throw taskStepError(reason, 'atris task step: ready-to-land rows have no safe agent step; continue other work or land/send back this task', { status: 409, exitCode: 1, page: actionPage });
+      throw taskStepError(reason, 'atris task step: approval-ready rows have no safe agent step; continue other work or wait for human approval/rework on this task', { status: 409, exitCode: 1, page: actionPage });
     }
     const reviewed = appendTaskReviewChat(taskDb, db, taskId, { reviewer, dryRun: Boolean(options.dryRun) });
     stepAction = 'review_chat';
@@ -6833,7 +7300,7 @@ function runCurrentTaskStep(taskDb, db, { owner = DEFAULT_OWNER, reviewer = 'cod
   if (nextActionKey === 'human_accept_waiting') {
     const error = taskStepError(
       'agent_certified_waiting_human',
-      'atris task current-step: selected row is ready to land; no agent mutation is safe',
+      'atris task current-step: selected row is ready for human approval; no agent mutation is safe',
       {
         status: 409,
         exitCode: 1,
@@ -7129,6 +7596,7 @@ function cmdFinish(args) {
   const currentTask = taskDb.getTask(db, taskId);
   const actor = String(flag(args, '--as') || DEFAULT_OWNER);
   const proof = proofFlagValue(args);
+  const landing = landingFlags(args);
   const failed = hasFlag(args, '--failed');
   const hasReview = hasFlag(args, '--review') || flag(args, '--lesson') || flag(args, '--next') || flag(args, '--proof') || flag(args, '--reward');
   if (agentProofOnlyMode() && !failed) {
@@ -7165,6 +7633,7 @@ function cmdFinish(args) {
     process.exit(1);
   }
   if (hasReview) {
+    const landingAdvisory = !failed ? warnIfLandingNeedsDayOnePm(landing, currentTask && currentTask.title) : null;
     const result = taskDb.reviewTask(db, {
       id: taskId,
       actor,
@@ -7173,6 +7642,7 @@ function cmdFinish(args) {
       nextTask: typeof flag(args, '--next') === 'string' ? flag(args, '--next') : '',
       proof,
       careerXpEligible: false,
+      landing,
     });
     const nextCreated = createNextTaskIfRequested(taskDb, db, args, currentTask, result.episode.next_task_suggestion);
     const xpProjection = refreshCareerXpAfterReview(result);
@@ -7186,6 +7656,7 @@ function cmdFinish(args) {
         reward: result.episode.reward.value,
         episode: result.episode,
         xp_projection: xpProjection,
+        landing_advisory: landingAdvisory,
         next_task_id: nextCreated ? nextCreated.id : null,
         projection_path: outPath,
         task: compactTaskFromProjection(projection, taskId),
@@ -7280,6 +7751,7 @@ function cmdReady(args) {
     console.error(`ready failed: ${result.reason}`);
     process.exit(1);
   }
+  const landingAdvisory = warnIfLandingNeedsDayOnePm(landing, result.row && result.row.title);
   const { projection, outPath } = writeDefaultProjection(taskDb, db);
   const agentCertified = result.event.payload.agent_certified === true;
   const projectionTask = taskFromProjection(projection, taskId)
@@ -7296,8 +7768,8 @@ function cmdReady(args) {
     career_xp_status: 'pending_human_accept',
     next_action: agentCertified ? certifiedReviewNextAction(nextTaskInput.nextTask) : 'agent_review_again',
     rule: agentCertified
-      ? 'Double-check complete; ready to keep moving. XP lands only after the human lands the task.'
-      : 'Proof is ready; one more agent check before landing. XP waits for the human.',
+      ? 'Double-check complete; ready to keep moving. XP is awarded only after the human approves the task.'
+      : 'Proof is ready; one more agent check before human approval. XP waits for the human.',
   };
   if (reviewChat) {
     handoff.review_chat_command = reviewChat.command;
@@ -7321,13 +7793,14 @@ function cmdReady(args) {
       agent_certified: agentCertified,
       handoff,
       result_trace: resultTrace,
+      landing_advisory: landingAdvisory,
       ...(nextTaskInput.ignored ? { review_next_task_ignored: nextTaskInput.ignored } : {}),
       projection_path: outPath,
       task: compactTaskFromProjection(projection, taskId),
     });
     return;
   }
-  console.log(`ready to land ${taskRef(compactTaskFromProjection(projection, taskId))} v${result.event.version}`);
+  console.log(`ready for approval ${taskRef(compactTaskFromProjection(projection, taskId))} v${result.event.version}`);
   if (resultTrace) console.log('Result trace recorded.');
   console.log(handoff.rule);
   for (const hint of policyHints) {
@@ -7412,9 +7885,12 @@ async function cmdAccept(args) {
   });
   const xpProjection = refreshCareerXpAfterReview(reviewed);
   const { projection, outPath } = writeDefaultProjection(taskDb, db);
+  const workspaceRoot = projection.workspace_root || process.cwd();
+  const brainScorecards = refreshBrainScorecardsAfterAccept(workspaceRoot);
+  const nextMissionRoute = nextMissionRouteAfterAccept(workspaceRoot);
   // Inform the gate, never block it: show what the receipts named in the proof
   // actually say so the accepting human isn't trusting prose.
-  const evidence = extractReceiptEvidence(proof, projection.workspace_root || process.cwd());
+  const evidence = extractReceiptEvidence(proof, workspaceRoot);
   const publicSync = hasFlag(args, '--public') ? await publishAcceptAgentXp(args, actor) : null;
   if (wantsJson(args)) {
     printJson({
@@ -7427,6 +7903,8 @@ async function cmdAccept(args) {
       evidence,
       public_sync: publicSync,
       xp_projection: xpProjection,
+      brain_scorecards: brainScorecards,
+      next_mission_route: nextMissionRoute,
       projection_path: outPath,
       task: compactTaskFromProjection(projection, taskId),
     });
@@ -7438,6 +7916,9 @@ async function cmdAccept(args) {
     proof,
     nextTask,
     publicSync,
+    xpProjection,
+    brainScorecards,
+    nextMissionRoute,
   }));
   if (publicSync && !publicSync.ok) process.exitCode = 1;
 }
@@ -7481,13 +7962,165 @@ function acceptReviewTask(taskDb, db, taskId, { actor, proof, reward, lesson = '
   return { ok: true, reviewed };
 }
 
+// Second-actor certification for proof-backed Review rows whose proof names a
+// runnable, allowlisted check. Re-running that check as a distinct actor IS
+// the independent verification the certification gate asks for — the row
+// becomes certified and autoland can land it on the same heartbeat. Rows in
+// denied lanes, without a runnable check, or already certified keep their
+// existing paths (review chats, human accept).
+function certifyVerifyCandidate(task) {
+  const metadata = task.metadata || {};
+  const review = task.review || {};
+  const recorded = typeof metadata.verify === 'string' && metadata.verify.trim() ? [metadata.verify.trim()] : [];
+  const proof = String(review.proof || metadata.latest_agent_proof || '');
+  for (const raw of [...recorded, ...taskReviewEvidenceCommands(proof)]) {
+    // The evidence extractor can keep trailing prose ("git diff --check. Evidence
+    // inspected: ..."); try the full clause, then the first sentence of it.
+    for (const candidate of [raw, raw.split(/\.(?:\s|$)/)[0]].map((c) => String(c || '').trim())) {
+      if (candidate && parseVerifyCommand(candidate).ok) return candidate;
+    }
+  }
+  return null;
+}
+
+function stampCertifyVerifyMetadata(taskDb, db, taskId, actor, verify) {
+  const row = taskDb.getTask(db, taskId);
+  if (!row) return;
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  metadata.verify = metadata.verify || verify;
+  metadata.certified_verified_at = new Date().toISOString();
+  metadata.certified_verified_by = actor;
+  db.prepare(`
+    UPDATE tasks
+       SET metadata = ?,
+           updated_at = ?
+     WHERE id = ?
+  `).run(JSON.stringify(metadata), Date.now(), taskId);
+}
+
+function cmdCertifyVerified(args) {
+  const dryRun = hasFlag(args, '--dry-run');
+  const asJson = wantsJson(args);
+  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;
+
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const { projection } = writeDefaultProjection(taskDb, db);
+  const candidates = (projection.tasks || [])
+    .filter((t) => t && t.status === 'review')
+    .sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0))
+    .slice(0, max);
+  const results = [];
+  for (const item of candidates) {
+    const fullProjection = enrichTaskProjection(taskDb.taskProjection(db, { taskId: item.id }));
+    const task = fullProjection.tasks[0] || null;
+    if (!task) {
+      results.push({ ref: item.display_id || item.id, action: 'skipped', reason: 'task_not_found' });
+      continue;
+    }
+    const ref = task.display_id || task.legacy_ref || task.id;
+    const metadata = task.metadata || {};
+    const review = task.review || {};
+    if (task.status !== 'review') {
+      results.push({ ref, action: 'skipped', reason: 'not_in_review' });
+      continue;
+    }
+    const approval = String(review.approval_status || metadata.approval_status || 'pending').toLowerCase();
+    if (approval !== 'pending') {
+      results.push({ ref, action: 'skipped', reason: `approval_${approval}` });
+      continue;
+    }
+    const tag = String(task.tag || '').toLowerCase();
+    if (DENIED_TAGS.has(tag)) {
+      results.push({ ref, action: 'skipped', reason: `denied_tag_${tag}` });
+      continue;
+    }
+    // Skip only rows the accept lane can already land, or rows blocked by
+    // something an executed second-actor check cannot cure. A row with two
+    // passes from ONE actor is exactly what this command exists to cure —
+    // "certified" alone is not landable.
+    const evaluation = evaluateAutoAccept(task, { strictVerify: false });
+    if (evaluation.eligible) {
+      results.push({ ref, action: 'skipped', reason: 'already_landable' });
+      continue;
+    }
+    const curable = ['not_agent_certified', 'needs_second_reviewer_or_third_pass', 'insufficient_review_passes'];
+    if (!curable.includes(evaluation.reason)) {
+      results.push({ ref, action: 'skipped', reason: evaluation.reason });
+      continue;
+    }
+    const verify = certifyVerifyCandidate(task);
+    if (!verify) {
+      results.push({ ref, action: 'skipped', reason: 'no_runnable_check_in_proof' });
+      continue;
+    }
+    if (dryRun) {
+      results.push({ ref, action: 'would_certify', verify });
+      continue;
+    }
+    const run = runVerifyCommand(verify, task.workspace_root || process.cwd());
+    if (!run.ok) {
+      results.push({ ref, action: 'verify_failed', reason: run.reason, verify });
+      continue;
+    }
+    const builderProof = String(review.proof || metadata.latest_agent_proof || '').slice(0, 200);
+    const readied = taskDb.readyTask(db, {
+      id: task.id,
+      actor,
+      proof: `Second-actor check: \`${verify}\` re-run by ${actor}, exited 0. Builder proof inspected: ${builderProof}`,
+      lesson: '',
+      nextTask: '',
+    });
+    if (!readied.ready) {
+      results.push({ ref, action: 'certify_failed', reason: readied.reason, verify });
+      continue;
+    }
+    stampCertifyVerifyMetadata(taskDb, db, task.id, actor, verify);
+    const certifiedNow = readied.event?.payload?.agent_certified === true;
+    results.push({ ref, action: certifiedNow ? 'certified' : 'pass_recorded', verify });
+  }
+  const { outPath } = writeDefaultProjection(taskDb, db);
+  const certified = results.filter((r) => r.action === 'certified').length;
+  const payload = {
+    ok: true,
+    action: dryRun ? 'certify_verified_dry_run' : 'certify_verified',
+    actor,
+    certified,
+    would_certify: results.filter((r) => r.action === 'would_certify').length,
+    skipped: results.filter((r) => r.action === 'skipped').length,
+    failed: results.filter((r) => r.action === 'verify_failed' || r.action === 'certify_failed').length,
+    results,
+    projection_path: outPath,
+  };
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else if (results.length === 0) {
+    console.log('certify-verified: no review rows to consider.');
+  } else {
+    for (const r of results) {
+      console.log(`${r.action.padEnd(14)} ${r.ref}${r.verify ? `  \`${r.verify}\`` : ''}${r.reason ? `  (${r.reason})` : ''}`);
+    }
+    console.log(`certified ${certified}; humans keep denied lanes and rows without a runnable check.`);
+  }
+  return payload;
+}
+
 function cmdAutoAcceptCertified(args) {
   const dryRun = hasFlag(args, '--dry-run');
   const strictVerify = hasFlag(args, '--strict-verify');
   const actorFlag = flag(args, '--as');
-  const actor = String(actorFlag || 'auto-accept-certified');
   const hasHumanActor = validHumanActorFlag(actorFlag);
   const confirmedHumanAccept = hasFlag(args, '--confirm-human-accept');
+  // Standing owner authorization: when the autoland policy is on for this
+  // workspace, live accepts run as the owner who flipped it, no per-run
+  // confirmation needed. See lib/autoland.js and 'atris autoland'.
+  const dryRunEarly = hasFlag(args, '--dry-run');
+  const policyAuth = (!dryRunEarly && !confirmedHumanAccept)
+    ? require('../lib/autoland').liveAcceptAuthorization()
+    : { ok: false };
+  const actor = String(actorFlag || (policyAuth.ok ? policyAuth.actor : 'auto-accept-certified'));
   const limitRaw = flag(args, '--limit');
   const max = limitRaw && limitRaw !== true ? Math.max(1, Number(limitRaw) || 12) : 12;
   const parsedReward = parseAcceptReward(flag(args, '--reward'));
@@ -7495,14 +8128,14 @@ function cmdAutoAcceptCertified(args) {
     console.error('atris task auto-accept-certified: reward must be a positive number');
     process.exit(2);
   }
-  if (!dryRun && !confirmedHumanAccept) {
+  if (!dryRun && !confirmedHumanAccept && !policyAuth.ok) {
     failTask(
       'atris task auto-accept-certified',
       'human_accept_confirmation_required',
-      'live auto-accept requires --confirm-human-accept --as <human>; use --dry-run to preview',
+      'live auto-accept requires --confirm-human-accept --as <human>, or the owner flips the standing policy with atris autoland on; use --dry-run to preview',
     );
   }
-  if (!dryRun && !hasHumanActor) {
+  if (!dryRun && !hasHumanActor && !policyAuth.ok) {
     failTask(
       'atris task auto-accept-certified',
       'human_actor_required',
@@ -7707,7 +8340,7 @@ function cmdReview(args) {
       version: result.event.version,
       reward: result.episode.reward.value,
       episode: result.episode,
-      xp_projection: xpProjection,
+      xp_projection: compactCareerXpProjection(xpProjection),
       next_task_id: nextCreated ? nextCreated.id : null,
       ...(nextTaskInput.ignored ? { review_next_task_ignored: nextTaskInput.ignored } : {}),
       projection_path: outPath,
@@ -8080,6 +8713,40 @@ function markdownRowsForRender(taskDb, existingTodoPath, rows, refRows) {
   return out;
 }
 
+function taskRenderStatusCounts(rows) {
+  const counts = {
+    backlog: 0,
+    in_progress: 0,
+    review: 0,
+    blocked: 0,
+    done: 0,
+    total: 0,
+  };
+  for (const row of Array.isArray(rows) ? rows : []) {
+    counts.total += 1;
+    if (row.status === 'open') counts.backlog += 1;
+    else if (row.status === 'claimed') counts.in_progress += 1;
+    else if (row.status === 'review') counts.review += 1;
+    else if (row.status === 'failed') counts.blocked += 1;
+    else if (row.status === 'done') counts.done += 1;
+  }
+  return counts;
+}
+
+function taskRenderCountLabel(count) {
+  return count === 0 ? 'empty' : String(count);
+}
+
+function taskRenderSummaryLine(counts) {
+  return [
+    `Backlog: ${taskRenderCountLabel(counts.backlog)}`,
+    `In Progress: ${taskRenderCountLabel(counts.in_progress)}`,
+    `Review: ${taskRenderCountLabel(counts.review)}`,
+    `Blocked: ${taskRenderCountLabel(counts.blocked)}`,
+    `Done saved: ${taskRenderCountLabel(counts.done)}`,
+  ].join('; ');
+}
+
 function cmdRender(args) {
   const out = flag(args, '--out') || path.join('atris', 'TODO.md');
   const all = hasFlag(args, '--all');
@@ -8103,6 +8770,7 @@ function cmdRender(args) {
   if (endgameSection) preservedSections.push(endgameSection);
   const markdownRows = markdownRowsForRender(taskDb, outPath, rows, refRows);
   const rowsToRender = [...rows, ...markdownRows];
+  const statusCounts = taskRenderStatusCounts(rowsToRender);
   const markdown = taskDb.renderTodoMarkdown(rowsToRender, { doneLimit, failedLimit, refRows, preservedSections });
   fs.mkdirSync(path.dirname(outPath), { recursive: true });
   fs.writeFileSync(outPath, markdown, 'utf8');
@@ -8111,11 +8779,14 @@ function cmdRender(args) {
       ok: true,
       action: 'rendered',
       count: rowsToRender.length,
+      status_counts: statusCounts,
+      backlog_empty: statusCounts.backlog === 0,
       path: outPath,
     });
     return;
   }
-  console.log(`rendered ${rowsToRender.length} task${rowsToRender.length === 1 ? '' : 's'} -> ${outPath}`);
+  console.log(`rendered TODO.md -> ${outPath}`);
+  console.log(taskRenderSummaryLine(statusCounts));
 }
 
 function cmdSync(args) {
@@ -8783,13 +9454,14 @@ async function handleTaskApi(req, res, taskDb, db) {
     const body = await readJsonBody(req);
     const title = String(body.title || '').trim();
     if (!title) return sendJson(res, 400, { ok: false, reason: 'missing_title', detail: 'title required' });
+    const operatorTitleWarning = warnIfTaskTitleNeedsOperatorWhy(title);
     const result = taskDb.addTask(db, {
       title,
       tag: body.tag ? String(body.tag) : 'tasks',
       workspaceRoot: taskDb.workspaceRoot(),
     });
     const { projection, outPath } = writeDefaultProjection(taskDb, db);
-    return sendJson(res, 200, { ok: true, action: 'created', task_id: result.id, projection_path: outPath, task: taskFromProjection(projection, result.id) });
+    return sendJson(res, 200, { ok: true, action: 'created', task_id: result.id, operator_title_warning: operatorTitleWarning, projection_path: outPath, task: taskFromProjection(projection, result.id) });
   }
   if (req.method === 'POST' && url.pathname === '/api/tasks/clear-plan') {
     const body = await readJsonBody(req);
@@ -9296,6 +9968,8 @@ async function run(args) {
     case 'auto-accept-certified':
     case 'auto-accept':
       return cmdAutoAcceptCertified(rest);
+    case 'certify-verified':
+      return cmdCertifyVerified(rest);
     case 'accept-group':
       return cmdAcceptGroup(rest);
     case 'revise': return cmdRevise(rest);