atris 3.31.0 → 3.33.3

package/commands/task.js

@@ -8,13 +8,22 @@ 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 {
+  TASK_INSPECT_FIELDS,
+  readFieldsFlag,
+  stripInspectArgs,
+  validateFields,
+  inspectTextLines,
+  buildInspectPayload,
+} = require('../lib/inspect-fields');
 
 const DEFAULT_OWNER = process.env.ATRIS_AGENT_ID
   || process.env.USER
@@ -90,13 +99,22 @@ 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)
 
   atris task                              Show the task desk
   atris task new "<title>"                Create a task
-  atris task next [--create-next]         Claim/show next open task; optionally create the generated Endgame fallback
+  atris task next [--tag <tag>] [--create-next]
+                                           Claim/show next open task; optionally create the generated Endgame fallback
   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
@@ -113,6 +131,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
@@ -128,6 +148,7 @@ atris task - durable local task state (SQLite, gitignored)
   atris task day [--json]                  Show today's owner-grouped task list
   atris task list [--all] [--status <s>]   List tasks (default: this workspace)
   atris task claim <id> [--as <owner>]     Atomic claim
+  atris task release <id> [--as <owner>]   Release your own mistaken claim back to open
   atris task capabilities [--json]         Read-only task CLI/API capability contract
   atris task capabilities-check [--json]   Verify task capability contract conformance
   atris task review-lane-drain [--json]    Pick next safe Review-lane agent action
@@ -143,6 +164,8 @@ atris task - durable local task state (SQLite, gitignored)
                                            review-state lanes: needs-agent, continue-work, human-accept-waiting, certified
   atris task note <id> "<message>"         Append dialogue/context to a task
   atris task show <id> [--json]            Show a task card + dialogue
+  atris task inspect <id> --fields review,status,title [--json]
+                                           Field-selectable task state (review metadata, status, title, owner, tag)
   atris task page <id> [--json]            Show the one-task page contract
   atris task step <id> [--json]            Refine chat, then advance one safe Plan/Do/Review step
   atris task done <id> --proof "..."       Mark complete with proof
@@ -374,13 +397,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;
@@ -597,18 +643,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(),
@@ -619,10 +666,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;
   }
@@ -1069,6 +1117,50 @@ function taskReviewSummary(task) {
   return reviewSummaryWithVerificationChat(task, review);
 }
 
+function taskReviewInspectMetadata(task) {
+  const review = task.review || taskReviewSummary(task);
+  if (!review) return null;
+  return {
+    approval_status: review.approval_status || null,
+    agent_certified: review.agent_certified === true,
+    agent_review_pass_count: review.agent_review_pass_count || null,
+    agent_certification_policy: review.agent_certification_policy || null,
+    summary: review.summary || null,
+    proof: review.proof || null,
+    lesson: review.lesson || null,
+    next_task: review.next_task || null,
+    human_revision_count: review.human_revision_count || null,
+    human_revision_note: review.human_revision_note || null,
+    reward: review.reward ?? null,
+  };
+}
+
+function taskInspectFieldValues(task, fields) {
+  const values = {};
+  for (const field of fields) {
+    switch (field) {
+      case 'status':
+        values.status = task.status || null;
+        break;
+      case 'title':
+        values.title = task.title || null;
+        break;
+      case 'claimed_by':
+        values.claimed_by = task.claimed_by || null;
+        break;
+      case 'tag':
+        values.tag = task.tag || null;
+        break;
+      case 'review':
+        values.review = taskReviewInspectMetadata(task);
+        break;
+      default:
+        break;
+    }
+  }
+  return values;
+}
+
 function reviewSummaryWithVerificationChat(task, review) {
   if (!review || task.status !== 'review' || review.approval_status !== 'pending') return review;
   const verifierTask = taskWithReviewEvidence(task, {
@@ -3168,6 +3260,11 @@ function formatTaskQueueScope(scope = {}) {
     .join(' ');
 }
 
+function noOpenTasksMessage(scope = {}) {
+  const scopeText = formatTaskQueueScope(scope);
+  return scopeText ? `No open tasks for ${scopeText}.` : 'No open tasks.';
+}
+
 function taskQueueContract(projection, { reviewer = 'codex-review', limit = 8, scope = {}, hasExistingReviewFollowUp = null, hasPendingReviewChat = null, excludeTaskIds = null } = {}) {
   const normalizedScope = normalizeTaskQueueScope(scope);
   const tasks = filterTasksByScope(sortTasksNewestFirst(projection.tasks || []), normalizedScope, { hasExistingReviewFollowUp });
@@ -4885,6 +4982,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.
@@ -4910,6 +5008,7 @@ function cmdAdd(args) {
       action: 'created',
       task_id: result.id,
       inserted: result.inserted !== false,
+      operator_title_warning: operatorTitleWarning,
       projection_path: outPath,
       task,
     });
@@ -4952,6 +5051,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,
@@ -5007,6 +5107,7 @@ function cmdDelegate(args) {
       executed_by: executedBy || null,
       via,
       handoff,
+      operator_title_warning: operatorTitleWarning,
       projection_path: outPath,
       task,
     });
@@ -5135,20 +5236,24 @@ function cmdHome(args) {
 function cmdList(args) {
   const all = hasFlag(args, '--all');
   const status = flag(args, '--status');
+  const scope = taskQueueScopeFromArgs(args);
+  const scoped = !taskQueueScopeIsEmpty(scope);
   const taskDb = getTaskDb();
   const db = taskDb.open();
-  const rows = taskDb.listTasks(db, {
+  const rawRows = taskDb.listTasks(db, {
     workspaceRoot: all ? null : taskDb.workspaceRoot(),
     status: typeof status === 'string' ? status : null,
-    limit: 200,
+    limit: scoped ? null : 200,
   });
+  const rows = filterTasksByScope(rawRows, scope);
   const displayRows = taskDb.withTaskDisplayRefs(rows, workspaceRefRows(taskDb, db, all));
   if (wantsJson(args)) {
-    printJson({ ok: true, action: 'list', tasks: displayRows });
+    printJson({ ok: true, action: 'list', scope: normalizeTaskQueueScope(scope), tasks: displayRows });
     return;
   }
   if (rows.length === 0) {
-    console.log('(no tasks)');
+    const scopeText = formatTaskQueueScope(scope);
+    console.log(scopeText ? `(no tasks for ${scopeText})` : '(no tasks)');
     return;
   }
   for (const r of displayRows) {
@@ -5184,19 +5289,68 @@ function cmdClaim(args) {
     }
     console.log(`claimed ${taskRef(compactTaskFromProjection(projection, taskId))} as ${owner}`);
   } else {
+    const recoveryCommand = result.reason === 'already_claimed' && result.claimed_by
+      ? `atris task release ${id} --as ${result.claimed_by}`
+      : null;
     if (wantsJson(args)) {
       printJson({
         ok: false,
         command: 'atris task claim',
         reason: result.reason,
         claimed_by: result.claimed_by || null,
+        recovery_command: recoveryCommand,
         detail: `claim failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`,
       });
       process.exit(1);
     }
     console.error(`claim failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`);
+    if (recoveryCommand) console.error(`Recovery: ${recoveryCommand}`);
+    process.exit(1);
+  }
+}
+
+function cmdRelease(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) {
+    failTask('atris task release', 'missing_id', 'id required');
+  }
+  const owner = flag(args, '--as') || DEFAULT_OWNER;
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, id, 'atris task release');
+  const result = taskDb.releaseTask(db, { id: taskId, actor: String(owner) });
+  if (result.released) {
+    const { projection, outPath } = writeDefaultProjection(taskDb, db);
+    const task = compactTaskFromProjection(projection, taskId);
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: 'released',
+        task_id: taskId,
+        owner: String(owner),
+        projection_path: outPath,
+        task,
+        event_version: result.event && result.event.version || null,
+      });
+      return;
+    }
+    console.log(`released ${taskRef(task)} from ${owner}`);
+    console.log(`Next: atris task next --as ${owner}`);
+    return;
+  }
+  if (wantsJson(args)) {
+    printJson({
+      ok: false,
+      command: 'atris task release',
+      reason: result.reason,
+      claimed_by: result.claimed_by || null,
+      detail: `release failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`,
+    });
     process.exit(1);
   }
+  console.error(`release failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`);
+  process.exit(1);
 }
 
 function liveTaskWithTitle(tasks, title) {
@@ -5271,6 +5425,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,
@@ -5294,20 +5449,23 @@ 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,
   };
 }
 
 function cmdNext(args) {
   const owner = flag(args, '--as') || DEFAULT_OWNER;
+  const scope = taskQueueScopeFromArgs(args);
+  const scoped = !taskQueueScopeIsEmpty(scope);
   const taskDb = getTaskDb();
   const db = taskDb.open();
-  const claimed = taskDb.listTasks(db, {
+  const claimed = filterTasksByScope(taskDb.listTasks(db, {
     workspaceRoot: taskDb.workspaceRoot(),
     status: 'claimed',
     claimedBy: String(owner),
-    limit: 1,
-  });
+    limit: scoped ? null : 1,
+  }), scope);
   if (claimed.length) {
     const { projection, outPath } = writeDefaultProjection(taskDb, db);
     if (wantsJson(args)) {
@@ -5316,6 +5474,7 @@ function cmdNext(args) {
         action: 'current',
         task_id: claimed[0].id,
         owner: String(owner),
+        scope: normalizeTaskQueueScope(scope),
         projection_path: outPath,
         task: compactTaskFromProjection(projection, claimed[0].id),
       });
@@ -5326,14 +5485,14 @@ function cmdNext(args) {
     return;
   }
   const reviewProjection = writeDefaultProjection(taskDb, db);
-  const reviewTasks = (reviewProjection.projection.tasks || [])
+  const reviewTasks = filterTasksByScope(reviewProjection.projection.tasks || [], scope)
     .map(compactTaskForStatus)
     .filter(task => task && task.review && task.review.handoff);
-  const open = taskDb.listTasks(db, {
+  const open = filterTasksByScope(taskDb.listTasks(db, {
     workspaceRoot: taskDb.workspaceRoot(),
     status: 'open',
-    limit: 1,
-  });
+    limit: scoped ? null : 1,
+  }), scope);
   if (!open.length) {
     const { projection, outPath } = reviewProjection;
     const reviewTask = reviewTasks.find(task => task.review.handoff.next_action === 'agent_review_again')
@@ -5363,10 +5522,12 @@ function cmdNext(args) {
             action: 'created_next',
             task_id: created.task_id,
             owner: String(owner),
+            scope: normalizeTaskQueueScope(scope),
             projection_path: createdOutPath,
             handoff,
             next_agent_action: nextAgentAction,
             note_version: created.note_version,
+            operator_title_warning: created.operator_title_warning || null,
             task: createdTask,
             review_task: reviewTask,
           });
@@ -5384,6 +5545,7 @@ function cmdNext(args) {
           action: handoff.next_action,
           task_id: handoff.next_action === 'continue_work' ? null : reviewTask.id,
           owner: String(owner),
+          scope: normalizeTaskQueueScope(scope),
           projection_path: outPath,
           handoff,
           next_agent_action: nextAgentAction,
@@ -5393,7 +5555,7 @@ function cmdNext(args) {
         });
         return;
       }
-      console.log('No open tasks.');
+      console.log(noOpenTasksMessage(scope));
       console.log(handoff.next_action === 'agent_review_again'
         ? `${taskRef(reviewTask)} needs one more agent check before approval.`
         : `${taskRef(reviewTask)} is ready for approval.`);
@@ -5418,11 +5580,12 @@ function cmdNext(args) {
         action: 'none',
         task_id: null,
         owner: String(owner),
+        scope: normalizeTaskQueueScope(scope),
         projection_path: outPath,
       });
       return;
     }
-    console.log('No open tasks.');
+    console.log(noOpenTasksMessage(scope));
     console.log('Start with: atris task new "..."');
     return;
   }
@@ -5438,6 +5601,7 @@ function cmdNext(args) {
       action: 'next',
       task_id: open[0].id,
       owner: String(owner),
+      scope: normalizeTaskQueueScope(scope),
       projection_path: outPath,
       task: compactTaskFromProjection(projection, open[0].id),
     });
@@ -5445,6 +5609,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 } = {}) {
@@ -5488,6 +5655,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,
@@ -5790,6 +5958,40 @@ function cmdClearPlan(args) {
   console.log(`clear-plan moved ${result.cleared.length} task${result.cleared.length === 1 ? '' : 's'} to Backlog`);
 }
 
+function cmdInspect(args) {
+  const parsed = readFieldsFlag(args, '--fields');
+  if (!parsed || parsed.error) {
+    failTask('atris task inspect', 'missing_fields', parsed?.error || 'Usage: atris task inspect <id> --fields review,status,title [--json]');
+  }
+  const fieldError = validateFields(parsed.fields, TASK_INSPECT_FIELDS, 'task');
+  if (fieldError) failTask('atris task inspect', 'unknown_fields', fieldError);
+  const ref = stripInspectArgs(args)[0] || '';
+  if (!ref) {
+    failTask('atris task inspect', 'missing_id', 'Usage: atris task inspect <id> --fields review,status,title [--json]');
+  }
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, ref, 'atris task inspect');
+  const projection = enrichTaskProjection(taskDb.taskProjection(db, { taskId }));
+  const task = projection.tasks[0];
+  if (!task) {
+    failTask('atris task inspect', 'not_found', `task not found: ${ref}`, 1);
+  }
+  const values = taskInspectFieldValues(task, parsed.fields);
+  const payload = buildInspectPayload({
+    action: 'task_inspect',
+    idKey: 'task_id',
+    idValue: task.id,
+    fields: parsed.fields,
+    values,
+  });
+  if (wantsJson(args)) {
+    printJson(payload);
+    return;
+  }
+  for (const line of inspectTextLines(parsed.fields, values)) console.log(line);
+}
+
 function cmdShow(args) {
   const pos = positional(args);
   const id = pos[0];
@@ -7549,6 +7751,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) {
@@ -7585,6 +7788,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,
@@ -7593,6 +7797,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);
@@ -7606,6 +7811,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),
@@ -7700,6 +7906,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)
@@ -7741,6 +7948,7 @@ 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),
@@ -7909,6 +8117,151 @@ 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');
@@ -9256,13 +9609,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);
@@ -9713,6 +10067,9 @@ async function run(args) {
       return cmdClearPlan(rest);
     case 'claim':  return cmdClaim(rest);
     case 'start':  return cmdClaim(rest);
+    case 'release':
+    case 'unclaim':
+      return cmdRelease(rest);
     case 'current':
     case 'select':
       return cmdCurrent(rest);
@@ -9758,6 +10115,7 @@ async function run(args) {
     case 'note':   return cmdNote(rest);
     case 'say':    return cmdNote(rest);
     case 'show':   return cmdShow(rest);
+    case 'inspect': return cmdInspect(rest);
     case 'page':   return cmdPage(rest);
     case 'step':   return cmdStep(rest);
     case 'review-chat':
@@ -9769,6 +10127,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);