atris 3.69.0 → 3.71.0

package/commands/report.js

@@ -88,22 +88,38 @@ function withWorkspaceCwd(root, fn) {
   }
 }
 
-function buildLandings(root, cutoff) {
+// A done task is only a landing when its stored git proof says so. Done
+// without that proof is reported separately, never counted as landed.
+function buildDoneTasks(root, cutoff) {
   const tasks = readProjection(root) || [];
   return tasks
     .filter(task => task && task.status === 'done' && Number(timestampMs(task.done_at)) >= cutoff)
     .sort((a, b) => Number(timestampMs(b.done_at) || 0) - Number(timestampMs(a.done_at) || 0))
     .map((task) => {
       const id = inlineText(task.display_id || task.task_ref || task.id, 'task');
+      const landing = task.metadata && typeof task.metadata.landing === 'object' ? task.metadata.landing : null;
       return {
         id,
         title: inlineText(task.title, 'untitled task'),
         done_at: task.done_at || null,
         source: `task ${id}`,
+        landed: landing?.status === 'landed',
+        landing_status: landing?.status || 'unchecked',
+        landing_reason: landing?.reason || (landing ? '' : 'no landing proof recorded'),
       };
     });
 }
 
+function buildLandings(root, cutoff) {
+  return buildDoneTasks(root, cutoff).filter(task => task.landed);
+}
+
+function landingStatusText(task) {
+  const status = String(task?.landing_status || 'unchecked').replace(/_/g, ' ');
+  const reason = String(task?.landing_reason || '').replace(/_/g, ' ');
+  return reason ? `${status}, ${reason}` : status;
+}
+
 function buildJournalCompletions(root, days, now) {
   return withWorkspaceCwd(root, () => {
     const completions = [];
@@ -198,13 +214,16 @@ function buildWeekReportData(root = process.cwd(), { days = DEFAULT_DAYS, now =
   const windowDays = asWindowDays(days);
   const nowMs = timestampMs(now) || Date.now();
   const cutoff = nowMs - windowDays * DAY_MS;
-  const landings = buildLandings(root, cutoff);
+  const done = buildDoneTasks(root, cutoff);
+  const landings = done.filter(task => task.landed);
+  const unproven = done.filter(task => !task.landed);
   const completions = buildJournalCompletions(root, windowDays, nowMs);
   const xp = buildXp(root, cutoff);
   return {
-    empty: landings.length === 0 && completions.length === 0 && xp.total <= 0,
+    empty: done.length === 0 && completions.length === 0 && xp.total <= 0,
     days: windowDays,
     landings,
+    unproven,
     completions,
     xp,
   };
@@ -212,11 +231,13 @@ function buildWeekReportData(root = process.cwd(), { days = DEFAULT_DAYS, now =
 
 function renderWeekReport(data) {
   const landings = Array.isArray(data?.landings) ? data.landings : [];
+  const unproven = Array.isArray(data?.unproven) ? data.unproven : [];
   const completions = Array.isArray(data?.completions) ? data.completions : [];
   const xp = data?.xp && typeof data.xp === 'object' ? data.xp : { total: 0, receipts: [] };
   const receipts = Array.isArray(xp.receipts) ? xp.receipts : [];
+  const unprovenHeader = unproven.length ? `, ${unproven.length} done but not proven landed` : '';
   const lines = [
-    `week in review: ${landings.length} landed, ${completions.length} completions, ${formatXp(xp.total)} xp`,
+    `week in review: ${landings.length} landed${unprovenHeader}, ${completions.length} completions, ${formatXp(xp.total)} xp`,
   ];
 
   if (data?.empty) {
@@ -227,12 +248,20 @@ function renderWeekReport(data) {
 
   if (landings.length) {
     lines.push('');
-    lines.push(`landings: ${landings.length} tasks, known from task projection`);
+    lines.push(`landings: ${landings.length} tasks, proven by a git landing check`);
     for (const landing of landings) {
       lines.push(`- landed: ${inlineText(landing.title)} | size: 1 task | know: ${inlineText(landing.source || landing.id, 'task')}`);
     }
   }
 
+  if (unproven.length) {
+    lines.push('');
+    lines.push(`done but not proven landed: ${unproven.length} tasks, git could not confirm the work reached the target`);
+    for (const task of unproven) {
+      lines.push(`- done: ${inlineText(task.title)} | landing: ${inlineText(landingStatusText(task))} | know: ${inlineText(task.source || task.id, 'task')}`);
+    }
+  }
+
   if (completions.length) {
     lines.push('');
     lines.push(`journal completions: ${completions.length} items, known from daily logs`);
@@ -258,6 +287,7 @@ function panelRows(rows, emptyTitle, emptySub) {
 
 function buildWeekReportHtmlSpec(data) {
   const landings = Array.isArray(data?.landings) ? data.landings : [];
+  const unproven = Array.isArray(data?.unproven) ? data.unproven : [];
   const completions = Array.isArray(data?.completions) ? data.completions : [];
   const xp = data?.xp && typeof data.xp === 'object' ? data.xp : { total: 0, receipts: [] };
   const receipts = Array.isArray(xp.receipts) ? xp.receipts : [];
@@ -277,18 +307,22 @@ function buildWeekReportHtmlSpec(data) {
     {
       type: 'panel',
       heading: 'landings',
-      sub: 'done tasks from the local task projection',
+      sub: 'done tasks whose git landing check passed; the rest are marked not proven',
       panel: {
         header: {
           title: 'task landings',
-          meta: `${landings.length} ${plural(landings.length, 'task')}`,
+          meta: `${landings.length} landed${unproven.length ? `, ${unproven.length} not proven` : ''}`,
         },
         rows: panelRows(
           landings.map((landing) => ({
             title: `${inlineText(landing.id, 'task')}: ${lowerText(landing.title, 'untitled task')}`,
             sub: lowerText(landing.source || landing.id, 'task'),
             sev: 0,
-          })),
+          })).concat(unproven.map((task) => ({
+            title: `${inlineText(task.id, 'task')}: ${lowerText(task.title, 'untitled task')}`,
+            sub: `not proven landed: ${lowerText(landingStatusText(task), 'unchecked')}`,
+            sev: 2,
+          }))),
           'no task landings found',
           'task projection had no done items in this window'
         ),

package/commands/run.js

@@ -223,12 +223,16 @@ function executePhase(phase, context, options = {}) {
   const prompt = buildRunPrompt(phase, context, priorCycleReview);
   const tmpFile = path.join(process.cwd(), '.run-prompt.tmp');
   fs.writeFileSync(tmpFile, prompt);
+  let endResource = () => null;
 
   try {
     const cmd = buildRunnerCommand({ promptFile: tmpFile, allowedTools: 'Bash,Read,Write,Edit,Glob,Grep' });
     // Strip CLAUDECODE env var to allow spawning from within a Claude Code session
     const env = { ...process.env };
     delete env.CLAUDECODE;
+    // Machine memory and load at both ends of the launch, so a phase killed
+    // with SIGKILL says whether the machine was short on memory.
+    endResource = require('../lib/engine-resource').startEngineRun(process.cwd(), { engine: 'runner', task: `run ${phase}` });
     const output = execPhaseCommandSync(cmd, {
       cwd: process.cwd(),
       encoding: 'utf8',
@@ -241,14 +245,17 @@ function executePhase(phase, context, options = {}) {
     });
 
     try { fs.unlinkSync(tmpFile); } catch {}
+    endResource();
     return output || '';
   } catch (err) {
     try { fs.unlinkSync(tmpFile); } catch {}
+    const resourceEnd = endResource(err);
     if (isPhaseTimeoutError(err)) {
       throw new Error(`${phase} timed out after ${timeout / 1000}s`);
     }
     if (isPhaseKillError(err)) {
-      throw new Error(`${phase} killed by ${err.signal || 'a signal'} before the ${timeout / 1000}s wall`);
+      const cause = resourceEnd && resourceEnd.cause ? `, ${resourceEnd.cause}` : '';
+      throw new Error(`${phase} killed by ${err.signal || 'a signal'} before the ${timeout / 1000}s wall${cause}`);
     }
     // execSync throws on non-zero exit but may still have output
     if (err.stdout) return err.stdout;
@@ -1068,4 +1075,4 @@ function diffRunLogs(args = []) {
   }
 }
 
-module.exports = { runAtris, hasWork, hasInboxOrBacklogWork, roadmapOpenCount, getRunLogDir, getRunLogPath, writePhaseToRunLog, appendMasterLoopReceipt, listRunLogs, pruneRunLogs, searchRunLogs, statsRunLogs, exportRunLogs, diffRunLogs, buildRunPrompt };
+module.exports = { runAtris, executePhase, hasWork, hasInboxOrBacklogWork, roadmapOpenCount, getRunLogDir, getRunLogPath, writePhaseToRunLog, appendMasterLoopReceipt, listRunLogs, pruneRunLogs, searchRunLogs, statsRunLogs, exportRunLogs, diffRunLogs, buildRunPrompt };

package/commands/scout.js

@@ -65,12 +65,16 @@ function runScout(question, { dir, model, engine, timeoutMs }) {
   return new Promise((resolve) => {
     const eng = ENGINES[engine];
     const [cmd, cmdArgs] = eng.argv(scoutPrompt(question, dir), model);
+    // Machine memory and load at both ends of the run, so a SIGKILL says
+    // whether it was the time limit, low memory, or an unknown cause.
+    const endResource = require('../lib/engine-resource').startEngineRun(process.cwd(), { engine, task: 'scout' });
     const child = spawn(cmd, cmdArgs, { cwd: dir, stdio: ['ignore', 'pipe', 'pipe'] });
 
     let out = '';
     let err = '';
     const timer = setTimeout(() => {
       child.kill('SIGKILL');
+      endResource({ code: 'ETIMEDOUT', signal: 'SIGKILL' });
       resolve({ question, ok: false, text: `timed out after ${timeoutMs / 1000}s` });
     }, timeoutMs);
 
@@ -78,11 +82,15 @@ function runScout(question, { dir, model, engine, timeoutMs }) {
     child.stderr.on('data', (d) => { err += d; });
     child.on('error', (e) => {
       clearTimeout(timer);
+      endResource(e);
       resolve({ question, ok: false, text: `failed to spawn ${cmd}: ${e.message}` });
     });
-    child.on('close', (code) => {
+    child.on('close', (code, signal) => {
       clearTimeout(timer);
+      // The child does not throw, so a failure is passed in the thrown shape.
+      const end = endResource(code === 0 ? null : { signal, stderr: err, message: `${cmd} exited ${code}` });
       if (code === 0 && out.trim()) resolve({ question, ok: true, text: eng.parse(out) });
+      else if (signal) resolve({ question, ok: false, text: `stopped by ${signal}${end && end.cause ? `; ${end.cause}` : ''}` });
       else resolve({ question, ok: false, text: (err.trim() || out.trim() || `exit ${code}`) });
     });
   });

package/commands/task.js

@@ -22,6 +22,7 @@ const {
 } = require('../lib/task-proof');
 const {
   candidatePolicyGate,
+  declaredCandidatePathValues,
   evaluateAutoAccept,
   isAgentCertified,
   isAutoCertifyVerifyCommandAllowed,
@@ -32,8 +33,10 @@ const {
   DENIED_TAGS,
 } = require('../lib/auto-accept-certified');
 const { evaluateAcceptVerify } = require('../lib/accept-verify-gate');
+const { proveTaskLanding } = require('../lib/landing-proof');
 const {
   taskExplanation,
+  explicitDoneLooksLike,
   explanationFieldsFromInput,
   explanationLines,
   taskApprovalControls,
@@ -253,6 +256,7 @@ atris task - durable local task state (SQLite, gitignored)
   atris task archive <id> --reason "..." [--from-failed]
                                            Sweep off-roadmap/duplicate work as archived (not failed);
                                            --from-failed opts in to relabel a fail-closed row (never done)
+  atris task reopen <id> [--reason "..."]  Send a done, waiting, failed, or archived task back to open
   atris task clear-done [--before <days>] [--dry-run] [--json]  Archive completed rows, oldest first
   atris task prune-test-junk [--yes] [--vacuum] [--json]
                                            Count rows test runs left from temp folders; --yes backs up the db, then removes them
@@ -1636,6 +1640,11 @@ function buildTaskStreams(tasks, goals) {
 // work, one clear way to ask for a change. Every enabled/blocked answer comes
 // from the existing review handoff, so this relabels what the certification
 // rules already allow and can never widen it.
+function joinPlainList(items) {
+  if (items.length <= 2) return items.join(' and ');
+  return `${items.slice(0, -1).join(', ')}, and ${items[items.length - 1]}`;
+}
+
 function taskApprovalFor(task, { reviewer = 'codex-review', hasExistingReviewFollowUp = null } = {}) {
   const metadata = task && task.metadata || {};
   const approvalStatus = (task && task.review && task.review.approval_status) || metadata.approval_status || null;
@@ -1658,12 +1667,16 @@ function taskApprovalFor(task, { reviewer = 'codex-review', hasExistingReviewFol
     ? reviewHandoffForTask(task, { suppressExistingFollowUp: true, hasExistingReviewFollowUp })
     : null;
   const planned = current === 'plan';
-  const planReady = planned && Boolean(
-    (metadata.task_goal || metadata.goal_objective || task.objective)
-    && metadata.exit_condition
-    && (metadata.verify || metadata.proof_needed)
-    && metadata.first_move
-  );
+  // Name only the plan parts that are really missing: a job given a check
+  // should not be told it still needs one, and a job that says what done
+  // looks like already has its finish line.
+  const planMissing = [
+    !(metadata.task_goal || metadata.goal_objective || task.objective) && 'a goal',
+    !(metadata.exit_condition || explicitDoneLooksLike(metadata)) && 'a finish line',
+    !(metadata.verify || metadata.proof_needed) && 'a check',
+    !metadata.first_move && 'a first move',
+  ].filter(Boolean);
+  const planReady = planned && planMissing.length === 0;
   const acceptEnabled = inReview ? handoffAllowsHumanAccept(handoff) : planReady;
   const planOwner = task && (task.claimed_by || taskAssignee(task)) || DEFAULT_OWNER;
   const acceptCommand = inReview
@@ -1682,7 +1695,7 @@ function taskApprovalFor(task, { reviewer = 'codex-review', hasExistingReviewFol
       ? 'The proof points at unfinished or unsafe work. Ask for a change before approval.'
       : 'The proof still needs its required checks before a person can approve it.'
     : planned
-      ? 'The plan still needs a goal, finish line, check, and first move before approval.'
+      ? `The plan still needs ${joinPlainList(planMissing)} before approval.`
       : current === 'backlog'
         ? 'This task still needs a complete plan before approval.'
         : current === 'do'
@@ -5454,11 +5467,12 @@ function autoAcceptCertifiedSmallReviews(taskDb, db, projection) {
       results.push({ ...evaluation, action: 'accept_failed', task_id: task.id, reason: accepted.reason });
       continue;
     }
-    stampAutoAcceptMetadata(taskDb, db, task.id, REVIEW_AUTO_ACCEPT_ACTOR, REVIEW_AUTO_ACCEPT_POLICY);
+    const landing = stampAutoAcceptMetadata(taskDb, db, task, REVIEW_AUTO_ACCEPT_ACTOR, REVIEW_AUTO_ACCEPT_POLICY);
     refreshCareerXpAfterReview(accepted.reviewed);
     results.push({
       ...evaluation,
       action: 'accepted',
+      landing,
       task_id: task.id,
       reward: accepted.reviewed.episode.reward.value,
     });
@@ -6243,6 +6257,27 @@ function cmdAdd(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const ws = taskDb.workspaceRoot();
+  // Filing a job that is already open or claimed hands back that job instead
+  // of making a copy. Work already handed in for review can be filed again.
+  const existing = taskDb.findUnfinishedTaskByTitle(db, { workspaceRoot: ws, title });
+  if (existing) {
+    const { projection, outPath } = writeDefaultProjection(taskDb, db);
+    const task = compactTaskFromProjection(projection, existing.id);
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: 'reused',
+        task_id: existing.id,
+        inserted: false,
+        operator_title_warning: null,
+        projection_path: outPath,
+        task,
+      });
+      return;
+    }
+    console.log(`${taskRef(task)}\t${existing.title}\t(already on the list, reused)`);
+    return;
+  }
   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
@@ -7898,9 +7933,13 @@ function taskDetail(taskDb, db, taskId) {
   };
 }
 
+// Printed lines get pasted into a shell. Plain words keep readable double
+// quotes; text a shell would act on ($, backticks, \, !) is single-quoted so
+// pasting it runs no command and keeps the words as written.
 function taskCommandQuote(value) {
-  const text = String(value || '').replace(/\s+/g, ' ').replace(/"/g, '\\"').trim();
-  return `"${text || '...'}"`;
+  const text = String(value || '').replace(/\s+/g, ' ').trim() || '...';
+  if (/[$`\\!]/.test(text)) return `'${text.replace(/'/g, `'\\''`)}'`;
+  return `"${text.replace(/"/g, '\\"')}"`;
 }
 
 function cleanPublicText(value, max = 500) {
@@ -9738,6 +9777,45 @@ function cmdArchive(args) {
   }
 }
 
+// Send a done, failed, or archived task back to open so it can be claimed
+// again. Review sign-offs are cleared; the old status and reason are kept.
+function cmdReopen(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) failTask('atris task reopen', 'missing_id', 'task id required');
+  const reason = textFlag(args, ['--reason']) || 'reopened';
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, id, 'atris task reopen');
+  const actor = String(flag(args, '--as') || DEFAULT_OWNER);
+  const result = taskDb.reopenTask(db, { id: taskId, actor, reason, fromReview: true });
+  if (!result.reopened) {
+    const detail = `reopen failed: ${taskId} ${result.reason}`;
+    if (wantsJson(args)) {
+      printJson({ ok: false, command: 'atris task reopen', reason: result.reason, task_id: taskId, detail });
+      process.exit(1);
+    }
+    console.error(detail);
+    process.exit(1);
+  }
+  const reopenedFrom = result.row && result.row.metadata && result.row.metadata.reopened_from || null;
+  const { projection, outPath } = writeDefaultProjection(taskDb, db);
+  const task = compactTaskFromProjection(projection, taskId);
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'reopened',
+      task_id: taskId,
+      reopened_from: reopenedFrom,
+      reason,
+      projection_path: outPath,
+      task,
+    });
+    return;
+  }
+  console.log(`reopened ${taskRef(task)}${reopenedFrom ? ` (was ${reopenedFrom})` : ''}: ${reason}`);
+}
+
 function taskCompletionTime(row) {
   const doneAt = Number(row && row.done_at);
   if (Number.isFinite(doneAt) && doneAt > 0) return doneAt;
@@ -10151,7 +10229,9 @@ function cmdReady(args) {
         ? `double-check complete; autoland will accept this ${whenLands}.`
         : needsExternalVerifier
         ? 'proof is ready; this verifier needs a second agent review because autoland cannot rerun it.'
-        : `proof is ready; autoland runs the second check and lands it ${whenLands}.`)
+        // Autoland accepts; landing is a git fact it proves separately. Do not
+        // promise "lands it" for work that may not be committed or merged.
+        : `proof is ready; autoland runs the second check and accepts it ${whenLands}; it lands once committed and merged.`)
       : (agentCertified
         ? 'double-check complete; ready to keep moving. XP is awarded only after the human approves the task.'
         : 'proof is ready; one more agent check before human approval. XP waits for the human.'),
@@ -10403,19 +10483,50 @@ async function cmdAccept(args) {
   if (publicSync && !publicSync.ok) process.exitCode = 1;
 }
 
-function stampAutoAcceptMetadata(taskDb, db, taskId, actor, policy) {
+// Every auto-accept passes through here, so this is where the record says
+// whether the work actually landed. Accepted is a review verdict; landed is a
+// fact about git, proven by lib/landing-proof.js or not claimed at all.
+// The check behind a landing is the one that actually ran: the verifier's
+// passing re-run first, then the check the proof names, then the builder's
+// recorded verify.
+function landingProofVerify(task) {
+  const metadata = task.metadata || {};
+  const cache = metadata.verify_cache;
+  if (cache && typeof cache === 'object' && cache.ok === true && String(cache.command || '').trim()) {
+    return String(cache.command).trim();
+  }
+  return certifyVerifyCandidate(task) || String(metadata.verify || '').trim();
+}
+
+function stampAutoAcceptMetadata(taskDb, db, task, actor, policy) {
+  const taskId = task.id;
   const row = taskDb.getTask(db, taskId);
-  if (!row) return;
+  if (!row) return null;
+  // The caller's task object was read before the re-check ran, so it lacks
+  // the verify_cache and certify stamps written since. Prove from the row as
+  // it stands now, keeping the caller's events and review for claimed paths.
+  const current = { ...task, ...row, metadata: row.metadata && typeof row.metadata === 'object' ? row.metadata : {} };
+  let landing;
+  try {
+    landing = proveTaskLanding(current, {
+      files: declaredCandidatePathValues(current),
+      verify: landingProofVerify(current),
+    });
+  } catch (err) {
+    landing = { status: 'unverified', reason: 'landing_proof_failed', detail: String((err && err.message) || err).slice(0, 200) };
+  }
   const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
   metadata.auto_accepted_at = new Date().toISOString();
   metadata.auto_accepted_by = actor;
   metadata.auto_accept_policy = policy;
+  metadata.landing = { ...landing, checked_at: metadata.auto_accepted_at };
   db.prepare(`
     UPDATE tasks
        SET metadata = ?,
            updated_at = ?
      WHERE id = ?
   `).run(JSON.stringify(metadata), Date.now(), taskId);
+  return landing;
 }
 
 function acceptReviewTask(taskDb, db, taskId, { actor, proof, reward, lesson = '', nextTask = '', autoAccepted = false }) {
@@ -10924,11 +11035,12 @@ function cmdAutoAcceptCertified(args) {
       results.push({ ...evaluation, action: 'accept_failed', reason: accepted.reason });
       continue;
     }
-    stampAutoAcceptMetadata(taskDb, db, task.id, actor, evaluation.policy);
+    const landing = stampAutoAcceptMetadata(taskDb, db, task, actor, evaluation.policy);
     refreshCareerXpAfterReview(accepted.reviewed);
     results.push({
       ...evaluation,
       action: 'accepted',
+      landing,
       reward: accepted.reviewed.episode.reward.value,
       task_id: task.id,
     });
@@ -11185,11 +11297,12 @@ function cmdSweep(args) {
       results.push({ ...evaluation, action: 'accept_failed', task_id: task.id, reason: accepted.reason });
       continue;
     }
-    stampAutoAcceptMetadata(taskDb, db, task.id, actor, evaluation.policy);
+    const landing = stampAutoAcceptMetadata(taskDb, db, task, actor, evaluation.policy);
     refreshCareerXpAfterReview(accepted.reviewed);
     results.push({
       ...evaluation,
       action: 'accepted',
+      landing,
       task_id: task.id,
       reward: accepted.reviewed.episode.reward.value,
     });
@@ -13475,6 +13588,7 @@ async function runTaskCommand(args) {
     case 'finish': return cmdFinish(rest);
     case 'fail':   return cmdDone([...rest, '--failed']);
     case 'archive': return cmdArchive(rest);
+    case 'reopen': return cmdReopen(rest);
     case 'clear-done': return cmdClearDone(rest);
     case 'prune-test-junk': return cmdPruneTestJunk(rest);
     case 'keep': return cmdKeep(rest);
@@ -13521,7 +13635,7 @@ const MUTATING_TASK_COMMANDS = new Set([
   'continue-work', 'continue', 'chat', 'note', 'say', 'retitle', 'tag', 'tags', 'step',
   'ready', 'result', 'accept', 'landing', 'land-review', 'auto-accept-certified',
   'auto-accept', 'sweep', 'audit', 'certify-verified', 'accept-group', 'revise',
-  'done', 'finish', 'fail', 'archive', 'clear-done', 'reap-mission-blockers', 'reap-blockers', 'relabel-archived', 'review', 'import',
+  'done', 'finish', 'fail', 'archive', 'reopen', 'clear-done', 'reap-mission-blockers', 'reap-blockers', 'relabel-archived', 'review', 'import',
   'setup', 'review-lane-act', 'review-act', 'act-review', 'review-lane-loop',
   'review-loop', 'loop-review', 'review-lane-run', 'review-run', 'run-review',
 ]);
@@ -13596,4 +13710,6 @@ module.exports = {
   taskDescriptionForCloud,
   taskReviewCleanEvidenceCommand,
   certifyVerifyCandidate,
+  landingProofVerify,
+  stampAutoAcceptMetadata,
 };